前言

Spring AOP 同样也定义好几大族接口，以辅助 AOP 的实现，这章节我们来解析 Pointcut 接口。Pointcut ，切点。它是对 Joinpoint 的匹配点的抽象，可以理解为 Advice 通过 Pointcut 找到 Joinpoint

接口

Pointcut

public interface Pointcut {// 类匹配ClassFilter getClassFilter();// 方法匹配MethodMatcher getMethodMatcher();// 匹配所有 Pointcut Pointcut TRUE = TruePointcut.INSTANCE;}

Pointcut 提供 ClassFilter 和 MethodMatcher 获取，事实上，它们可以组合使用

先来分别介绍 ClassFilter 和 MethodMatcher

ClassFilter

@FunctionalInterface
public interface ClassFilter {// 给定类是否匹配boolean matches(Class<?> clazz);// 匹配所有类ClassFilter TRUE = TrueClassFilter.INSTANCE;}

其子类需要重写 equals(Object) 和 hashCode() 方法

看一个实现类体会一下

AnnotationClassFilter

基于注解匹配类

// 检查给定类是否包含指定注解
public class AnnotationClassFilter implements ClassFilter {private final Class<? extends Annotation> annotationType;// 是否检查内部类private final boolean checkInherited;public AnnotationClassFilter(Class<? extends Annotation> annotationType) {this(annotationType, false);}public AnnotationClassFilter(Class<? extends Annotation> annotationType, boolean checkInherited) {Assert.notNull(annotationType, "Annotation type must not be null");this.annotationType = annotationType;this.checkInherited = checkInherited;}@Overridepublic boolean matches(Class<?> clazz) {return (this.checkInherited ? AnnotatedElementUtils.hasAnnotation(clazz, this.annotationType) :clazz.isAnnotationPresent(this.annotationType));}// hashCode equals toString 略}

MethodMatcher

public interface MethodMatcher {// 静态匹配boolean matches(Method method, Class<?> targetClass);// true 动态 false 静态boolean isRuntime();// 动态匹配boolean matches(Method method, Class<?> targetClass, Object... args);// 匹配所有方法MethodMatcher TRUE = TrueMethodMatcher.INSTANCE;}

静态匹配：不会对方法的参数进行匹配
动态匹配：会同时匹配方法的参数，不常用

看看它的实现类

DynamicMethodMatcher

public abstract class DynamicMethodMatcher implements MethodMatcher {@Overridepublic final boolean isRuntime() {return true;}@Overridepublic boolean matches(Method method, Class<?> targetClass) {return true;}
}

动态匹配抽象类，isRuntime() 和 matches(Method method, Class<?> targetClass) 都返回 true

DynamicMethodMatcherPointcut

public abstract class DynamicMethodMatcherPointcut extends DynamicMethodMatcher implements Pointcut {// 匹配所有类@Overridepublic ClassFilter getClassFilter() {return ClassFilter.TRUE;}@Overridepublic final MethodMatcher getMethodMatcher() {return this;}}

动态 MethodMatcher 和 Pointcut 的组合

IntroductionAwareMethodMatcher

public interface IntroductionAwareMethodMatcher extends MethodMatcher {// 若实现该接口，用该方法代替静态匹配方法boolean matches(Method method, Class<?> targetClass, boolean hasIntroductions);}

AspectJExpressionPointcut 实现了该接口，下边有介绍

StaticMethodMatcher

public abstract class StaticMethodMatcher implements MethodMatcher {@Overridepublic final boolean isRuntime() {return false;}@Overridepublic final boolean matches(Method method, Class<?> targetClass, Object... args) {throw new UnsupportedOperationException("Illegal MethodMatcher usage");}}

静态匹配的抽象类，故 isRuntime 为 false ，动态匹配方法抛出 UnsupportedOperationException 异常

AnnotationMethodMatcher

基于注解匹配方法

public class AnnotationMethodMatcher extends StaticMethodMatcher {private final Class<? extends Annotation> annotationType;private final boolean checkInherited;public AnnotationMethodMatcher(Class<? extends Annotation> annotationType) {this(annotationType, false);}public AnnotationMethodMatcher(Class<? extends Annotation> annotationType, boolean checkInherited) {Assert.notNull(annotationType, "Annotation type must not be null");this.annotationType = annotationType;this.checkInherited = checkInherited;}@Overridepublic boolean matches(Method method, Class<?> targetClass) {if (matchesMethod(method)) {return true;}// 目标类是否代理类if (Proxy.isProxyClass(targetClass)) {return false;}// 如果是接口方法，还会检查实现类Method specificMethod = AopUtils.getMostSpecificMethod(method, targetClass);return (specificMethod != method && matchesMethod(specificMethod));}// 根据 checkInherited 区分是否需要检查父类方法private boolean matchesMethod(Method method) {return (this.checkInherited ? AnnotatedElementUtils.hasAnnotation(method, this.annotationType) :method.isAnnotationPresent(this.annotationType));}// 其他方法略}

StaticMethodMatcherPointcut

public abstract class StaticMethodMatcherPointcut extends StaticMethodMatcher implements Pointcut {private ClassFilter classFilter = ClassFilter.TRUE;public void setClassFilter(ClassFilter classFilter) {this.classFilter = classFilter;}@Overridepublic ClassFilter getClassFilter() {return this.classFilter;}@Overridepublic final MethodMatcher getMethodMatcher() {return this;}}

静态 MethodMatcher 和 Pointcut 的组合。支持传入自定义的 ClassFilter ，默认 ClassFilter.TRUE

NameMatchMethodPointcut

public class NameMatchMethodPointcut extends StaticMethodMatcherPointcut implements Serializable {// 匹配模板private List<String> mappedNames = new ArrayList<>();public void setMappedName(String mappedName) {setMappedNames(mappedName);}public void setMappedNames(String... mappedNames) {this.mappedNames = new ArrayList<>(Arrays.asList(mappedNames));}// 添加模板方法public NameMatchMethodPointcut addMethodName(String name) {this.mappedNames.add(name);return this;}// 静态匹配，equals 或者正则匹配@Overridepublic boolean matches(Method method, Class<?> targetClass) {for (String mappedName : this.mappedNames) {if (mappedName.equals(method.getName()) || isMatch(method.getName(), mappedName)) {return true;}}return false;}// 支持形如 "xxx*", "*xxx" 的正则匹配protected boolean isMatch(String methodName, String mappedName) {return PatternMatchUtils.simpleMatch(mappedName, methodName);}// 略
}

基于方法名匹配，同时支持形如 “xxx*”, "*xxx"的模糊匹配，比如*Service 匹配所有 Serivce 结尾的方法。
看个 demo

@My
public class A {public void aaa() {}public void bbb() {}
}public class B {public void aaa() {}
}public class NameMatchMethodTest {public static void main(String[] args) {NameMatchMethodPointcut matchMethodPointcut= new NameMatchMethodPointcut();matchMethodPointcut.setClassFilter(new AnnotationClassFilter(My.class));matchMethodPointcut.setMappedName("*a");if (matchMethodPointcut.getClassFilter().matches(A.class)) {for (Method m : A.class.getDeclaredMethods()) {boolean match = matchMethodPointcut.matches(m, A.class);System.out.println("A类的方法" + m.getName() + (match ? " 匹配" : " 不匹配"));}} else {System.out.println("A类不匹配");}if (matchMethodPointcut.getClassFilter().matches(B.class)) {for (Method m : B.class.getDeclaredMethods()) {boolean match = matchMethodPointcut.matches(m, B.class);System.out.println("B类的方法" + m.getName() + (match ? " 匹配" : " 不匹配"));}} else {System.out.println("B类不匹配");}}
}// 结果
A类的方法aaa 匹配
A类的方法bbb 不匹配
B类不匹配

AbstractRegexpMethodPointcut

正则匹配的抽象类。模板方法设计模式，将匹配方法抽象出来由子类 （JdkRegexpMethodPointcut） 实现。

public abstract class AbstractRegexpMethodPointcut extends StaticMethodMatcherPointcutimplements Serializable {// 匹配正则private String[] patterns = new String[0];// 排除正则private String[] excludedPatterns = new String[0];public void setPattern(String pattern) {setPatterns(pattern);}public void setPatterns(String... patterns) {Assert.notEmpty(patterns, "'patterns' must not be empty");this.patterns = new String[patterns.length];for (int i = 0; i < patterns.length; i++) {this.patterns[i] = StringUtils.trimWhitespace(patterns[i]);}initPatternRepresentation(this.patterns);}public String[] getPatterns() {return this.patterns;}public void setExcludedPattern(String excludedPattern) {setExcludedPatterns(excludedPattern);}public void setExcludedPatterns(String... excludedPatterns) {Assert.notEmpty(excludedPatterns, "'excludedPatterns' must not be empty");this.excludedPatterns = new String[excludedPatterns.length];for (int i = 0; i < excludedPatterns.length; i++) {this.excludedPatterns[i] = StringUtils.trimWhitespace(excludedPatterns[i]);}initExcludedPatternRepresentation(this.excludedPatterns);}public String[] getExcludedPatterns() {return this.excludedPatterns;}// 匹配方法，给定类找不到回去该方法的当前类找@Overridepublic boolean matches(Method method, Class<?> targetClass) {return (matchesPattern(ClassUtils.getQualifiedMethodName(method, targetClass)) ||(targetClass != method.getDeclaringClass() &&matchesPattern(ClassUtils.getQualifiedMethodName(method, method.getDeclaringClass()))));}// 匹配与排除protected boolean matchesPattern(String signatureString) {for (int i = 0; i < this.patterns.length; i++) {boolean matched = matches(signatureString, i);if (matched) {for (int j = 0; j < this.excludedPatterns.length; j++) {boolean excluded = matchesExclusion(signatureString, j);if (excluded) {return false;}}return true;}}return false;}// 模板方法，初始化匹配正则protected abstract void initPatternRepresentation(String[] patterns) throws IllegalArgumentException;// 模板方法，初始化排除正则protected abstract void initExcludedPatternRepresentation(String[] patterns) throws IllegalArgumentException;// 模板方法，正则匹配protected abstract boolean matches(String pattern, int patternIndex);// 模板方法，排除正则匹配protected abstract boolean matchesExclusion(String pattern, int patternIndex);// 略}

JdkRegexpMethodPointcut

实现类，方法清晰明了，Pattern 类解析匹配正则。

public class JdkRegexpMethodPointcut extends AbstractRegexpMethodPointcut {private Pattern[] compiledPatterns = new Pattern[0];private Pattern[] compiledExclusionPatterns = new Pattern[0];@Overrideprotected void initPatternRepresentation(String[] patterns) throws PatternSyntaxException {this.compiledPatterns = compilePatterns(patterns);}@Overrideprotected void initExcludedPatternRepresentation(String[] excludedPatterns) throws PatternSyntaxException {this.compiledExclusionPatterns = compilePatterns(excludedPatterns);}@Overrideprotected boolean matches(String pattern, int patternIndex) {Matcher matcher = this.compiledPatterns[patternIndex].matcher(pattern);return matcher.matches();}@Overrideprotected boolean matchesExclusion(String candidate, int patternIndex) {Matcher matcher = this.compiledExclusionPatterns[patternIndex].matcher(candidate);return matcher.matches();}private Pattern[] compilePatterns(String[] source) throws PatternSyntaxException {Pattern[] destination = new Pattern[source.length];for (int i = 0; i < source.length; i++) {destination[i] = Pattern.compile(source[i]);}return destination;}
}

看看 demo

public class A {public void aaa111() {}public void aaabb() {}public void bbb() {}
}public class JdkRegrexpMthodTest {public static void main(String[] args) {JdkRegexpMethodPointcut jdkRegexpMethodPointcut= new JdkRegexpMethodPointcut();jdkRegexpMethodPointcut.setPattern(".*a+.+$");jdkRegexpMethodPointcut.setExcludedPattern(".*a+\\d+$");for (Method m : A.class.getDeclaredMethods()) {boolean match = jdkRegexpMethodPointcut.matches(m, A.class);System.out.println("A类的方法" + m.getName() + (match ? " 匹配" : " 不匹配"));}}
}// 结果
A类的方法aaa111 不匹配
A类的方法bbb 不匹配
A类的方法aaabb 匹配

Pointcut

对 MethodMatcher 和 ClassFilter 的接口和部分实现类做了了解之后，回头再来看看 Pointcut 下的几个实现类

ComposablePointcut

public class ComposablePointcut implements Pointcut, Serializable {private static final long serialVersionUID = -2743223737633663832L;private ClassFilter classFilter;private MethodMatcher methodMatcher;public ComposablePointcut() {this.classFilter = ClassFilter.TRUE;this.methodMatcher = MethodMatcher.TRUE;}public ComposablePointcut(Pointcut pointcut) {Assert.notNull(pointcut, "Pointcut must not be null");this.classFilter = pointcut.getClassFilter();this.methodMatcher = pointcut.getMethodMatcher();}public ComposablePointcut(ClassFilter classFilter) {Assert.notNull(classFilter, "ClassFilter must not be null");this.classFilter = classFilter;this.methodMatcher = MethodMatcher.TRUE;}public ComposablePointcut(MethodMatcher methodMatcher) {Assert.notNull(methodMatcher, "MethodMatcher must not be null");this.classFilter = ClassFilter.TRUE;this.methodMatcher = methodMatcher;}public ComposablePointcut(ClassFilter classFilter, MethodMatcher methodMatcher) {Assert.notNull(classFilter, "ClassFilter must not be null");Assert.notNull(methodMatcher, "MethodMatcher must not be null");this.classFilter = classFilter;this.methodMatcher = methodMatcher;}// 借助 ClassFilters 合并 ClassFilterpublic ComposablePointcut union(ClassFilter other) {this.classFilter = ClassFilters.union(this.classFilter, other);return this;}// 借助 ClassFilters 取 ClassFilter 交集public ComposablePointcut intersection(ClassFilter other) {this.classFilter = ClassFilters.intersection(this.classFilter, other);return this;}// 借助 ClassFilters 合并 MethodMatcherpublic ComposablePointcut union(MethodMatcher other) {this.methodMatcher = MethodMatchers.union(this.methodMatcher, other);return this;}// 借助 ClassFilters 取 MethodMatcher 交集public ComposablePointcut intersection(MethodMatcher other) {this.methodMatcher = MethodMatchers.intersection(this.methodMatcher, other);return this;}// 借助 ClassFilters 分别合并给定 Pointcut 的 methodMatcher 和 classFilterpublic ComposablePointcut union(Pointcut other) {this.methodMatcher = MethodMatchers.union(this.methodMatcher, this.classFilter, other.getMethodMatcher(), other.getClassFilter());this.classFilter = ClassFilters.union(this.classFilter, other.getClassFilter());return this;}// 借助 ClassFilters 做给定 Pointcut 的 methodMatcher 和 classFilter 的交集public ComposablePointcut intersection(Pointcut other) {this.classFilter = ClassFilters.intersection(this.classFilter, other.getClassFilter());this.methodMatcher = MethodMatchers.intersection(this.methodMatcher, other.getMethodMatcher());return this;}@Overridepublic ClassFilter getClassFilter() {return this.classFilter;}@Overridepublic MethodMatcher getMethodMatcher() {return this.methodMatcher;}// 略}

组合实现类，包含各种对 ClassFilter，MethodMatcher 和 Pointcut 的组合操作

AnnotationMatchingPointcut

public class AnnotationMatchingPointcut implements Pointcut {private final ClassFilter classFilter;private final MethodMatcher methodMatcher;public AnnotationMatchingPointcut(Class<? extends Annotation> classAnnotationType) {this(classAnnotationType, false);}// 构造 ClassFilterpublic AnnotationMatchingPointcut(Class<? extends Annotation> classAnnotationType, boolean checkInherited) {this.classFilter = new AnnotationClassFilter(classAnnotationType, checkInherited);this.methodMatcher = MethodMatcher.TRUE;}public AnnotationMatchingPointcut(@Nullable Class<? extends Annotation> classAnnotationType,@Nullable Class<? extends Annotation> methodAnnotationType) {this(classAnnotationType, methodAnnotationType, false);}public AnnotationMatchingPointcut(@Nullable Class<? extends Annotation> classAnnotationType,@Nullable Class<? extends Annotation> methodAnnotationType, boolean checkInherited) {// classAnnotationType 为 null 则以 methodAnnotationType 构造 AnnotationCandidateClassFilterif (classAnnotationType != null) {this.classFilter = new AnnotationClassFilter(classAnnotationType, checkInherited);}else {this.classFilter = new AnnotationCandidateClassFilter(methodAnnotationType);}// 构造 MethodMatcherif (methodAnnotationType != null) {this.methodMatcher = new AnnotationMethodMatcher(methodAnnotationType, checkInherited);}else {this.methodMatcher = MethodMatcher.TRUE;}}// 略// 传入的类注解为空时构造此 ClassFilterpublic static AnnotationMatchingPointcut forClassAnnotation(Class<? extends Annotation> annotationType) {Assert.notNull(annotationType, "Annotation type must not be null");return new AnnotationMatchingPointcut(annotationType);}public static AnnotationMatchingPointcut forMethodAnnotation(Class<? extends Annotation> annotationType) {Assert.notNull(annotationType, "Annotation type must not be null");return new AnnotationMatchingPointcut(null, annotationType);}private static class AnnotationCandidateClassFilter implements ClassFilter {private final Class<? extends Annotation> annotationType;AnnotationCandidateClassFilter(Class<? extends Annotation> annotationType) {this.annotationType = annotationType;}@Overridepublic boolean matches(Class<?> clazz) {return AnnotationUtils.isCandidateClass(clazz, this.annotationType);}// 略}
}

注解匹配的 Pointcut，可以理解为上面介绍的 AnnotationClassFilter 和 AnnotationMethodMatcher 的组合。

ExpressionPointcut

public interface ExpressionPointcut extends Pointcut {// 表达式获取@NullableString getExpression();}

表达式（其实就是 AspectJ 表达式嘛）匹配的接口

AbstractExpressionPointcut

public abstract class AbstractExpressionPointcut implements ExpressionPointcut, Serializable {@Nullableprivate String location;@Nullableprivate String expression;public void setLocation(@Nullable String location) {this.location = location;}@Nullablepublic String getLocation() {return this.location;}public void setExpression(@Nullable String expression) {this.expression = expression;try {onSetExpression(expression);}catch (IllegalArgumentException ex) {// ...}}// 允许子类拓展protected void onSetExpression(@Nullable String expression) throws IllegalArgumentException {}@Override@Nullablepublic String getExpression() {return this.expression;}}

表达式匹配 Pointcut 的抽象类，提供表达式位置信息和相关操作，提供一个模板方法 onSetExpression 供子类实现。

AspectJExpressionPointcut

很关键的一个类，对 Aspect 切点表达式匹配的实现。

它是 Pointcut， ClassFilter 和 MethodMatcher 的组合， 同时实现了 BeanFactoryAware（可以跟 bean工厂 互动）

public class AspectJExpressionPointcut extends AbstractExpressionPointcutimplements ClassFilter, IntroductionAwareMethodMatcher, BeanFactoryAware

它支持如下 AspectJ 原语

	static {SUPPORTED_PRIMITIVES.add(PointcutPrimitive.EXECUTION);SUPPORTED_PRIMITIVES.add(PointcutPrimitive.ARGS);SUPPORTED_PRIMITIVES.add(PointcutPrimitive.REFERENCE);SUPPORTED_PRIMITIVES.add(PointcutPrimitive.THIS);SUPPORTED_PRIMITIVES.add(PointcutPrimitive.TARGET);SUPPORTED_PRIMITIVES.add(PointcutPrimitive.WITHIN);SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_ANNOTATION);SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_WITHIN);SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_ARGS);SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_TARGET);}

我们最常用的应该就是 execution 了

事实上，最终对表达式的解析和匹配还是委托给 AspectJ 的相关类来实现的

import org.aspectj.weaver.patterns.NamePattern;
import org.aspectj.weaver.reflect.ReflectionWorld.ReflectionWorldException;
import org.aspectj.weaver.reflect.ShadowMatchImpl;
import org.aspectj.weaver.tools.ContextBasedMatcher;
import org.aspectj.weaver.tools.FuzzyBoolean;
import org.aspectj.weaver.tools.JoinPointMatch;
import org.aspectj.weaver.tools.MatchingContext;
import org.aspectj.weaver.tools.PointcutDesignatorHandler;
import org.aspectj.weaver.tools.PointcutExpression;
import org.aspectj.weaver.tools.PointcutParameter;
import org.aspectj.weaver.tools.PointcutParser;
import org.aspectj.weaver.tools.PointcutPrimitive;
import org.aspectj.weaver.tools.ShadowMatch;

具体方法就不一一解读了。写个 demo 体验一下

public class AService implements A {public void a() {}
}public class BService implements B {public void b() {}
}public class Test2 {@Testpublic void test1() {AspectJExpressionPointcut aspectJExpressionPointcut= new AspectJExpressionPointcut();aspectJExpressionPointcut.setExpression("execution(* a())");System.out.println("A类：" + aspectJExpressionPointcut.matches(AService.class));System.out.println("B类：" + aspectJExpressionPointcut.matches(BService.class));System.out.println("================================");for (Method m : AService.class.getDeclaredMethods()) {System.out.println(m.getName() + ": " +aspectJExpressionPointcut.matches(m, m.getDeclaringClass()));}System.out.println("================================");for (Method m : BService.class.getDeclaredMethods()) {System.out.println(m.getName() + ": " +aspectJExpressionPointcut.matches(m, m.getDeclaringClass()));}}
}// 结果
A类：true
B类：true
================================
a: true
================================
b: false

类图

Pointcut

ClassFilter

MethodMatcher

总结

这一章节涉及的类比较多一点，主要对 Pointcut 体系抽象做了整体的了解，它可以与 ClassFilter 和 MethodMatcher 组合，来实现对类、方法的匹配。其中 AspectJExpressionPointcut 就是对基于注解的 AspectJ 的 切点表达式 的匹配实现。下一章节，我们再对 Spring 下的 Advisor 抽象进行解读。

上一篇：【源码】Spring AOP 3 Joinpoint
下一篇：【源码】Spring AOP 5 Advisor

参考：

【小家Spring】Spring AOP核心类Pointcut解析，对PointcutExpression切点表达式解析原理分析（以AspectJExpressionPointcut为例）