Spring AOP的介绍与实现

比眉伴天荒 2024-03-17 22:32 84阅读 0赞

#### 文章目录 ####

*  Spring AOP
 *   *  1. Spring AOP概念
     *  2. Spring AOP的作用
     *  3.AOP的组成
     *  4. Spring AOP的实现
     *   *  4.1 添加Spring AOP依赖
         *  4.2 定义切面（创建切面类）
         *  4.3 定义切点（配置拦截规则）
         *   *  4.3.1 切点表达式语法
         *  4.4 定义通知的实现
     *  5. Spring AOP实现原理

## Spring AOP ##

### 1. Spring AOP概念 ###

**AOP （Aspect Oriented Programming）** ：⾯向切⾯编程，是⼀种思想，它是对某⼀类事情的集中处理。

举个例子：  
当我们进行用户登录权限的校验，在需要进行校验的页面中，我们都各⾃实现或调⽤⽤户验证的⽅法，有了 AOP 之后，我们只需要在某⼀处配置⼀下，需要登录校验的页面就可以自主实现，不再需要每个方法中都写相同的登录校验。

**AOP与Spring AOP的关系和IoC和DI类似，AOP是一种思想，而Spring AOP是一个具体的框架对AOP的实现。**

### 2. Spring AOP的作用 ###

对于以上的登录校验例子来说，我们使用Spring AOP我们可以减少代码的重复，提高我们程序员开发的效率，在具体开发中它可以实现以下功能：

1.  统一日志记录
2.  统一方法执行时间统计
3.  统一的返回格式设置
4.  统一的异常处理
5.  事务开启和提交
6.  统一登录校验等

对于我们对象来说，AOP扩展了它的能力，在某个方面我们可以说AOP是OOP（面向对象编程）的补充和完善，它们都是一种思想。

### 3.AOP的组成 ###

*  切⾯（Aspect）：切⾯（Aspect）由切点（Pointcut）和通知（Advice）组成，它既包含了横切逻辑的定义，也包括了连接点的定义。 **在程序中就是一个处理某方面具体问题的类，类中包含很多方法，这些方法就是切点和通知。**
 *  连接点（Join Point）：应⽤执⾏过程中能够插⼊切⾯的⼀个点，这个点可以是方法调用时，抛出异常时或者修改字段时。切⾯代码可以利⽤这些点插⼊到应用的正常流程之中，并添加新的行为。**它是可能会触发AOP的所有点（请求）。**
 *  切点（Pointcut）：切点是提供一组规则来匹配连接点，给满足规则的连接点添加通知。 **切点就是用来进行主动拦截的规则（配置）然后触发AOP。**
 *  通知（Advice）：切面的工作被称为通知，定义了切⾯是什么，何时使用，描述了切⾯要完成的工作，还解决何时执行这个工作问题。**也就是程序中被拦截请求触发的具体动作，在通知中的的具体业务代码。**

通知的分类：使用注解可以实现

*  前置通知：在执行目标方法之前执行的方法，@Before实现。比如我们要请求某页面要进行的登录检验相关方法，登录校验就是前置通知通过。请求页面的方法就是目标方法。
 *  后置通知：在执行目标方法之后执行的方法，通过@After实现。
 *  异常通知：在执行目标方法出现异常时执行的方法，通过@AfterThrowing实现。
 *  返回通知：目标方法执行了返回数据时（return）执行的通知，@AfterReturning实现。
 *  环绕通知：在目标方法执行的周期范围内（执行之前，执行中，执行后）都可以执行的。通过@Around实现。

### 4. Spring AOP的实现 ###

#### 4.1 添加Spring AOP依赖 ####

首先创建一个Spring Boot项目，在创建过程中我们没有Spring AOP框架可选，需要在pom.xml文件中自己添加Spring AOP 依赖。  
![在这里插入图片描述][a48c9b7b5d1b44ccb9f4f1eefb5933c5.png]

添加依赖，在Maven仓库中根据我们创建的spring boot项目添加以下依赖：  
![在这里插入图片描述][eed0c2c5dcfc4ad98f966290ee3f9a6c.png]

由于我使用的spring版本是2.7.13，所以我选用的版本也是2.7.13。

#### 4.2 定义切面（创建切面类） ####

对于切面我使用的注解是@Component，让该类醉着框架启动。通过@Aspect表示该类是一个切面；

package com.example.demo_aop.component;
    import org.aspectj.lang.annotation.Aspect;
    import org.springframework.context.annotation.EnableAspectJAutoProxy;
    import org.springframework.stereotype.Component;
    
    /**
     * @author zq
     * @date 2023-07-19 20:04
     */
    @Component
    @Aspect
    public class UserAspect {
        
        
    }

#### 4.3 定义切点（配置拦截规则） ####

定义切点通过@Poincut注解，使用Aspect的表达式语法；该方法是空方法只起到表示作用，指向后面多个对应的通知。

//定义切点，使用Aspect的表达式语法
    //    表示拦截该UserController下所有方法
        @Pointcut("execution(* com.example.demo_aop.controller.UserController.*(..))")
        public void poincut(){
        
    
        }

##### 4.3.1 切点表达式语法 #####

切点表达式由切点函数组成，其中 execution() 是最常⽤的切点函数，⽤来匹配⽅法，语法为：

> execution(<修饰符><返回类型> <包.类.方法(参数)><异常>)

\*号可以匹配任意字符，只匹配一个元素如包、类、方法、方法参数；…符号可以匹配任意字符，多个元素，在表示类时，需要与 星号联合使用；+号表示按照类型匹配指定类的所有类，必须跟在类名后面。如com.example.User+，就表示继承该类的所有子类和本身。

\*\* 注意：\*\*

1.  修饰符和异常通常可以省略，返回值不能省略。
2.  在我们上述代码中的表达式就省略了修饰符，用\*号表示返回值类型。
3.  返回值与包是两个东西所以加上了空格
4.  在我们上述代码表达式省略了异常。括号中的点点表示匹配任意参数的方法。

#### 4.4 定义通知的实现 ####

以下实现前置通知和后置通知；注解中对应切点的方法名。

//    表示该通知针对该方法
    //    前置通知
        @Before("pointcut()")
        public void beforeAdvice(){
        
            System.out.println("执行力前置通知");
        }
    //    后置通知
        @After("pointcut()")
        public void AfterAdvice(){
        
            System.out.println("执行了后置通知");
        }

**解释说明：我们不在切点中实现具体方法，是因为我们实现的方法有很多种，所以通过通知进行实现，它们具有1对多的关系。**

**在UserController类中创建方法检验AOP执行过程：**

package com.example.demo_aop.controller;
    
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * @author zq
     * @date 2023-07-19 20:25
     */
    
    @RequestMapping("/user")
    @RestController
    public class UserController {
        
    
        @RequestMapping("/hi")
        public String sayHi(String name){
        
            System.out.println("执行了sayHi方法");
            return "Hi" + name;
        }
    
        @RequestMapping("/hello")
        public String sayHello(String name){
        
            System.out.println("执行了sayHello方法");
            return "Hello" + name;
        }
    
    
    }

如图当我们启动程序，访问http://localhost:8080/user/hi时，控制台输出结果符合AOP执行过程  
![在这里插入图片描述][52c61b8a713a4afc989f358ad2e734be.png]

同理我们可以在切面类中也实现环绕通知，指的注意的是我们在环绕通知中必须通过 object = joinPoint.proceed(); 才能执行目标方法，不然只是执行环绕通知 ；

//    环绕通知
        @Around("poincut()")
    //    它必须有返回值返回给框架
        public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
        
            Object object = null;
            System.out.println("进入环绕通知");
    //        执行目标方法
            object = joinPoint.proceed();
            System.out.println("退出环绕通知");
            return object;
        }

**执行结果如下：**  
![在这里插入图片描述][afcf6ffe4ef14fc1acbc0f6b0ae971bc.png]

### 5. Spring AOP实现原理 ###

Spring AOP 是构建在动态代理基础上，因此 Spring 对 AOP 的支持局限于方法级别的拦截。Spring AOP ⽀持 JDK Proxy 和 CGLIB 方式实现动态代理。默认情况下，实现了接⼝的类，使⽤ AOP 会基于 JDK 生成代理类，没有实现接口的类，会基于 CGLIB 生成代理类。

也就是说我们本来要访问某个对象，但是我们Spring AOP构造了一个对应的代理类，我们访问时会通过代理类来访问我们的目标对象，不能直接访问

**如图所示：对于我们以上代码来说我们本来是访问UserController类，但是我们不能直接访问了，而是通过访问代理类访问。**  
![在这里插入图片描述][c01f491bc6604bd6b6e5e637e6a622e1.png]

**两种代理方式的区别：**

1.  JDK 实现，要求被代理类必须实现接⼝，之后是通过 InvocationHandler 及 Proxy，在运行时动态的在内存中⽣成了代理类对象，该代理对象是通过实现同样接⼝来实现，只是该代理类是在运行期时，动态的织⼊统⼀的业务逻辑字节码来完成。
2.  CGLIB 实现，被代理类可以不实现接⼝，是通过继承被代理类，在运⾏时动态的生成代理类对象。

[a48c9b7b5d1b44ccb9f4f1eefb5933c5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/e74acfd23c924a35b238eb9d8e06a87c.png
[eed0c2c5dcfc4ad98f966290ee3f9a6c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/ed4f4f417f124009ad9bf210443221c3.png
[52c61b8a713a4afc989f358ad2e734be.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/61a886b781464fa59c457409b3ae84e4.png
[afcf6ffe4ef14fc1acbc0f6b0ae971bc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/42e726905b3a4c2eabd7e47a4a0c317c.png
[c01f491bc6604bd6b6e5e637e6a622e1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/9abedec9f9204c159393daf7c35327eb.png