Spring AOP 切点指示符中execution和args的区别

「爱情、让人受尽委屈。」 2021-09-21 04:56 239阅读 0赞

# 一、简单介绍   #

Spring AOP中支持的切点指示符（PCD）有以下：execution、within、this、target、args、@target、@args、@within、@annotation和bean。

Spring 官网的介绍：

**`execution`**: For matching method execution join points. This is the primary pointcut designator to use when working with Spring AOP.*（用于匹配方法执行的连接点。 这是使用Spring AOP时要使用的主要切入点指示符）*

**`args`**: Limits matching to join points (the execution of methods when using Spring AOP) where the arguments are instances of the given types.（*将匹配限制为连接点（使用Spring AOP时方法的执行），其中参数是给定类型的实例）*

通常情况下，两者很容易使用和区分，比如：

1、表示任意public 方法的执行：

execution(public * *(..))

2、任何只有单个参数且在运行时传递的参数是Param实例方法的执行（注意Param要带上包路径）：

args(com.dxc.opentalk.springtest.param.Param)

# 二、区分示例 #

官网给出一个[例子][Link 1]，如下：

args(java.io.Serializable)

execution（**（java.io.Serializable））

这上面两个切点表达式有什么区别呢？如下：

*       Note that the pointcut given in this example is different from `execution(* *(java.io.Serializable))`. The args version matches if the argument passed at runtime is `Serializable`, and the execution version matches if the method signature declares a single parameter of type `Serializable`.*

个人理解***args(java.io.Serializable)***匹配的是只有单个入参而且入参是可以序列化（实现Serializable接口或者Serializable的子接口）的方法；而***`execution(* *(java.io.Serializable))`***匹配的是只有单个入参而且入参声明的必须是Serializable接口（不能是该接口的实现类以及子接口，严格的参数类型匹配）

# 三 、代码验证 #

定义一个类A，其三个方法为连接点：

@Component
    public class A {
    
    
        public void testOne(Param param) {
            System.out.println("testOne exec..." + param.getName());
        }
    
        public void testTwo(java.io.Serializable serializable) {
            System.out.println("testTwo exec..." + serializable.toString());
        }
    
        public void testThree(com.dxc.opentalk.springtest.service.TestInterface testInterface) {
            System.out.println("testThree exec..." + testInterface.toString());
        }
    }

定义切面、切点以及通知：

@Aspect
    @Component
    public class AopConfig {
    
        @Pointcut("args(java.io.Serializable)")
        private void apply(){}
    
        @Before("apply()")
        public void check(){
            System.out.println("aop args()...");
        }
    
    }

定义一个继承java.io.Serializable接口的TestInterface子接口，一个参数类Param 实现java.io.Serializable接口，一个ParamOne类实现TestInterface子接口：

public interface TestInterface extends Serializable {
    
        void test();
    }
    
    public class Param implements Serializable {
        private static final long serialVersionUID = 1342018181486589136L;
    
        private String name;
    
        public Param(String name){
            this.name = name;
        }
    
        public String getName(){
            return name;
        }
    }
    
    public class ParamOne implements TestInterface {
        private static final long serialVersionUID = 3558001836605280932L;
    
        public void test() {
            System.out.println("extended interface exec...");
        }
    
        private String name;
    
        public ParamOne(String name){
            this.name = name;
        }
    
        public String getName(){
            return name;
        }
    }

主程序类：

@EnableAspectJAutoProxy
    @ComponentScan("com.dxc.opentalk.springtest")
    public class BootStrap {
    
        public static void main(String[] args) {
            AnnotationConfigApplicationContext applicationContext
                    = new AnnotationConfigApplicationContext(BootStrap.class);
            A a = (A) applicationContext.getBean("a");
            a.testOne(new Param("param"));
            a.testTwo(new ArrayList());
            a.testThree(new ParamOne("paramOne"));
        }
    }

### 当采用 **@Pointcut("args(java.io.Serializable)")** 时，程序输出结果： ###

aop args()...
    testOne exec...param
    aop args()...
    testTwo exec...[]
    aop args()...
    testThree exec...com.dxc.opentalk.springtest.param.ParamOne@68267da0

可以看到，A类中的三个连接点方法全部被切点匹配上了。

### **当采用@Pointcut("execution(\* \*(java.io.Serializable))")时，程序输出结果：** ###

testOne exec...param
    aop args()...
    testTwo exec...[]
    testThree exec...com.dxc.opentalk.springtest.param.ParamOne@6ab778a

可以看到，只有入参声明是Serializable 的第二个方法**void testTwo(java.io.Serializable serializable)**被切点匹配上。

# 四、小结 #

execution表达式的标准格式如下：

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern)
                    throws-pattern?)

综上，execution表达式中的**param-pattern**是严格的类型匹配（必须是方法声明的参数类型，子类也不可以）；args表达式参数是给定类型的实例即可匹配到。

[Link 1]: https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#aop-ataspectj