Springboot 中使用 Aop

た入场券 2023-10-13 16:59 58阅读 0赞

### 1. aop作用 ###

AOP意为面向切面编程，可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。  
AOP的编程思想是把对类对象的横切问题点，从业务逻辑中分离出来，从而达到解耦的目的，增加代码的复用性，提高开发效率。

### 2. 相关注解 ###

@Component ：将当前类注入到Spring容器内。  
@Aspect ：表明当前类是一个切面类。  
@Before ：前置通知，在被切入方法执行之前执行。  
@After ：后置通知，在被切入方法执行之后执行。  
@AfterRuturning ：返回通知，在被切入方法返回结果之后执行。使用此注解的方法，可以使用returning = "XXX"返回被切入方法的返回值，XXX即为被切入方法的返回值，本例中是controller类中方法的返回值。

//返回通知
    @AfterReturning(returning = "ret", pointcut = "log()")
    public void doAfterReturning(Object ret) throws Throwable {
        
        // 处理完请求，返回内容
        System.out.println("返回通知：方法的返回值 : " + ret);
    }

@AfterThrowing ：异常通知，在被切入方法抛出异常之后执行。在此注解中可以使用throwing = "XXX"获取异常信息，获取的异常信息可以在方法中打印出来，举例如下。

/异常通知
    @AfterThrowing(throwing = "ex", pointcut = "log()")
    public void throwss(JoinPoint jp, Exception ex) {
        
        System.out.println("异常通知：方法异常时执行.....");
        System.out.println("产生异常的方法：" + jp);
        System.out.println("异常种类：" + ex);
    }

@Around ：环绕通知，围绕着被切入方法执行。参数必须为ProceedingJoinPoint，pjp.proceed相应于执行被切面的方法。环绕通知一般单独使用，环绕通知可以替代上面的四种通知，后面单独介绍。  
@Pointcut ：切入点，PointCut（切入点）表达式有很多种，其中execution用于使用切面的连接点。

注意：  
返回通知和异常通知只能有一个会被执行，因为发生异常执行异常通知，然后就不会继续向下执行，自然后置通知也就不会被执行，反之亦然。  
后置通知一定会执行。

### 3. Aop 相关概念 ###

Joinpoint(连接点)：所谓连接点是指那些被拦截到的点，在 spring 中，这些点指的是方法，因为 spring 只支持方法类型的连接点，通俗的说就是被增强类中的所有方法。注意： 除了环绕通知外，其他的四个通知注解中，加或者不加参数JoinPoint都可以，如果有用到JoinPoint的地方就加，用不到就可以不加。JoinPoint里包含了类名、被切面的方法名，参数等属性。  
PointCut(切入点)：所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义，通俗的说就是被增强类中的被增强的方法，因为被增强类中并不是所有的方法都被增强了。  
Advice(通知/增强)：所谓通知是指拦截到 Joinpoint （被增强的方法）之后所要做的事情就是通知，通俗的说就是对被增强的方法进行增强的代码  
Aspect(切面)：是切入点和通知（引介）的结合，通俗的说就是建立切入点和通知方法在创建时的对应关系。

### 4. 切入点表达式详解：@PointCut(表达式) ###

PointCut：切入点，指哪些方法需要被执行AOP，PointCut表达式可以有一下几种方式：

1.  execution表达式  
    表达式语法：访问修饰符 返回值 包名.包名.包名…类名.方法名(参数列表)  
    标准的表达式写法范例：

public void com.aismall.testaop.controller.HelloController.helloAop()

访问修饰符可以省略

void com.aismall.testaop.controller.HelloController.helloAop()

返回值可以使用通配符\*，表示任意返回值

* com.aismall.testaop.controller.HelloController.helloAop()

包名可以使用通配符，表示任意包，但是有几级包，就需要写几个\*.

*  *.*.*.*.HelloController.helloAop()

包名可以使用…表示当前包及其子包

* *...HelloController.helloAop()

类名和方法名都可以使用\*来实现通配

* *..*.*()

表达式中的参数列表，可以直接写数据类型：

基本类型直接写名称 ：例如，int  
引用类型写包名.类名的方式 ：例如，java.lang.String  
可以使用通配符*表示任意类型，但是必须有参数  
可以使用…表示有无参数均可，有参数可以是任意类型  
全通配写法：* *…*.\*(…)

2.within表达式  
是用来指定类型的，指定类型中的所有方法将被拦截  
表达式：包名.包名.包名…类名  
标准的表达式写法范例：

com.aismall.testaop.controller.HelloController

举例：匹配HelloController类对应对象的所有方法，并且只能是HelloController类生成的对象，不能是它的子类生成的对象。

within(com.aismall.testaop.controller.HelloController)

也可以使用通配符\*：匹配com.aismall包及其子包下面的所有类的所有方法。

within(com.aismall…*)

1.  this(type)  
    SpringAOP是基于代理的，this就代表代理对象，语法是this(type)，当生成的代理对象可以转化为type指定的类型时表示匹配。  
    `this(com.aismall.testaop.controller.HelloController)`匹配生成的代理对象是HelloController类型的所有方法的外部调用
2.  target  
    SpringAOP是基于代理的，target表示被代理的目标对象，当被代理的目标对象可以转换为指定的类型时则表示匹配。  
    `target(com.aismall.testaop.controller.HelloController)` 匹配所有被代理的目标对象能够转化成HelloController类型的所有方法的外部调用。
3.  args:  
    `args`用来匹配方法参数  
    `args()` 匹配不带参数的方法  
    `args(java.lang.String)` 匹配方法参数是String类型的  
    `args(…)` 带任意参数的方法  
    `args(java.lang.String,…)` 匹配第一个参数是String类型的，其他参数任意。最后一个参数是String的同理。
4.  @ annotation:  
    带有相应注解的方法，比如对标有@Transactional注解的方法进行增强

@annotation(org.springframework.transaction.annotation.Transactional)

@within和@target针对类的注解  
@annotation针对方法的注解  
@args:  
参数带有相应标注的任意方法，比如@Transactional

@args(org.springframework.transaction.annotation.Transactional)

### 5. 代码实战 使用execution(表达式) ###

创建一个aspect切面类

@Aspect
    @Component
    public class MyAop {
        
        //切入点：待增强的方法
        @Pointcut("execution(public * com.xxx.controller.*.*(..))")
        //切入点签名
        public void log(){
        
            System.out.println("pointCut签名。。。");
        }
        //前置通知
        @Before("log()")
        public void deBefore(JoinPoint jp) throws Throwable {
        
            // 接收到请求，记录请求内容
            ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
            HttpServletRequest request = attributes.getRequest();
            // 记录下请求内容
            System.out.println("URL : " + request.getRequestURL().toString());
            System.out.println("HTTP_METHOD : " + request.getMethod());
            System.out.println("CLASS_METHOD : " + jp);
            System.out.println("ARGS : " + Arrays.toString(jp.getArgs()));
    
        }
        //返回通知
        @AfterReturning(returning = "ret", pointcut = "log()")
        public void doAfterReturning(Object ret) throws Throwable {
        
            // 处理完请求，返回内容
            System.out.println("返回通知：方法的返回值 : " + ret);`在这里插入代码片`
        }
    
        //异常通知
        @AfterThrowing(throwing = "ex", pointcut = "log()")
        public void throwss(JoinPoint jp,Exception ex){
        
            System.out.println("异常通知：方法异常时执行.....");
            System.out.println("产生异常的方法："+jp);
            System.out.println("异常种类："+ex);
        }
    
        //后置通知
        @After("log()")
        public void after(JoinPoint jp){
        
            System.out.println("后置通知：最后且一定执行.....");
        }
    }

创建controlle

@RestController
    public class HelloController {
        
        @RequestMapping("/helloAop")
        public Object hello(){
        
            return "hello aop";
        }
        @RequestMapping("/helloError")
        public Object helloError(){
        
            return 1/0;
        }
    }

测试

### 6. 代码实战 使用@annotation ###

自定义注解

//表示次注解可以标注在类和方法上
    @Target({
        ElementType.METHOD, ElementType.TYPE})
    //运行时生效
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyLogAnnotation {
        
        //定义一个变量，可以接受参数
        String desc() default " ";
    }

切面类

@Aspect
    @Component
    public class MyAopAnnotation {
        
        //切入点：增强标有MyLogAnnotation注解的方法
        @Pointcut(value="@annotation(com.aismall.testaop.MyAnnotation.MyLogAnnotation)")
        //切入点签名
        public void logAnnotation(){
        
            System.out.println("pointCut签名。。。");
        }
        //前置通知
        @Before("logAnnotation()")
        public void deBefore(JoinPoint jp) throws Throwable {
        
            // 接收到请求，记录请求内容
            ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
            HttpServletRequest request = attributes.getRequest();
            // 记录下请求内容
            System.out.println("URL : " + request.getRequestURL().toString());
        }
        //返回通知
        @AfterReturning(returning = "ret", pointcut = "logAnnotation()")
        public void doAfterReturning(Object ret) throws Throwable {
        
            // 处理完请求，返回内容
            System.out.println("返回通知：方法的返回值 : " + ret);
        }
    
        //异常通知
        @AfterThrowing(throwing = "ex", pointcut = "logAnnotation()")
        public void throwss(JoinPoint jp,Exception ex){
        
            System.out.println("异常通知：方法异常时执行.....");
            System.out.println("产生异常的方法："+jp);
            System.out.println("异常种类："+ex);
        }
    
        //后置通知
        @After("logAnnotation()")
        public void after(JoinPoint jp){
        
            System.out.println("后置通知：最后且一定执行.....");
        }
    }

Controller类

@RequestMapping("helloAnnotation")
    //标有这个注解的方法会被增强
    @MyLogAnnotation(desc = "@Annotation")
    public Object helloAnnotation() {
        
        return "hello annotation";
    }