必备技能：spring aop 切入点表达式，你都会么？

时间 2019-11-06

原文原文链接

本文主要介绍spring aop中9种切入点表达式的写法java

execute
within
this
target
args
@target
@within
@annotation
@args

一、execute表达式

拦截任意公共方法spring

execution(public * *(..))
复制代码

拦截以set开头的任意方法apache

execution(* set*(..))
复制代码

拦截类或者接口中的方法bash

execution(* com.xyz.service.AccountService.*(..))
复制代码

拦截AccountService(类、接口)中定义的全部方法maven

拦截包中定义的方法，不包含子包中的方法ide

execution(* com.xyz.service.*.*(..))
复制代码

拦截com.xyz.service包中全部类中任意方法，不包含子包中的类spring-boot

拦截包或者子包中定义的方法测试

execution(* com.xyz.service..*.*(..))
复制代码

拦截com.xyz.service包或者子包中定义的全部方法ui

二、within表达式

表达式格式：包名.* 或者包名..*this

拦截包中任意方法，不包含子包中的方法

within(com.xyz.service.*)
复制代码

拦截service包中任意类的任意方法

拦截包或者子包中定义的方法

within(com.xyz.service..*)
复制代码

拦截service包及子包中任意类的任意方法

三、this表达式

代理对象为指定的类型会被拦截

目标对象使用aop以后生成的代理对象必须是指定的类型才会被拦截，注意是目标对象被代理以后生成的代理对象和指定的类型匹配才会被拦截

this(com.xyz.service.AccountService)
复制代码

示例 this表达式的使用，可能不是很好理解，用示例说明一下：

<?xml version="1.0" encoding="UTF-8"?>
<projectxmlns="http://maven.apache.org/POM/4.0." xmlns:xsi="http://www.w3.org/2001/XMLSchemainsance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>   
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.1.4.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>   
   <groupId>com.ms</groupId>   
   <artifactId>spring-aop-demo   </artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <name>spring-aop-demo</name>
   <description>Demo project for Spring Boot</description>

   <properties>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-aop</artifactId>
      </dependency>
      <dependency>
         <groupId>org.projectlombok</groupId>
         <artifactId>lombok</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
</project>
复制代码

package com.ms.aop.jthis.demo1;

public interface IService {
    void m1();
}
复制代码

package com.ms.aop.jthis.demo1;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class ServiceImpl implements IService {
    @Override
    public void m1() {
        log.info("切入点this测试！");
    }
}
复制代码

package com.ms.aop.jthis.demo1;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Aspect
@Component
@Slf4j
public class Interceptor1 {

    @Pointcut("this(com.ms.aop.jthis.demo1.ServiceImpl)")
    public void pointcut() {
    }

    @Around("pointcut()")
    public Object invoke(ProceedingJoinPoint invocation) throws Throwable {
        log.info("方法执行以前");
        Object result = invocation.proceed();
        log.info("方法执行完毕");
        return result;
    }
}
复制代码

package com.ms.aop.jthis.demo1;

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@ComponentScan(basePackageClasses = {Client.class})
@EnableAspectJAutoProxy
@Slf4j
public class Client {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(Client.class);
        IService service = annotationConfigApplicationContext.getBean(IService.class);
        service.m1();
        log.info("{}", service instanceof ServiceImpl);
    }
}
复制代码

执行结果

10:27:12.277 [main] INFO com.ms.aop.jthis.demo1.ServiceImpl - 切入点this测试！
10:27:12.277 [main] INFO com.ms.aop.jthis.demo1.Client - false
复制代码

@EnableAspectJAutoProxy：表示若spring建立的对象若是实现了接口，默认使用jdk动态代理，若是没有实现接口，使用cglib建立代理对象
因此 service 是使用jdk动态代理生成的对象，service instanceof ServiceImpl 为 false
@Pointcut("this(com.ms.aop.jthis.demo1.ServiceImpl)")表示被spring代理以后生成的对象必须为com.ms.aop.jthis.demo1.ServiceImpl才会被拦截，可是service不是ServiceImpl类型的对象了，因此不会被拦截
修改代码**@EnableAspectJAutoProxy(proxyTargetClass=true)**，使用cglib来生成代理对象

执行结果:

10:34:50.736[main]INFO com.ms.aop.jthis.demo1.Interceptor1-方法执行以前

10:34:50.755[main]INFO com.ms.aop.jthis.demo1.ServiceImpl-切入点this测试！

10:34:50.756[main]INFO com.ms.aop.jthis.demo1.Interceptor1-方法执行完毕

10:34:50.756[main]INFO com.ms.aop.jthis.demo1.Client-true
复制代码

service 为 ServiceImpl类型的对象，因此会被拦截

四、target表达式

目标对象为指定的类型被拦截

target(com.xyz.service.AccountService)
复制代码

目标对象为AccountService类型的会被代理

示例

package com.ms.aop.target;

public interface IService {
    void m1();}
复制代码

package com.ms.aop.target;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class ServiceImpl implements IService {
    @Override
    public void m1() {
        log.info("切入点target测试！");
    }
}
复制代码

package com.ms.aop.target;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect
@Component
@Slf4j
public class Interceptor1 {

    @Pointcut("target(com.ms.aop.target.ServiceImpl)")
    public void pointcut() {
    }

    @Around("pointcut()")
    public Object invoke(ProceedingJoinPoint invocation) throws Throwable {
        log.info("方法执行以前");
        Object result = invocation.proceed();
        log.info("方法执行完毕");
        return result;
    }
}
复制代码

package com.ms.aop.target;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@ComponentScan(basePackageClasses = {Client.class})
@EnableAspectJAutoProxy
public class Client {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(Client.class);
        IService service = annotationConfigApplicationContext.getBean(IService.class);
        service.m1();
    }
}
复制代码

执行结果：

10:49:01.674 [main] INFO com.ms.aop.targetInterceptor1 - 方法执行以前
10:49:01.674 [main] INFO com.ms.aop.target.ServiceImpl - 切入点target测试！
10:49:01.674 [main] INFO com.ms.aop.target.Interceptor1 - 方法执行完毕
复制代码

this 和 target 的不一样点

this做用于代理对象，target做用于目标对象
this表示目标对象被代理以后生成的代理对象和指定的类型匹配会被拦截，匹配的是代理对象
target表示目标对象和指定的类型匹配会被拦截，匹配的是目标对象

五、args 表达式

匹配方法中的参数

@Pointcut("args(com.ms.aop.args.demo1.UserModel)")
复制代码

匹配只有一个参数，且类型为com.ms.aop.args.demo1.UserModel

匹配多个参数

args(type1,type2,typeN)
复制代码

匹配任意多个参数

@Pointcut("args(com.ms.aop.args.demo1.UserModel,..)")
复制代码

匹配第一个参数类型为com.ms.aop.args.demo1.UserModel的全部方法, .. 表示任意个参数

六、@target表达式

匹配的目标对象的类有一个指定的注解

@target(com.ms.aop.jtarget.Annotation1)
复制代码

目标对象中包含com.ms.aop.jtarget.Annotation1注解，调用该目标对象的任意方法都会被拦截

七、@within表达式

指定匹配必须包含某个注解的

@within(com.ms.aop.jwithin.Annotation1)
复制代码

声明有com.ms.aop.jwithin.Annotation1注解的类中的全部方法都会被拦截

@target 和 @within 的不一样点

@target(注解A)：判断被调用的目标对象中是否声明了注解A，若是有，会被拦截
@within(注解A)：判断被调用的方法所属的类中是否声明了注解A，若是有，会被拦截

@target关注的是被调用的对象，@within关注的是调用的方法所在的类

八、@annotation表达式

匹配有指定注解的方法（注解做用在方法上面）

@annotation(com.ms.aop.jannotation.demo2.Annotation1)
复制代码

被调用的方法包含指定的注解

九、@args表达式

方法参数所属的类型上有指定的注解，被匹配

注意：是方法参数所属的类型上有指定的注解，不是方法参数中有注解

匹配1个参数，且第1个参数所属的类中有Anno1注解

@args(com.ms.aop.jargs.demo1.Anno1)
复制代码

匹配多个参数，且多个参数所属的类型上都有指定的注解

@args(com.ms.aop.jargs.demo1.Anno1,com.ms.aop.jargs.demo1.Anno2)
复制代码

匹配多个参数，且第一个参数所属的类中有Anno1注解

@args(com.ms.aop.jargs.demo2.Anno1,..)
复制代码