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 well-structured, with a clear class hierarchy, consistent formatting, and comprehensive Javadoc that explains intent. Nesting is minimal—only a single synchronized block with a simple conditional. Each method performs one logical action, and lines are appropriately granular. Reading flow is natural: fields, constructors, setters, then overridden methods. The main readability weaknesses are minor: the lazy initialization inside synchronized is slightly dense, and the toString concatenation spans multiple lines, but neither significantly harms clarity. Overall, very readable.
Run 3
The code is well-structured and highly readable. It has a clear class hierarchy, concise methods, and comprehensive Javadoc comments that explain intent. Nesting is minimal, limited to a single synchronized block and a simple null check. The action granularity is good—most lines perform one logical operation. The reading flow is natural, with constructors, setters, core logic, and utility methods in a logical order. Minor deductions are for the slightly awkward placement of type annotations (`String @Nullable []`), the empty default constructor, and the small amount of boilerplate around the serializable monitor, but overall it is very maintainable Spring-style code.
Run 1
Code Structure: Fields, constructors, configuration methods, and implementation methods are logically grouped, with a small helper class last. Nesting: Most methods are flat; getPointcut has moderate nesting for synchronization and lazy initialization. Clarity of intent: Descriptive names and useful Javadoc clearly explain pattern configuration, default implementation, and extension points. The fact that changing patterns after initialization does not update the pointcut is less obvious. Code length: Implementation methods are concise, though constructor documentation is somewhat repetitive. Action granularity: Statements generally perform one action per line, making state changes easy to follow. Reading flow: Consistent formatting and method ordering support natural reading; extra blank lines and the wrapped toString expression add only minor friction.
Run 2
Code Structure: Fields, constructors, configuration methods, pointcut creation, and utilities are logically grouped. Nesting: Most methods are flat; getPointcut has modest nesting for synchronization and lazy initialization. Clarity of intent: Descriptive names and useful Javadoc clearly explain configuration, delegation, and defaults. Code length: Implementation is concise, although repeated constructor documentation and generous spacing increase its visual length. Action granularity: Statements generally perform one action per line; the wrapped toString expression remains understandable. Reading flow: Consistent formatting and a natural progression from construction to configuration to behavior make the class easy to follow. Minor friction comes from framework-specific terminology, the unusual array nullability annotation placement, and the nested initialization logic.
Run 3
Code Structure: Fields, constructors, configuration methods, pointcut initialization, and the helper class 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 thorough Javadoc clearly explain configuration, delegation, and lazy initialization. Code length: Implementations are concise, although repeated constructor documentation and generous spacing add some bulk. Action granularity: Statements generally perform one action per line; the wrapped toString expression remains understandable. Reading flow: Consistent formatting and ordering support natural top-to-bottom reading. Minor readability costs include the unusual array nullability annotation syntax and reliance on inherited behavior and framework types.