2.AOP

AOP是面向切面编程（Aspect-Oriented Programming）的缩写。

AOP是面向切面编程，OOP（面向对象）编程思想可以解决大部分的代码重复问题。但是有一些问题是处理不了的，比如在父类Animal中多个方法的相同位置出现了重复代码（横切逻辑代码）。AOP是一种编程范式，旨在通过将横切关注点（cross-cutting concerns）从主要业务逻辑中分离出来，提供一种更好的代码模块化和可维护性，换句话说，就是对某一类事情的集中处理。

目标对象（Target）： 被增强的方法所在的对象。
代理对象（Proxy）： 对目标对象进行增强后的对象，客户端实际调用的对象。
连接点（JoinPoint）： 目标对象中可以被增强的方法。
切入点（PointCut）： 目标对象中实际被增强的方法。
通知/增强（Advice）： 增强部分的代码逻辑。
切面（Aspect）： 增强和切入点的组合。
织入（Weaving）： 将通知和切入点组合动态组合的过程。

　　连接点是程序执行过程中的任意位置，粒度为执行方法，抛出异常等；通知是切面的一部分，它是在特定切点处执行的具体操作。切面由切点和通知组成，切点用于定义在哪些连接点上应用通知的规则，而通知定义了在这些连接点上执行的具体操作。在方法上添加相应的注解就表示相应的通知：

前置通知（@Before）：在目标方法执行之前执行的通知。可以在该通知中进行一些准备工作或参数验证。
后置通知（@After）：在目标方法执行之后执行的通知。可以在该通知中进行一些清理工作或记录日志。
返回通知（@AfterReturning）：在目标方法成功执行并返回结果后执行的通知。可以在该通知中对方法的返回值进行处理或执行其他操作。
异常通知（@AfterThrowing）：在目标方法抛出异常后执行的通知。可以在该通知中处理异常或执行相应的异常处理逻辑。
环绕通知（@Around）：在目标方法执行之前和之后都执行的通知。它可以完全控制目标方法的执行过程，包括是否执行目标方法以及如何处理返回值和异常。

# 多个切面的执行顺序如何控制？

1、通常使用@Order 注解直接定义切面顺序
 // 值越小优先级越高
@Order(3)
@Component
@Aspect
public class LoggingAspect implements Ordered {}

2、实现Ordered 接口重写 getOrder 方法。
@Component
@Aspect
public class LoggingAspect implements Ordered {
    // ....
    @Override
    public int getOrder() {
        // 返回值越小优先级越高
        return 1;
    }
}

Spring AOP的大致流程：

什么是AOP:其实AOP就是对原有的bean进行动态代理。

　　在创建一个Bean的过程中，Spring在最后一步会去判断当前正在创建的这个Bean是不是需要进行AOP，如果需要则会进行动态代理。

那么Spring是如何判断当前的bean对象需不需要进行AOP的呢：

找出所有的切面Bean
遍历切面中的每个方法，看是否写了@Before、@After等注解
如果写了，则判断所对应的Pointcut是否和当前Bean对象的类是否匹配
如果匹配则表示当前Bean对象有匹配的的Pointcut，表示需要进行AOP

当Spring判断出当前创建的bean需要进行AOP后，则需要进行动态代理，生成一个代理对象

Spring利用cglib进行AOP的大致流程如下：

生成代理类DemoServiceProxy，代理类继承DemoService
代理类中重写了父类的方法，比如DemoService中的demo()方法
代理类中还会有一个target属性，该属性的值为被代理对象（也就是通过UserService类推断构造方法实例化出来的对象，进行了依赖注入、初始化等步骤的对象）
代理类中的demo()方法被执行时的逻辑如下：a.执行切面逻辑（@Before）b.调用target.demo()

所以，如果一个bean进行了AOP，那么当我们从Spring容器得到DemoService的Bean对象时，拿到的就是DemoServiceProxy所生成的对象，也就是代理对象。

Spring AOP的简要实现原理：

切入点表达式解析：Spring AOP首先解析定义的切入点表达式，该表达式指定了哪些方法将被织入切面逻辑。
切面逻辑定义：开发人员定义切面逻辑，包括要在目标方法执行前、执行后或抛出异常时执行的逻辑。
创建代理对象：Spring使用动态代理机制，在运行时动态地创建一个代理对象，该代理对象实现了目标对象所实现的接口。代理对象将会拦截目标对象的方法调用。
方法拦截：当客户端调用目标对象的方法时，实际上是调用代理对象的对应方法。代理对象会拦截这个方法调用并执行切面逻辑。
执行切面逻辑：在代理对象的对应方法中，根据切入点表达式判断是否需要执行切面逻辑。如果需要，代理对象会调用切面逻辑的相关方法。
调用目标方法：在切面逻辑执行完毕后，代理对象会继续调用目标对象的实际方法。

织入（Weaving）是指将切面逻辑与目标类进行结合的过程。

代理对象的生成时机与织入时机有关。根据织入时机的不同，可以将织入分为以下三种方式：

编译期织入（Compile-Time Weaving）：
- 切面在目标类编译时被织入。
- 需要特殊的编译器来支持，例如AspectJ的织入编译器。
- 在目标类编译期间，切面逻辑被直接织入目标类的字节码中。
类加载期织入（Load-Time Weaving）：
- 切面在目标类加载到JVM时被织入。
- 需要特殊的类加载器（ClassLoader）来支持。
- 在目标类被引入应用之前，通过增强目标类的字节码来织入切面逻辑。
- AspectJ5的加载时织入（Load-Time Weaving, LTW）支持这种方式。
运行期织入（Runtime Weaving）：
- 切面在应用运行的某一时刻被织入。
- 一般情况下，AOP容器会为目标对象动态创建代理对象。
- 代理对象通过拦截目标对象的方法调用，在适当的时机执行切面逻辑。
- Spring AOP就是以运行期织入的方式来织入切面。

Spring AOP支持两种类型的代理：JDK动态代理和CGLIB代理。如果目标对象实现了InvocationHandler接口，Spring将使用JDK动态代理来创建代理对象。如果目标对象没有实现InvocationHandler接⼝，Spring将使用CGLIB代理，通过继承目标对象来创建代理对象。

它们主要区别：

接口要求：JDK动态代理要求目标对象实现接口，而CGLIB代理可以代理没有实现接口的类。
生成方式：JDK动态代理使用Java的反射机制生成代理对象，而CGLIB代理使用CGLIB库生成代理对象，通过修改目标类的字节码来实现。
代理对象类型：JDK动态代理生成的代理对象是实现了目标对象所实现的接口，而CGLIB代理生成的代理对象是目标对象的子类。

package com.ksyun.train.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;

@Aspect //切面
@Component //不能省略，要在项目启动的时候启动
public class UserAOP{
    //切点(配置拦截规则)
    @Pointcut("execution(* com.ksyun.train.Controller.UserController.*(..))")//这个切点表达式的意思是匹配 com.example.demo.controller.UserController 类中的所有方法，无论方法的返回类型和参数如何。换言之，就是UserController中的所有方法都被拦截了。
    public void pointcut(){}

    //前置通知
    @Before("pointcut()")
    public void doBefore(){
        System.out.println("执行前置通知" + LocalDateTime.now());
    }

    //后置通知
    @After("pointcut()")
    public void doAfter(){
        System.out.println("执行后置通知" + LocalDateTime.now());
    }

    //环绕通知
    @Around("pointcut()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("开始执行环绕通知：");
        Object obj = joinPoint.proceed();
        System.out.println("结束环绕通知");
        //这里的 obj 就是 连接点方法的返回值，可以对其进行修改
        obj = "do Around " + obj;
        System.out.println(obj);
        return obj;
    }

    //返回通知
    @AfterReturning("pointcut()")
    public void AfterReturning(){
        System.out.println("执行返回通知");
    }

    //异常通知
    @AfterThrowing("pointcut()")
    public void AfterThrowing(){
        System.out.println("执行异常通知");
        // 可以在此处进行异常处理逻辑
    }
}

package com.ksyun.train.Controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RequestMapping("/user")
@RestController
public class UserController {
    @RequestMapping("/hi")
    public String hi() {
        System.out.println("执行 UserController 的 hi() 方法");
        return "do user";
    }

    @RequestMapping("/login")
    public String login() {
        System.out.println("执行 UserController 的 login() 方法");
        return "do login";
    }

    //执行异常
//    @RequestMapping("/login")
//    public String login(){
//        System.out.println("执行 UserController 的 login() 方法");
//        throw new ArrayIndexOutOfBoundsException();
//    }

}
//localhost:8001/user/hi

参考：https://juejin.cn/post/7244492473933365304

参考：https://juejin.cn/post/7235167849428926521

AOP 有哪些应用场景？
    记录日志(调用方法后记录日志)
    监控性能(统计方法运行时间)
    权限控制(调用方法前校验是否有权限)
    事务管理(调用方法前开启事务，调用方法后提交关闭事务 )
    缓存优化(第一次调用查询数据库，将查询结果放入内存对象，第二次调用，直接从内存对象返回，不需要查询数据库 )

posted @ 2023-07-17 17:48 壹索007 阅读(23) 评论(0) 编辑收藏举报

刷新页面返回顶部

cjhtxdy

2.AOP

# 多个切面的执行顺序如何控制？

公告