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 with clear class structure, well-documented Javadoc, and logical organization of fields, constructors, and methods. The class follows Spring conventions with minimal nesting (only one synchronized block and one null check condition). Intent is explicit through comprehensive documentation and descriptive method names. Code length is appropriate - concise without being overly compact. Each action is clearly separated per line, and the reading flow follows a natural progression from constructors to setters to the pointcut initialization logic. The use of a serializable monitor object for synchronization is well-documented and properly encapsulated. Minor deductions for slight complexity in the lazy initialization pattern and the multiple constructor overloads, but overall this represents exemplary Java code.
Run 2
The code is well-structured with clear separation of concerns, following Spring framework conventions. It has minimal nesting (only one synchronized block with a null check). Intent is clear through descriptive method names and comprehensive Javadoc. The class is concise and focused on a single responsibility. Each action is on its own line, and the reading flow is natural, moving from fields to constructors to setters to business logic. The only minor deductions are for the somewhat redundant constructors and the SerializableMonitor pattern which, while idiomatic for Spring, adds slight complexity.
Run 3
The code is highly readable with clear structure and intent. The class follows a logical organization: fields, constructors, setters, and overridden methods, each with concise Javadoc explaining purpose and usage. Nesting is minimal—only a single synchronized block with an if-check inside, which is appropriate. Clarity of intent is strong due to descriptive method/field names and documentation, though the lazy initialization pattern with a monitor object may require brief study. Code length is reasonable and not unnecessarily verbose, with each method performing one focused action. Action granularity is good, with one primary operation per line. Reading flow is natural, from field declarations through constructors to behavior methods. Minor deductions stem from slight complexity around the synchronized initialization pattern and the use of a custom serializable monitor rather than relying on simpler synchronization on the pointcut field, which adds cognitive overhead without major benefit.
Run 1
Code Structure: Fields, constructors, configuration methods, pointcut initialization, and helpers are logically grouped. Nesting: Most methods are flat; getPointcut has three nested blocks for synchronization and conditional initialization, but remains easy to follow. Clarity of intent: Descriptive names and helpful Javadocs clearly explain pattern matching, delegation, and lazy initialization. The fact that changing patterns after initialization does not update the existing pointcut is less obvious. Code length: Implementation is concise, although constructor documentation and whitespace add some repetition. Action granularity: Each statement performs a focused action, with no compressed multi-statement lines. Reading flow: Consistent formatting and method ordering support natural reading; the wrapped toString expression and specialized nullable-array annotation introduce minor friction.
Run 2
Code Structure: Fields, constructors, configuration methods, and pointcut creation are logically grouped with consistent spacing. Nesting: Most methods are flat; getPointcut has modest nesting from synchronization and two conditional checks. Clarity of intent: Descriptive names and thorough Javadoc clearly explain pattern configuration, lazy initialization, and the serializable monitor. Code length: Implementations are concise, though repeated constructor documentation and generous whitespace increase scanning length slightly. Action granularity: Statements generally perform one action per line; the wrapped toString expression remains straightforward. Reading flow: The progression from construction to configuration and initialization is natural. Minor readability costs include the unusual array nullability annotation syntax and the need to understand inherited advisor behavior.
Run 3
Code Structure: Fields, constructors, configuration methods, pointcut initialization, and helpers are logically grouped. Nesting: Most methods are flat; getPointcut has moderate nesting from synchronization and two conditionals, but remains easy to follow. Clarity of intent: Descriptive names and useful Javadoc clearly explain configuration, lazy initialization, and the serializable monitor. Code length: Implementation methods are concise, though repeated constructor documentation and generous spacing increase overall length. Action granularity: Statements generally perform one action per line, with no compressed logic. Reading flow: Consistent formatting and straightforward delegation provide a natural progression. Minor friction comes from the nested initialization block, the wrapped toString expression, and reliance on superclass behavior.