Source code
package org.springframework.aop.support;
import java.io.Serializable;
import org.aopalliance.aop.Advice;
import org.jspecify.annotations.Nullable;
import org.springframework.aop.Pointcut;
import org.springframework.util.ObjectUtils;
/**
* Convenient class for regexp method pointcuts that hold an Advice,
* making them an {@link org.springframework.aop.Advisor}.
*
* <p>Configure this class using the "pattern" and "patterns"
* pass-through properties. These are analogous to the pattern
* and patterns properties of {@link AbstractRegexpMethodPointcut}.
*
* <p>Can delegate to any {@link AbstractRegexpMethodPointcut} subclass.
* By default, {@link JdkRegexpMethodPointcut} will be used. To choose
* a specific one, override the {@link #createPointcut} method.
*
* @author Rod Johnson
* @author Juergen Hoeller
* @see #setPattern
* @see #setPatterns
* @see JdkRegexpMethodPointcut
*/
@SuppressWarnings("serial")
public class RegexpMethodPointcutAdvisor extends AbstractGenericPointcutAdvisor {
private String @Nullable [] patterns;
private @Nullable AbstractRegexpMethodPointcut pointcut;
private final Object pointcutMonitor = new SerializableMonitor();
/**
* Create an empty RegexpMethodPointcutAdvisor.
* @see #setPattern
* @see #setPatterns
* @see #setAdvice
*/
public RegexpMethodPointcutAdvisor() {
}
/**
* Create a RegexpMethodPointcutAdvisor for the given advice.
* The pattern still needs to be specified afterwards.
* @param advice the advice to use
* @see #setPattern
* @see #setPatterns
*/
public RegexpMethodPointcutAdvisor(Advice advice) {
setAdvice(advice);
}
/**
* Create a RegexpMethodPointcutAdvisor for the given advice.
* @param pattern the pattern to use
* @param advice the advice to use
*/
public RegexpMethodPointcutAdvisor(String pattern, Advice advice) {
setPattern(pattern);
setAdvice(advice);
}
/**
* Create a RegexpMethodPointcutAdvisor for the given advice.
* @param patterns the patterns to use
* @param advice the advice to use
*/
public RegexpMethodPointcutAdvisor(String[] patterns, Advice advice) {
setPatterns(patterns);
setAdvice(advice);
}
/**
* Set the regular expression defining methods to match.
* <p>Use either this method or {@link #setPatterns}, not both.
* @see #setPatterns
*/
public void setPattern(String pattern) {
setPatterns(pattern);
}
/**
* Set the regular expressions defining methods to match.
* To be passed through to the pointcut implementation.
* <p>Matching will be the union of all these; if any of the
* patterns matches, the pointcut matches.
* @see AbstractRegexpMethodPointcut#setPatterns
*/
public void setPatterns(String... patterns) {
this.patterns = patterns;
}
/**
* Initialize the singleton Pointcut held within this Advisor.
*/
@Override
public Pointcut getPointcut() {
synchronized (this.pointcutMonitor) {
if (this.pointcut == null) {
this.pointcut = createPointcut();
if (this.patterns != null) {
this.pointcut.setPatterns(this.patterns);
}
}
return this.pointcut;
}
}
/**
* Create the actual pointcut: By default, a {@link JdkRegexpMethodPointcut}
* will be used.
* @return the Pointcut instance (never {@code null})
*/
protected AbstractRegexpMethodPointcut createPointcut() {
return new JdkRegexpMethodPointcut();
}
@Override
public String toString() {
return getClass().getName() + ": advice [" + getAdvice() +
"], pointcut patterns " + ObjectUtils.nullSafeToString(this.patterns);
}
/**
* Empty class used for a serializable monitor object.
*/
private static class SerializableMonitor implements Serializable {
}
}
Run 1
The code is highly readable due to its clear structure, consistent formatting, and comprehensive Javadoc documentation. It uses flat nesting with only one level of synchronization, and each method performs a single logical action. Constructors are concise and delegate appropriately. The class follows Spring conventions, with fields clearly named and annotated for nullability. The use of a dedicated monitor object for synchronization is a good practice. Minor deductions: the empty constructor adds slight length, and the toString method could be marginally clearer, but overall the code is well-organized and easy to understand.
Run 2
The code is clear, well-structured, and maintains a flat, readable flow. Class responsibilities are obvious, and each method has a single purpose. Javadocs are thorough, and the use of a dedicated monitor object for synchronization is clear. Minimal nesting and concise implementation contribute to high readability.
Run 3
The code is well-structured with clear separation of constructors, setters, and overridden methods. Javadoc comments explain intent thoroughly. Nesting is minimal—only one synchronized block with a single inner if statement. Action granularity is generally good, with one logical operation per line. Reading flow follows a natural progression from class declaration through constructors, setters, pointcut initialization, and utility methods. Deductions: the synchronized lazy-initialization pattern adds slight complexity, and the setPattern/setPatterns delegation creates minor indirection. Some lines in toString() are long. Overall, this is production-quality Spring framework code with excellent documentation—readable for experienced developers, though beginners may find the pattern-pass-through and lazy singleton pattern slightly dense.
Run 1
Code Structure: Fields, constructors, configuration methods, pointcut initialization, and helpers are logically organized. Nesting: Most methods are flat; getPointcut has three nested levels for synchronization and conditional initialization, but remains easy to follow. Clarity of intent: Descriptive names and useful Javadoc clearly explain pattern configuration, defaults, and extension points. Code length: Implementation is concise, though repetitive constructor documentation and generous whitespace increase visual length. Action granularity: Each statement performs a single clear action, with no compressed multi-action lines. Reading flow: Consistent formatting and straightforward delegation support natural reading. Minor friction comes from the unusual array nullability annotation syntax and the need to understand inherited advisor behavior.
Run 2
Code Structure: Fields, constructors, configuration methods, and implementation details are logically grouped. Nesting: Most methods are flat; getPointcut has three nested blocks for synchronization and lazy initialization, but remains easy to follow. Clarity of intent: Descriptive names and useful Javadoc clearly explain configuration, delegation, and initialization. Code length: Implementation is concise, although repeated constructor documentation and generous spacing increase scanning length. Action granularity: Statements generally perform one action per line; the wrapped toString expression is still understandable. Reading flow: Consistent formatting and progression from construction to configuration to behavior support natural reading. Minor friction comes from framework-specific types and the unusual array nullability annotation syntax.
Run 3
Code Structure: Fields, constructors, configuration methods, and implementation methods are logically grouped, with a clearly isolated monitor class. Nesting: Most methods are flat; getPointcut has moderate, justified nesting for synchronized lazy initialization and optional pattern configuration. Clarity of intent: Descriptive names and useful Javadoc explain the advisor, pattern matching, and extension point, although framework inheritance requires some background knowledge. Code length: Implementation methods are concise, but repeated constructor documentation and generous spacing slightly increase scanning effort. Action granularity: Statements generally perform one action per line; constructor initialization steps are cleanly separated. Reading flow: The progression from construction through configuration to pointcut creation is natural and consistent. The wrapped toString expression and specialized nullable-array syntax introduce minor visual friction.