Spring AOP之pointcut语法

墨蓝 2023-07-25 08:37 129阅读 0赞

在文章Spring AOP之术语简介中有提到，pointcut定义了一种模式，用于匹配join point。Spring AOP中使用了AspectJ的pointcut模式定义语言。

声明一个pointcut

一个pointcut由两部分组成：

  • Pointcut signature：pointcut签名，类似于方法签名，但该方法返回值必须是void

  • Pointcut expression：@Pointcut注解中的模式定义表达式

    @Pointcut(“execution(* transfer(..))”) // the pointcut expression
    private void anyOldTransfer() {

    1. } // the pointcut signature

pointcut expression指示符

pointcut expression指示符用来指示该表达式的目的，Spring AOP支持以下10种指示符：

  • execution：匹配指定方法。

    execution(public (..)) //任意public方法
    execution( set(..)) //任意名称以set开头的方法
    execution( com.xyz.service.AccountService.(..)) //com.xyz.service.AccountService接口中定义的任意方法
    execution( com.xyz.service..(..)) //com.xyz.service包中定义的任意方法
    execution(     com.xyz.service...(..)) //com.xyz.service包中及其子包中定义的任意方法

  • within：匹配指定类内的所有join point（在Spring AOP中仅是方法执行点）。

    within(com.xyz.service.) //com.xyz.service包中的任意方法
    within(com.xyz.service..    ) //com.xyz.service包中及其子包中的任意方法

  • this：匹配可以向上转型为this指定的类型的代理对象中的所有join point（在Spring AOP中仅是方法执行点）。

    this(com.xyz.service.AccountService) //实现了com.xyz.service.AccountService接口的代理类中的所有方法

  • target：匹配可以向上转型为target指定的类型的目标对象中的所有join point（在Spring AOP中仅是方法执行点）。

    target(com.xyz.service.AccountService) //实现了com.xyz.service.AccountService接口的目标类中的所有方法

this和target的区别究竟在哪呢？举例说明。

下述所有类均定义在包com.qyh.test.aspectj中。

  • 定义一个接口TargetClassInterface

    public interface TargetClassInterface {

    1. void sayHello();

    }

  • 定义一个TargetClassInterface接口的实现类TargetClass

    @Component(“targetClass”)
    public class TargetClass implements TargetClassInterface {

    1. @Override
    2. public void sayHello() {
    4.     System.out.println("Hello World!");
    5. }

    }

  • 定义Spring的Java配置类AppConfig

    @Configuration
    @EnableAspectJAutoProxy
    @ComponentScan
    public class AppConfig {

    1. }

  • 定义切面类AspectClass

    @Component
    @Aspect
    public class AspectClass {

    1. @Pointcut("this(com.qyh.test.aspectj.TargetClass)")
    2. public void pointCutInTargetClass() {
    3. }
    5. @Before("pointCutInTargetClass()")
    6. public void beforeAdvice() {
    8.     System.out.println("我是前置增强");
    9. }

    }

  • 定义测试类Test

    public class Test {

    1. public static void main(String[] args) {
    3.     ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
    4.     TargetClassInterface targetClass = applicationContext.getBean("targetClass", TargetClassInterface.class);
    5.     targetClass.sayHello();
    6. }

    }

  • 测试结果1

    Hello World!

  • 将切面类AspectClass修改如下

    @Component
    @Aspect
    public class AspectClass {

    1. @Pointcut("target(com.qyh.test.aspectj.TargetClass)")
    2. public void pointCutInTargetClass() {
    3. }
    5. @Before("pointCutInTargetClass()")
    6. public void beforeAdvice() {
    8.     System.out.println("我是前置增强");
    9. }

    }

  • 测试结果2

    我是前置增强
    Hello World!

  • 结果分析
    由于Spring AOP默认使用的是JDK的动态代理来为接口生成代理对象，其代理对象实现了接口TargetClassInterface，与TargetClass没有关系，使用this关键字时，该代理对象无法向上转型为TargetClass，因此该切面失效，没有应用前置增强。使用target关键字时，目标对象可以向上转型为TargetClass（目标对象本身就是TargetClass），因此该切面生效，应用前置增强。

  • args：用方法参数去匹配方法

    args(java.io.Serializable) //只有一个参数，且参数的运行时类型是java.io.Serializable的方法

args(java.io.Serializable)和execution(* *(java.io.Serializable))的在哪呢？举例说明。

下述所有类均定义在包com.qyh.test.aspectj中。

  • 定义一个目标类TargetClass

    @Component(“targetClass”)
    public class TargetClass {

    1. public void originalMethod(String name, int age) {
    3.     System.out.println("我的名字叫" + name + "，我今年" + age + "岁了！");
    4. }
    6. public String sayHello(Serializable name) throws Exception {
    8.     return "Hello World!" + name;
    9. }

    }

  • 定义Spring的Java配置类AppConfig

    @Configuration
    @EnableAspectJAutoProxy
    @ComponentScan
    public class AppConfig {

    1. }

  • 定义切面类AspectClass

    @Component
    @Aspect
    public class AspectClass {

    1. @Pointcut("execution(* *(java.io.Serializable))")
    2. public void pointCutInTargetClass1() {
    3. }
    5. @Pointcut("args(java.lang.String)")
    6. public void pointCutInTargetClass2() {
    7. }
    9. @Before("pointCutInTargetClass1()")
    10. public void beforeAdvice() {
    12.     System.out.println("我是前置增强");
    13. }
    15. @AfterReturning(value = "pointCutInTargetClass2()")
    16. public void afterReturningAdvice() {
    18.     System.out.println("我是后置增强");
    19. }

    }

  • 定义测试类Test

    public class Test {

    1. public static void main(String[] args) throws Exception {
    3.     ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
    4.     TargetClass targetClass = applicationContext.getBean("targetClass", TargetClass.class);
    5.     System.out.println(targetClass.sayHello("小钱"));
    6. }

    }

  • 测试结果

    我是前置增强
    我是后置增强
    Hello World!小钱

  • 结果分析
    在本例中，sayHello(java.io.Serializable)方法的参数声明类型是java.io.Serializable，运行时类型是java.lang.String，因此execution(* *(java.io.Serializable))和args(java.lang.String)均能对该方法进行增强。这个例子说明args(java.io.Serializable)与execution(* *(java.io.Serializable))是不一样的。args(java.io.Serializable)指参数的运行时类型是java.io.Serializable，而execution(* *(java.io.Serializable))指参数的声明类型是java.io.Serializable。

  • @target：Limits matching to join points (the execution of methods when using Spring AOP) where the class of the executing object has an annotation of the given type.

    @target(org.springframework.transaction.annotation.Transactional) //Any join point (method execution only in Spring AOP) where the target object has a @Transactional annotation

  • @within：Limits matching to join points within types that have the given annotation (the execution of methods declared in types with the given annotation when using Spring AOP).

    @within(org.springframework.transaction.annotation.Transactional) //Any join point (method execution only in Spring AOP) where the declared type of the target object has an @Transactional annotation

@target和@within的区别究竟在哪呢？举例说明。

下述所有类均定义在包com.qyh.test.aspectj.withinandtargetannotation中。

  • 定义两个注解类MyAnnotation1和MyAnnotation2

    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Component
    public @interface MyAnnotation1 {

    1. }

    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Component
    public @interface MyAnnotation2 {

    1. }

  • 定义3个实体类GrandFather、Father和Son

    @MyAnnotation1
    public class GrandFather {

    1. public void say() {
    3.     System.out.println("GrandFather say");
    4. }
    6. public void run() {
    8.     System.out.println("GrandFather run");
    9. }

    }

    @MyAnnotation2
    public class Father extends GrandFather {

    1. @Override
    2. public void say() {
    4.     System.out.println("Father say");
    5. }

    }

    @Component
    public class Son extends Father {

    1. @Override
    2. public void say() {
    4.     System.out.println("Son say");
    5. }

    }

  • 定义Spring的Java配置类AppConfig

    @Configuration
    @EnableAspectJAutoProxy
    @ComponentScan
    public class AppConfig {

    1. }

  • 定义切面类AspectClass

    @Aspect
    @Component
    public class AspectClass {

    1. @Before("@within(com.qyh.test.aspectj.withinandtargetannotation.MyAnnotation1)")
    2. public void beforeAdviceWithinMyAnnotation1() {
    4.     System.out.println("beforeAdviceWithinMyAnnotation1");
    5. }
    7. @Before("@within(com.qyh.test.aspectj.withinandtargetannotation.MyAnnotation2)")
    8. public void beforeAdviceWithinMyAnnotation2() {
    10.     System.out.println("beforeAdviceWithinMyAnnotation2");
    11. }
    13. @Before("@target(com.qyh.test.aspectj.withinandtargetannotation.MyAnnotation1)")
    14. public void beforeAdviceTargetMyAnnotation1() {
    16.     System.out.println("beforeAdviceTargetMyAnnotation1");
    17. }
    19. @Before("@target(com.qyh.test.aspectj.withinandtargetannotation.MyAnnotation2)")
    20. public void beforeAdviceTargetMyAnnotation2() {
    22.     System.out.println("beforeAdviceTargetMyAnnotation2");
    23. }

    }

  • 定义测试类Test

    public class Test {

    1. public static void main(String[] args) {
    3.     ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
    4.     GrandFather grandFather = applicationContext.getBean("grandFather", GrandFather.class);
    5.     grandFather.say();
    6.     grandFather.run();
    7.     Father father = applicationContext.getBean("father", Father.class);
    8.     father.say();
    9.     father.run();
    10.     Son son = applicationContext.getBean("son", Son.class);
    11.     son.say();
    12.     son.run();
    13. }

    }

  • 测试结果

    beforeAdviceTargetMyAnnotation1
    beforeAdviceWithinMyAnnotation1
    GrandFather say
    beforeAdviceTargetMyAnnotation1
    beforeAdviceWithinMyAnnotation1
    GrandFather run
    beforeAdviceTargetMyAnnotation2
    beforeAdviceWithinMyAnnotation2
    Father say
    beforeAdviceTargetMyAnnotation2
    beforeAdviceWithinMyAnnotation1
    GrandFather run
    Son say
    beforeAdviceWithinMyAnnotation1
    GrandFather run

  • 结果分析
    父类有注解A，子类没有注解，子类中不是在父类中定义的方法不会被@within(A)和@target(A)拦截。
    父类有注解A，子类没有注解，子类中在父类中定义的方法会被@within(A)拦截，但不会被@target(A)拦截
    父类有注解A，子类有注解B，子类中不是在父类中定义的方法会被注解@within(B)和@target(B)拦截，但不会被@within(A)和@target(A)拦截。
    父类有注解A，子类有注解B，子类中在父类中定义的方法会被@within(A)和@target(B)拦截，但不会被@within(B)和@target(A)拦截。

  • @args：匹配方法，该方法的参数的运行时类型带有指定的注解

    @args(com.xyz.security.Classified) //只有一个参数，且该参数的运行时类型具有com.xyz.security.Classified注解的方法

  • @annotation：匹配方法，该方法带有指定的注解

    @annotation(org.springframework.transaction.annotation.Transactional) //被标注了org.springframework.transaction.annotation.Transactional注解的所有方法

  • bean：匹配bean实例内的所有join point（在Spring AOP中仅是方法执行点）。

    bean(tradeService) //id或name为tradeService的bean实例的所有方法
    bean(*Service) //id或name以Service结尾的bean实例的所有方法

指示符分类
  • Kinded designators：execution。
  • Scoping designators：within。
  • Contextual designators：this，target和@annotation。
    其中，Kinded designators和Contextual designators的性能较差，而Scoping designators的性能最好，故在开发中应尽可能地使用within指示符来定义pointcut。

pointcut expression表达式

通配符语法
  • *：匹配任何数量字符。
  • ..：匹配任何数量字符的重复，如在类型模式中匹配任何数量子包；而在方法参数模式中匹配任何数量参数。
  • +：匹配指定类型的子类型，仅能作为后缀放在类型模式后边。
模式匹配语法

以execution指示符为例：

  1. execution(修饰符类型? 返回值类型 类型模式?方法名称(参数类型) 异常类型?)

References

Spring Framework 5.2.5 Reference Doc.
Spring–@within和@target的区别
02-05 AOP学习之@within和@target使用示例及对比分析

发表评论

表情：
评论列表 （有 0 条评论，129人围观）

还没有评论，来说两句吧...

相关阅读