Spring AOP 中，切点有多少种定义方式？

最新推荐文章于 2024-05-15 09:41:25 发布
最新推荐文章于 2024-05-15 09:41:25 发布
阅读量1k 收藏
点赞数
文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21305943/article/details/131972702
版权

在 Spring AOP 中，我们最常用的切点定义方式主要是两种：

  1. 使用 execution 进行无侵入拦截。
  2. 使用注解进行拦截。

这应该是是小伙伴们日常工作中使用最多的两种切点定义方式了。但是除了这两种还有没有其他的呢？今天松哥就来和大家聊一聊这个话题。

1. Pointcut 分类

来看下 Pointcut 的定义：

public interface Pointcut {
  ClassFilter getClassFilter();
  MethodMatcher getMethodMatcher();
  Pointcut TRUE = TruePointcut.INSTANCE;
}

从方法名上就能看出来，getClassFilter 进行类的过滤，getMethodMatcher 进行方法过滤。通过过滤 Class 和过滤 Method，我们就能够锁定一个拦截对象了。

再来看下 Pointcut 类的继承关系图：

可以看到，其实实现类不算多，大部分看名字其实都能猜出来是干嘛的，这些实现类我们大致上又可以分为六大类：

  1. 静态方法切点：StaticMethodMatcherPointcut 表示静态方法切点的抽象基类，默认情况下匹配所有的类，然后通过不同的规则去匹配不同的方法。
  2. 动态方法切点：DynamicMethodMatcherPointcut 表示动态方法切点的抽象基类，默认情况下它匹配所有的类，然后通过不同的规则匹配不同的方法，这个有点类似于 StaticMethodMatcherPointcut，不同的是，StaticMethodMatcherPointcut 仅对方法签名进行匹配并且仅匹配一次，而 DynamicMethodMatcherPointcut 会在运行期间检查方法入参的值，由于每次传入的参数可能都不一样，所以没调用都要去判断，因此就导致 DynamicMethodMatcherPointcut 的性能差一些。
  3. 注解切点：AnnotationMatchingPointcut。
  4. 表达式切点：ExpressionPointcut。
  5. 流程切点：ControlFlowPointcut。
  6. 复合切点：ComposablePointcut。

除了上面这六个之外，另外还有一个落单的 TruePointcut，这个从名字上就能看出来是拦截一切。

所以满打满算，有七种类型的切点，接下来我们就来逐个分析一下。

2. TruePointcut

这个实现类从名字上看就是拦截所有，拦截一切，我们来看下这个类怎么做的：

final class TruePointcut implements Pointcut, Serializable {
    //...
  @Override
  public ClassFilter getClassFilter() {
    return ClassFilter.TRUE;
  }

  @Override
  public MethodMatcher getMethodMatcher() {
    return MethodMatcher.TRUE;
  }
    //...
}

首先小伙伴们注意，这个类不是 public 的，所以意味着我们自己开发中没法直接使用这个切点。然后大家看到，在 getClassFilter 和 getMethodMatcher 方法中，这里都返回了对应的 TRUE，而这两个 TRUE 实现非常简单，就是在需要做比对的地方，不做任何比对，直接返回 true 即可，这就导致了最终将所有东西都拦截下来。

3. StaticMethodMatcherPointcut


StaticMethodMatcherPointcut 仅对方法名签名（包括方法名和入参类型及顺序）进行匹配，静态匹配仅判断一次。

public abstract class StaticMethodMatcherPointcut extends StaticMethodMatcher implements Pointcut {

  private ClassFilter classFilter = ClassFilter.TRUE;


  /**
   * Set the {@link ClassFilter} to use for this pointcut.
   * Default is {@link ClassFilter#TRUE}.
   */
  public void setClassFilter(ClassFilter classFilter) {
    this.classFilter = classFilter;
  }

  @Override
  public ClassFilter getClassFilter() {
    return this.classFilter;
  }


  @Override
  public final MethodMatcher getMethodMatcher() {
    return this;
  }

}

可以看到，这里类的匹配默认就是返回 true，方法的匹配则返回当前对象，也就是看具体的实现。


StaticMethodMatcherPointcut 有几个写好的实现类，我们来看下。

3.1 SetterPointcut

看名字就知道，这个可以用来拦截所有的 set 方法：

private static class SetterPointcut extends StaticMethodMatcherPointcut implements Serializable {
  public static final SetterPointcut INSTANCE = new SetterPointcut();
  @Override
  public boolean matches(Method method, Class<?> targetClass) {
    return (method.getName().startsWith("set") &&
        method.getParameterCount() == 1 &&
        method.getReturnType() == Void.TYPE);
  }
  private Object readResolve() {
    return INSTANCE;
  }
  @Override
  public String toString() {
    return "Pointcuts.SETTERS";
  }
}

可以看到，方法的匹配就是断定当前方法是否为 set 方法，要求方法名以 set 开始，方法只有一个参数并且方法返回值为 null，精准定位到一个 set 方法。

举一个使用的例子，如下：

ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.setTarget(new CalculatorImpl());
proxyFactory.addInterface(ICalculator.class);
proxyFactory.addAdvisor(new PointcutAdvisor() {
    @Override
    public Pointcut getPointcut() {
        return Pointcuts.SETTERS;
    }
    @Override
    public Advice getAdvice() {
        return new MethodInterceptor() {
            @Override
            public Object invoke(MethodInvocation invocation) throws Throwable {
                Method method = invocation.getMethod();
                String name = method.getName();
                System.out.println(name + " 方法开始执行了。。。");
                Object proceed = invocation.proceed();
                System.out.println(name + " 方法执行结束了。。。");
                return proceed;
            }
        };
    }
    @Override
    public boolean isPerInstance() {
        return true;
    }
});
ICalculator calculator = (ICalculator) proxyFactory.getProxy();
calculator.setA(5);

由于 SetterPointcut 是私有的，无法直接 new，可以通过工具类 Pointcuts 获取到实例。

3.2 GetterPointcut

GetterPointcut 和 SetterPointcut 类似，如下：

private static class GetterPointcut extends StaticMethodMatcherPointcut implements Serializable {
  public static final GetterPointcut INSTANCE = new GetterPointcut();
  @Override
  public boolean matches(Method method, Class<?> targetClass) {
    return (method.getName().startsWith("get") &&
        method.getParameterCount() == 0);
  }
  private Object readResolve() {
    return INSTANCE;
  }
  @Override
  public String toString() {
    return "Pointcuts.GETTERS";
  }
}

我觉得这个应该就不用过多解释了吧，跟前面的 SetterPointcut 类似，对照理解就行了。

3.3 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;
  }


  @Override
  public boolean matches(Method method, Class<?> targetClass) {
    for (String mappedName : this.mappedNames) {
      if (mappedName.equals(method.getName()) || isMatch(method.getName(), mappedName)) {
        return true;
      }
    }
    return false;
  }
  protected boolean isMatch(String methodName, String mappedName) {
    return PatternMatchUtils.simpleMatch(mappedName, methodName);
    }
}

可以看到，这个就是从外部传一个方法名称列表进来，然后在 matches 方法中进行匹配即可，匹配的时候直接调用 equals 方法进行匹配，如果 equals 方法没有匹配上，则调用 isMatch 方法进行匹配，这个最终调用到
PatternMatchUtils.simpleMatch 方法，这是 Spring 中提供的一个工具类，支持通配符的匹配。

举个简单例子：

ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.setTarget(new CalculatorImpl());
proxyFactory.addInterface(ICalculator.class);
proxyFactory.addAdvisor(new PointcutAdvisor() {
    @Override
    public Pointcut getPointcut() {
        NameMatchMethodPointcut pointcut = new NameMatchMethodPointcut();
        pointcut.setMappedNames("add","set*");
        return pointcut;
    }
    @Override
    public Advice getAdvice() {
        return new MethodInterceptor() {
            @Override
            public Object invoke(MethodInvocation invocation) throws Throwable {
                Method method = invocation.getMethod();
                String name = method.getName();
                System.out.println(name + " 方法开始执行了。。。");
                Object proceed = invocation.proceed();
                System.out.println(name + " 方法执行结束了。。。");
                return proceed;
            }
        };
    }
    @Override
    public boolean isPerInstance() {
        return true;
    }
});
ICalculator calculator = (ICalculator) proxyFactory.getProxy();
calculator.add(3,4);
calculator.minus(3, 4);
calculator.setA(5);

这里我设置的是拦截方法名为 add 或者方法名以 set 开头的方法。

3.4 JdkRegexpMethodPointcut

这个是支持通过正则去匹配方法名，匹配上的方法就会被拦截下来。

public class JdkRegexpMethodPointcut extends AbstractRegexpMethodPointcut {
  private Pattern[] compiledPatterns = new Pattern[0];
  private Pattern[] compiledExclusionPatterns = new Pattern[0];
  @Override
  protected void initPatternRepresentation(String[] patterns) throws PatternSyntaxException {
    this.compiledPatterns = compilePatterns(patterns);
  }
  @Override
  protected void initExcludedPatternRepresentation(String[] excludedPatterns) throws PatternSyntaxException {
    this.compiledExclusionPatterns = compilePatterns(excludedPatterns);
  }
  @Override
  protected boolean matches(String pattern, int patternIndex) {
    Matcher matcher = this.compiledPatterns[patternIndex].matcher(pattern);
    return matcher.matches();
  }
  @Override
  protected 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;
  }
}

可以看到，这里实际上就是传入正则表达式，然后通过正则表达式去匹配方法名是否满足条件。正则表达式可以传入多个，系统会在 JdkRegexpMethodPointcut 的父类中进行遍历逐个进行匹配，我举一个例子：

ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.setTarget(new CalculatorImpl());
proxyFactory.addInterface(ICalculator.class);
proxyFactory.addAdvisor(new PointcutAdvisor() {
    @Override
    public Pointcut getPointcut() {
        JdkRegexpMethodPointcut pc = new JdkRegexpMethodPointcut();
        pc.setPatterns("org.javaboy.bean.aop3.ICalculator.set.*");
        pc.setExcludedPattern("org.javaboy.bean.aop3.ICalculator.setA");
        return pc;
    }
    @Override
    public Advice getAdvice() {
        return new MethodInterceptor() {
            @Override
            public Object invoke(MethodInvocation invocation) throws Throwable {
                Method method = invocation.getMethod();
                String name = method.getName();
                System.out.println(name + " 方法开始执行了。。。");
                Object proceed = invocation.proceed();
                System.out.println(name + " 方法执行结束了。。。");
                return proceed;
            }
        };
    }
    @Override
    public boolean isPerInstance() {
        return true;
    }
});
ICalculator calculator = (ICalculator) proxyFactory.getProxy();
calculator.add(3,4);
calculator.minus(3, 4);
calculator.setA(5);

上面这个例子也是拦截 setXXX 方法，不过需要注意的是，方法名匹配的时候使用的是方法的全路径。

另外还需要注意，在配置匹配规则的时候，还可以设置 ExcludedPattern，实际上在匹配的时候，首先进行正向匹配，就是先看下方法名是否满足规则，如果满足，则方法名再和 ExcludedPattern 进行比对，如果不满足，则这个方法才会被确定下来要拦截。


StaticMethodMatcherPointcut 中主要就给我们提供了这些规则。

4. DynamicMethodMatcherPointcut

这个是动态方法匹配的切点，默认也是匹配所有类，但是在方法匹配这个问题，每次都会匹配，我们来看下：

public abstract class DynamicMethodMatcherPointcut extends DynamicMethodMatcher implements Pointcut {

  @Override
  public ClassFilter getClassFilter() {
    return ClassFilter.TRUE;
  }

  @Override
  public final MethodMatcher getMethodMatcher() {
    return this;
  }

}

可以看到，getClassFilter 直接返回 TRUE，也就是类就直接匹配了，getMethodMatcher 返回的则是当前对象，那是因为当前类实现了 DynamicMethodMatcher 接口，这就是一个方法匹配器：

public abstract class DynamicMethodMatcher implements MethodMatcher {

  @Override
  public final boolean isRuntime() {
    return true;
  }
  @Override
  public boolean matches(Method method, Class<?> targetClass) {
    return true;
  }

}

小伙伴们看到，这里 isRuntime 方法返回 true，该方法为 true，意味着三个参数的 matches 方法将会被调用，所以这里两个参数的 matches 方法可以直接返回 true，不做任何控制。

当然，也可以在两个参数的 matches 方法中做一些前置的判断。

我们来看一个简单例子：

public class MyDynamicMethodMatcherPointcut extends DynamicMethodMatcherPointcut {
    @Override
    public boolean matches(Method method, Class<?> targetClass) {
        return method.getName().startsWith("set");
    }

    @Override
    public boolean matches(Method method, Class<?> targetClass, Object... args) {
        return method.getName().startsWith("set") && args.length == 1 && Integer.class.isAssignableFrom(args[0].getClass());
    }
}

在实际执行过程中，两个参数的 matches 方法返回 true，三个参数的 matches 方法才会执行，如果两个参数的 matches 方法返回 false，则三个参数的 matches 就不会执行了。所以也可以两个参数的 matches 方法直接固定返回 true，只在三个参数的 matches 方法中做匹配操作即可。

然后使用这个切点：

ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.setTarget(new CalculatorImpl());
proxyFactory.addInterface(ICalculator.class);
proxyFactory.addAdvisor(new PointcutAdvisor() {
    @Override
    public Pointcut getPointcut() {
        return new MyDynamicMethodMatcherPointcut();
    }
    @Override
    public Advice getAdvice() {
        return new MethodInterceptor() {
            @Override
            public Object invoke(MethodInvocation invocation) throws Throwable {
                Method method = invocation.getMethod();
                String name = method.getName();
                System.out.println(name + " 方法开始执行了。。。");
                Object proceed = invocation.proceed();
                System.out.println(name + " 方法执行结束了。。。");
                return proceed;
            }
        };
    }
    @Override
    public boolean isPerInstance() {
        return true;
    }
});
ICalculator calculator = (ICalculator) proxyFactory.getProxy();
calculator.add(3,4);
calculator.minus(3, 4);
calculator.setA(5);

5. AnnotationMatchingPointcut

这个就是判断类或者方法上是否存在某个注解，如果存在，则将之拦截下来，否则不拦截。

先来看下这个类的定义：

public class AnnotationMatchingPointcut implements Pointcut {

  private final ClassFilter classFilter;

  private final MethodMatcher methodMatcher;

  public AnnotationMatchingPointcut(Class<? extends Annotation> classAnnotationType) {
    this(classAnnotationType, false);
  }

  public 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) {

    if (classAnnotationType != null) {
      this.classFilter = new AnnotationClassFilter(classAnnotationType, checkInherited);
    }
    else {
      this.classFilter = new AnnotationCandidateClassFilter(methodAnnotationType);
    }

    if (methodAnnotationType != null) {
      this.methodMatcher = new AnnotationMethodMatcher(methodAnnotationType, checkInherited);
    }
    else {
      this.methodMatcher = MethodMatcher.TRUE;
    }
  }


  @Override
  public ClassFilter getClassFilter() {
    return this.classFilter;
  }

  @Override
  public MethodMatcher getMethodMatcher() {
    return this.methodMatcher;
  }

  public 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);
  }

}

首先小伙伴们注意到，这个类一共有四个构造方法，从上往下分别是：

  1. 传入类上的注解名称，根据类上的注解去判断是否需要拦截。
  2. 在 1 的基础之上，再增加一个 checkInherited，这个表示是否需要检查父类上是否存在相关的注解。
  3. 传入类上和方法上的注解类型，根据这个注解类型去判断是否需要拦截。
  4. 在 3 的基础之上，再增加一个 checkInherited，这个表示是否需要检查父类上或者方法上是否存在相关的注解。

其中，第四个构造方法中处理的情况类型比较多，如果用户传入了 classAnnotationType，则构建 AnnotationClassFilter 类型的 ClassFilter，否则构建
AnnotationCandidateClassFilter 类型的 ClassFilter；如果用户传入了 methodAnnotationType，则构建 AnnotationMethodMatcher 类型的 MethodMatcher，否则方法匹配器就直接返回匹配所有方法。

那么接下来我们就来看下这几种不同的匹配器。

5.1 AnnotationClassFilter

public class AnnotationClassFilter implements ClassFilter {
    //...
  @Override
  public boolean matches(Class<?> clazz) {
    return (this.checkInherited ? AnnotatedElementUtils.hasAnnotation(clazz, this.annotationType) :
        clazz.isAnnotationPresent(this.annotationType));
  }
    //...
}

这里省略了一些代码，关键地方就是这个匹配方法了，如果需要检查父类是否包含该注解，则调用
AnnotatedElementUtils.hasAnnotation 方法进行查找，否则直接调用 clazz.isAnnotationPresent 方法判断当前类上是否包含指定注解即可。

5.2 AnnotationCandidateClassFilter

private static class AnnotationCandidateClassFilter implements ClassFilter {
  private final Class<? extends Annotation> annotationType;
  AnnotationCandidateClassFilter(Class<? extends Annotation> annotationType) {
    this.annotationType = annotationType;
  }
  @Override
  public boolean matches(Class<?> clazz) {
    return AnnotationUtils.isCandidateClass(clazz, this.annotationType);
  }
}

这里就是调用了
AnnotationUtils.isCandidateClass 方法进行判断，这个方法用来判断指定类是不是可以承载指定注解的候选类，返回 true 的规则是：

  1. 以 java. 开头的注解，所有的类都能承载，这种情况会返回 true。
  2. 目标类不能以 java. 开头，也就是说 JDK 中的类都不行，不是以 java. 开头的类就可以返回 true。
  3. 给定类也不能是 Ordered 类。

满足如上条件，这个类就是符合规定的。


AnnotationCandidateClassFilter 主要是针对用户没有传入类上注解的情况，这种情况一般都是根据方法上的注解进行匹配的，所以这里主要是排除一些系统类。

5.3 AnnotationMethodMatcher

public class AnnotationMethodMatcher extends StaticMethodMatcher {
  @Override
  public boolean matches(Method method, Class<?> targetClass) {
    if (matchesMethod(method)) {
      return true;
    }
    // Proxy classes never have annotations on their redeclared methods.
    if (Proxy.isProxyClass(targetClass)) {
      return false;
    }
    // The method may be on an interface, so let's check on the target class as well.
    Method specificMethod = AopUtils.getMostSpecificMethod(method, targetClass);
    return (specificMethod != method && matchesMethod(specificMethod));
  }
  private boolean matchesMethod(Method method) {
    return (this.checkInherited ? AnnotatedElementUtils.hasAnnotation(method, this.annotationType) :
        method.isAnnotationPresent(this.annotationType));
  }
}

方法匹配就是首先检查方法上是否有注解，如果开启了 checkInherited，则去检查一下父类对应的方法上是否有相关的注解，如果有，则表示方法匹配上了，返回 true。

否则先去检查一下当前类是否是一个代理对象，代理对象中对应的方法肯定是没有注解的，直接返回 false。

如果前面两步还没返回，最后考虑到目前这个方法可能是在一个接口上，要检查一下它的实现类是否包含该注解。

这就是
AnnotationMatchingPointcut。松哥也举一个简单例子吧。

5.4 实践

首先我自定义一个注解，如下：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAction {
}

然后将之添加到某一个方法上：

public class CalculatorImpl implements ICalculator {
    @Override
    public void add(int a, int b) {
        System.out.println(a + "+" + b + "=" + (a + b));
    }

    @MyAction
    @Override
    public int minus(int a, int b) {
        return a - b;
    }

    @Override
    public void setA(int a) {
        System.out.println("a = " + a);
    }
}

最后来实践一下：

ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.setTarget(new CalculatorImpl());
proxyFactory.addInterface(ICalculator.class);
proxyFactory.addAdvisor(new PointcutAdvisor() {
    @Override
    public Pointcut getPointcut() {
        return new AnnotationMatchingPointcut(null, MyAction.class);
    }
    @Override
    public Advice getAdvice() {
        return new MethodInterceptor() {
            @Override
            public Object invoke(MethodInvocation invocation) throws Throwable {
                Method method = invocation.getMethod();
                String name = method.getName();
                System.out.println(name + " 方法开始执行了。。。");
                Object proceed = invocation.proceed();
                System.out.println(name + " 方法执行结束了。。。");
                return proceed;
            }
        };
    }
    @Override
    public boolean isPerInstance() {
        return true;
    }
});
ICalculator calculator = (ICalculator) proxyFactory.getProxy();
calculator.add(3,4);
calculator.minus(3, 4);
calculator.setA(5);

只有 minus 方法被拦截下来了。

6. ExpressionPointcut

这个其实就是我们日常开发中使用最多的一种切点定义方式，可能项目中 99% 的切点定义都是使用的 ExpressionPointcut。这个具体用法我这里就不说了，因为比较丰富，都能单独整一篇文章了，如果小伙伴对 ExpressionPointcut 的基础用法还不熟悉的话，可以在公众号【江南一点雨】后台回复 ssm，有松哥之前录制的入门视频教程可以参考。

我这里就简单把它的实现思路来和小伙伴们梳理一下，ExpressionPointcut 的实现都在 AspectJExpressionPointcut 类中，该类支持使用切点语言来对要拦截的方法做一个非常精确的描述，精确到要拦截方法的返回值，AspectJExpressionPointcut 类的实现比较长也比较复杂，我这里贴其中一些关键的代码来看下：

public class AspectJExpressionPointcut extends AbstractExpressionPointcut
    implements ClassFilter, IntroductionAwareMethodMatcher, BeanFactoryAware {

  private static final Set<PointcutPrimitive> SUPPORTED_PRIMITIVES = Set.of(
      PointcutPrimitive.EXECUTION,
      PointcutPrimitive.ARGS,
      PointcutPrimitive.REFERENCE,
      PointcutPrimitive.THIS,
      PointcutPrimitive.TARGET,
      PointcutPrimitive.WITHIN,
      PointcutPrimitive.AT_ANNOTATION,
      PointcutPrimitive.AT_WITHIN,
      PointcutPrimitive.AT_ARGS,
      PointcutPrimitive.AT_TARGET);

  @Override
  public ClassFilter getClassFilter() {
    obtainPointcutExpression();
    return this;
  }

  @Override
  public MethodMatcher getMethodMatcher() {
    obtainPointcutExpression();
    return this;
  }

  /**
   * Check whether this pointcut is ready to match,
   * lazily building the underlying AspectJ pointcut expression.
   */
  private PointcutExpression obtainPointcutExpression() {
    if (getExpression() == null) {
      throw new IllegalStateException("Must set property 'expression' before attempting to match");
    }
    if (this.pointcutExpression == null) {
      this.pointcutClassLoader = determinePointcutClassLoader();
      this.pointcutExpression = buildPointcutExpression(this.pointcutClassLoader);
    }
    return this.pointcutExpression;
  }
}

其实关键还是要获取到 ClassFilter 和 MethodMatcher，然后调用其 matches 方法，当前类刚好就是实现了这两个，所以直接返回 this 就可以了。在 getClassFilter 或者 getMethodMatcher 方法执行之前，都会先调用 obtainPointcutExpression 方法，去解析我们传入的 expression 字符串，将之解析为一个 PointcutExpression 对象，接下来的 matches 方法就可以此为依据，进行匹配了。

7. ControlFlowPointcut

ControlFlowPointcut 主要是指目标方法从某一个指定类的指定方法中执行，切点才生效，否则不生效。

举个简单例子，如下：

public class AopDemo04 {
    public static void main(String[] args) {
        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.setTarget(new CalculatorImpl());
        proxyFactory.addInterface(ICalculator.class);
        proxyFactory.addAdvisor(new PointcutAdvisor() {
            @Override
            public Pointcut getPointcut() {
                return new ControlFlowPointcut(AopDemo04.class, "evl");
            }

            @Override
            public Advice getAdvice() {
                return new MethodInterceptor() {
                    @Override
                    public Object invoke(MethodInvocation invocation) throws Throwable {
                        Method method = invocation.getMethod();
                        String name = method.getName();
                        System.out.println(name + " 方法开始执行了。。。");
                        Object proceed = invocation.proceed();
                        System.out.println(name + " 方法执行结束了。。。");
                        return proceed;
                    }
                };
            }

            @Override
            public boolean isPerInstance() {
                return true;
            }
        });
        ICalculator calculator = (ICalculator) proxyFactory.getProxy();
        calculator.add(3,4);
        System.out.println("/");
        evl(calculator);
    }

    public static void evl(ICalculator iCalculator) {
        iCalculator.add(3, 4);
    }
}

这里切点的意思就是说，必须要从 AopDemo04 这个类的 evl 方法中调用 add 方法，这个切点才会生效，如果是拿到了 ICalculator 对象后直接调用 add 方法，那么切点是不会生效的。

ControlFlowPointcut 的原理也很简单，就是比较一下类名和方法名，如下：

public class ControlFlowPointcut implements Pointcut, ClassFilter, MethodMatcher, Serializable {
  @Override
  public boolean matches(Class<?> clazz) {
    return true;
  }
  @Override
  public boolean matches(Method method, Class<?> targetClass) {
    return true;
  }

  @Override
  public boolean isRuntime() {
    return true;
  }

  @Override
  public boolean matches(Method method, Class<?> targetClass, Object... args) {
    this.evaluations.incrementAndGet();

    for (StackTraceElement element : new Throwable().getStackTrace()) {
      if (element.getClassName().equals(this.clazz.getName()) &&
          (this.methodName == null || element.getMethodName().equals(this.methodName))) {
        return true;
      }
    }
    return false;
  }
  @Override
  public ClassFilter getClassFilter() {
    return this;
  }

  @Override
  public MethodMatcher getMethodMatcher() {
    return this;
  }
}

大家可以看到，isRuntime 方法返回 true，表示这是一个动态的方法匹配器。关键的 matches 方法，就是根据调用栈中的信息，去比较给定的类名和方法名是否满足。

8. ComposablePointcut

看名字就知道，这个可以将多个切点组合到一起，组合关系有求交集和求并集两种，分别对应 ComposablePointcut 中的 intersection 方法和 union 方法。

如下案例：

ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.setTarget(new CalculatorImpl());
proxyFactory.addInterface(ICalculator.class);
proxyFactory.addAdvisor(new PointcutAdvisor() {
    @Override
    public Pointcut getPointcut() {
        NameMatchMethodPointcut nameMatchMethodPointcut = new NameMatchMethodPointcut();
        nameMatchMethodPointcut.setMappedNames("add");
        ComposablePointcut pc = new ComposablePointcut((Pointcut) nameMatchMethodPointcut);
        pc.union(new AnnotationMatchingPointcut(null, MyAction.class));
        return pc;
    }
    @Override
    public Advice getAdvice() {
        return new MethodInterceptor() {
            @Override
            public Object invoke(MethodInvocation invocation) throws Throwable {
                Method method = invocation.getMethod();
                String name = method.getName();
                System.out.println(name + " 方法开始执行了。。。");
                Object proceed = invocation.proceed();
                System.out.println(name + " 方法执行结束了。。。");
                return proceed;
            }
        };
    }
    @Override
    public boolean isPerInstance() {
        return true;
    }
});
ICalculator calculator = (ICalculator) proxyFactory.getProxy();
calculator.add(3,4);
calculator.minus(3, 4);
calculator.setA(5);

在上面的案例中，就是把 NameMatchMethodPointcut 和
AnnotationMatchingPointcut 两个切点联合起来，既拦截方法名为 add 的方法，也拦截含有 @MyAction 注解的方法。

如果将 union 方法改为 intersection，就表示拦截方法名为 add 且被 @MyAction 注解标记的方法。如下：

@Override
public Pointcut getPointcut() {
    NameMatchMethodPointcut nameMatchMethodPointcut = new NameMatchMethodPointcut();
    nameMatchMethodPointcut.setMappedNames("add");
    ComposablePointcut pc = new ComposablePointcut((Pointcut) nameMatchMethodPointcut);
    pc.intersection(new AnnotationMatchingPointcut(null, MyAction.class));
    return pc;
}

其实这种组合切点的原理很简单，先把我们提供的 ClassFilter 和 MethodMatcher 收集到一个集合中，如果是 union，就直接遍历集合，只要有一个满足，就返回 true；如果是 intersection，也是直接遍历，如果有一个返回 false 就直接返回 false 即可。

以 ClassFilter 为例，我们来简单看下源码：

public ComposablePointcut union(ClassFilter other) {
  this.classFilter = ClassFilters.union(this.classFilter, other);
  return this;
}
public abstract class ClassFilters {
  public static ClassFilter union(ClassFilter cf1, ClassFilter cf2) {
    return new UnionClassFilter(new ClassFilter[] {cf1, cf2});
  }
  private static class UnionClassFilter implements ClassFilter, Serializable {

    private final ClassFilter[] filters;

    UnionClassFilter(ClassFilter[] filters) {
      this.filters = filters;
    }

    @Override
    public boolean matches(Class<?> clazz) {
      for (ClassFilter filter : this.filters) {
        if (filter.matches(clazz)) {
          return true;
        }
      }
      return false;
    }

  }
}

可以看到，传入的多个 ClassFilter 被组装到一起，在 matches 方法中逐个遍历，只要其中一个返回 true，就是 true。

9. 小结

好啦，这就是松哥今天和小伙伴们介绍的 7 中 Pointcut 了，希望借此小伙伴们对 Spring AOP 中切点的类型有一个完整的了解。再来回顾一下这其中切点：

  1. 静态方法切点：StaticMethodMatcherPointcut 表示静态方法切点的抽象基类，默认情况下匹配所有的类，然后通过不同的规则去匹配不同的方法。
  2. 动态方法切点：DynamicMethodMatcherPointcut 表示动态方法切点的抽象基类，默认情况下它匹配所有的类，然后通过不同的规则匹配不同的方法，这个有点类似于 StaticMethodMatcherPointcut，不同的是，StaticMethodMatcherPointcut 仅对方法签名进行匹配并且仅匹配一次，而 DynamicMethodMatcherPointcut 会在运行期间检查方法入参的值，由于每次传入的参数可能都不一样，所以没调用都要去判断，因此就导致 DynamicMethodMatcherPointcut 的性能差一些。
  3. 注解切点：AnnotationMatchingPointcut 根据制定注解拦截目标方法或者类。
  4. 表达式切点：ExpressionPointcut 这个是我们日常开发中使用最多的一种切点定义方式。
  5. 流程切点：ControlFlowPointcut 这个是要求必须从某一个位置调用目标方法，切点才会生效。
  6. 复合切点：ComposablePointcut 这个是把多个拦截器组装在一起使用，有交集和并集两种组装方式。
  7. TruePointcut 这是框架内部使用的一个切点，表示拦截一切。

 

qq_21305943
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于注解方式声明切面(AOP)
04-05
NULL 博文链接：https://1028826685.iteye.com/blog/1517747
Spring-AOP 切点/切面类型和创建切面
小工匠
08-15 2万+
概述 静态方法匹配器 动态方法匹配器 六种切点类型 静态方法切点StaticMethodMatcherPointcut 动态方法切点DynamicMethodMatcher 注解切点AnnotationMatchingPointcut 表达式切点ExpressionPointcut 流程切点ControlFlowPointcut 复合切点ComposablePointcut 三种切面类型一般切面Ad
【Spring】AOP中的核心概念：通知(Advice)和切点(Pointcut)
最新发布
m0_65277261的博客
05-15 977
通知(Advice)：在切面的某个特定的连接点上执行的动作。通知有多种类型，包括“around”，“before” 和“after”等等。通知的类型将在后面详细了解。许多AOP框架，包括Spring在内，都是以拦截器做通知模型的，并维护着一个以连接点为中心的拦截器链。 用来放增强的代码的那个方法 环绕通知@Around：可以把代码增强在目标方法的任意地方，更通用 前置通知@Before：目标方法之前执行 后置通知@After：目标方法之后执行 异常通知@AfterThrowing：目标方法出现了异常执行
【JavaEE进阶】——第七节.Spring AOP统一功能处理(切面、切点、连接点、通知）
未央的博客哟
05-23 1997
今天我们将介绍有关Spring AOP统一功能处理的内容
Spring AOP 切点 Pointcut 表达式介绍与使用
weixin_62636680的博客
11-27 2341
this指示符就是用来匹配基于CGLIB的代理类，通俗的来讲就是，如果当前要代理的类对象没有实现某个接口的话，则使用this；如果需要对现有类增加新的方法，可以通过 @DeclareParents 注解可以实现，DeclareParents 是一种 引入 (Introduction ) 类型的模型，在属性声明上使用，主要用于为指定的业务模块添加新的接口和相应的实现。this 用来匹配的连接点所属的对象引用是某个特定类型的实例，target 用来匹配的连接点所属目标对象必须是指定类型的实例；
Spring-AOP 静态普通方法名匹配切面
小工匠
08-19 2万+
概述 实例概述StaticMethodMatcherPointcutAdvisor代表一个静态方法匹配切面，它通过StaticMethodMatcherPointcut来定义切点，并通过类过滤和方法名来匹配所定义的切点.实例我们假设我们业务类中 Waiter和 Seller中都有同名的greetTo()方法.业务类Waiterpackage com.xgj.aop.spring.advisor.St
Spring之AOP系列--将方法上的注解做为切点(用@Before)
IT利刃出鞘的博客
07-23 1968
本文介绍Spring（SpringBoot）的AOP的用法：自定义注解，在接口上使用此注解，然后在AOP中获得注解的相关信息。 本文使用@Before。
Spring AOP中定义切点的实现方法示例
08-25
其中，定义切点是 AOP 中最为关键的一步骤，本文将主要介绍 Spring AOP 中定义切点的实现方法，并结合实例形式分析了 Spring 面向切面 AOP 定义切点的具体步骤、实现方法与相关操作技巧。 首先，在 Spring AOP 中，...
SpringAOP是什么？为什么要有SpringAOP？
10-15
4. **简化事务管理**：Spring AOP提供了一种声明式事务管理方式，通过简单的配置就可以实现复杂的事务规则，极大地减少了手动管理事务的工作量。 5. **增强可扩展性**：切面允许添加新的功能而不修改现有代码，这...
详解Spring学习总结——Spring实现AOP的多种方式
08-31
面向切面编程（AOP）是Spring框架的一个核心特性，它提供了一种模块化和解耦的方式来处理系统中的交叉关注点，如日志、事务管理等。本文将详细讲解Spring如何实现AOP，包括基于XML配置、注解配置以及AspectJ的使用。...
图解JAVA中Spring Aop作用
08-30
在 Spring AOP 中，切面是通过注解 @Aspect 来定义的，例如： ```java @Aspect @Component public class UserAspect { @Before("execution(* com.aop.service.impl.UserServiceImpl.login(..))") public void ...
SpringAOP.rar_springAOP
09-23
通过 `<aop:config>` 和 `<aop:aspect>` 标签在Spring配置文件中定义切面和通知。 五、总结 Spring AOP通过将关注点分离，提升了代码的可读性和可维护性，简化了复杂系统的管理。理解并熟练运用Spring AOP，能够让...
使用注解作为AOP的切入点（@Pointcut）
nidimyger的博客
02-16 967
修改代码：把注解移到mapper接口中的方法。（因为@mapper注释了mapper接口，这个@mapper注解会被用于spring和mybatis链接的@MapperScan扫描）检查代码发现，如果你使用的是 controller->service->mapper 在接口中定义的方法添加。，我们的aop在容器中找注解时会找不到，因为service接口没有注入到spring ioc中。在使用aop的注解切入时…为什么aop没有生效？
Spring之AOP系列--将类上的注解作为切点(用@Before)
IT利刃出鞘的博客
12-17 1700
本文介绍Spring（SpringBoot）的AOP的用法：自定义注解，在Controller的类上使用此注解，然后在AOP中获得注解的相关信息。 本文使用@Before。
注解定义切点
懒起来
06-14 286
建立一个包annotation建立一个类 在需要插入切点的位置写入注解 定义切点为
StaticMethodMatcherPointcutAdvisor静态切入点实现切面
felix
10-11 2355
通过注解实现接口的日志记录，是aop的一大用处。 实现注解 /** * @Description Accesslog: * @Author LiHaitao * @Date 2018/12/21 15:37 **/ @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @Documented public @...
Spring AOP中定义切点（PointCut）和通知（Advice）
GarfieldEr007的专栏
09-21 1744
本文讨论一下Spring AOP编程中的两个关键问题，定义切点和定义通知，理解这两个问题能应付大部分AOP场景。 如果你还不熟悉AOP，请先看AOP基本原理，本文的例子也沿用了AOP基本原理中的例子。 切点表达式 切点的功能是指出切面的通知应该从哪里织入应用的执行流。切面只能织入公共方法。 在Spring AOP中，使用AspectJ的切点表达式语言定义切点其中excecution()
Spring学习之深入AOP面向切面编程
逆风奔跑。。不要去考虑什么天赋异禀，一切都来自经历和渴望。
03-02 1万+
AOP(Aspect Oriented Programming,面向切面编程)的主要目的是针对业务处理过程中的切面进行提取，所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。可以通过预编译方式和运行时动态代理，实现在不修改源代码的请你工况下，给程序动态添加功能的一种技术。在OOP中模块化的关键单元是类，而在AOP中模块化的单元是切面。切面能对关注点进行模块化，例如
Spring AOP 之 通知、连接点、切点、切面。
热门推荐
github_34889651的博客
05-05 3万+
1：知识背景 软件系统可以看成是由一组关注点组成的，其中，直接的业务关注点，是直切关注点。而为直切关注点提供服务的，就是横切关注点。 2：面向切面的基本原理什么是面向切面编程 横切关注点：影响应用多处的功能（安全、事务、日志） 切面： 横切关注点被模块化为特殊的类，这些类称为切面 优点： 每个关注点现在都集中于一处，而不是分散到多处代码中 服务模块更简洁，服务模块只需关注核心代
spring中aop的切点
04-26
在Spring中，AOP（面向切面编程）是一种编程范式，它允许我们通过将横切关注点（如日志记录、事务管理等）从业务逻辑中分离出来，以提高代码的模块化和可维护性。 AOP的核心概念之一是切点（Pointcut），它定义了在哪些方法或者类上应用切面逻辑。在Spring中，我们可以使用不同的方式来定义切点： 1. 使用注解：通过在方法或者类上添加特定的注解，如`@Before`、`@After`、`@Around`等，来指定切点。例如，使用`@Before("execution(* com.example.service.*.*(..))")`可以定义一个切点，表示在com.example.service包下的所有方法执行之前执行切面逻辑。 2. 使用表达式：Spring提供了一种表达式语言（Expression Language，简称EL），可以使用表达式来定义切点。例如，使用`execution(* com.example.service.*.*(..))`可以定义一个切点，表示在com.example.service包下的所有方法执行时应用切面逻辑。 3. 使用XML配置：除了注解和表达式外，我们还可以使用XML配置文件来定义切点。在XML配置文件中，我们可以使用`<aop:pointcut>`元素来定义切点，并指定匹配的方法或者类。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值