Spring AOP（概念、实战、原理）

1. 什么是AOP

能够将那些与业务无关，却为业务模板所共同调成的逻辑或责任（例如事务处理、日志管理、权限控制等）封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的拓展性和可维护性

2. AOP体系图

3. 术语解释

3.1 Aspect（切面）

切入点(Pointcut)+通知(Advice)，使用@Aspect注解的类就是切面

3.2 Join point（连接点）

目标对象的所属类中，定义的所有方法均为连接点

3.3 Advice（通知）

增强的逻辑 / 代码，也即拦截到目标对象的连接点之后要做的事情

3.4 Pointcut（切入点）

被切面拦截 / 增强的连接点（切入点一定是连接点，连接点不一定是切入点）

3.5 Target（目标）

被通知的对象

3.6 Proxy（代理）

向目标对象应用通知之后创建的代理对象

3.7 Weaving（织入）

将通知应用到目标对象，进而生成代理对象的过程动作

4. 如何使用

4.1 常见使用场景

● 日志记录：在方法执行前后记录日志，方便跟踪和调试
● 事务管理：在方法执行前后进行事务的开启、提交或回滚
● 安全性控制：在方法执行前进行权限验证，保证敏感数据和操作的安全
● 性能监控：在方法执行前后进行性能监控，如记录方法的执行时间、调用次数等
● 异常处理：在方法执行过程中捕获异常，并进行统一的异常处理和错误日志记录
● 缓存管理：在方法执行前后进行缓存的读取和更新，提高系统的响应速度和性能
● 验证和校验：在方法执行前进行参数的验证和校验，确保输入的数据符合要求

4.2 五种通知

● 前置通知：在目标方法执行之前执行执行的通知。
● 环绕通知：在目标方法执行之前和之后都可以执行额外代码的通知。
● 后置通知：在目标方法执行之后执行的通知。
● 异常通知：在目标方法抛出异常时执行的通知。
● 返回通知：在目标方法返回后调用

4.3 常见实现方式

4.3.1 注解

创建Spring boot项目，引入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

示例一：在调用get方法之前，输出”aop触发“
创建AOP切面类，加@Aspect注解代表这是一个切面

package com.bin.bintest.Config;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class binAdvice {

    @Pointcut("@annotation(org.springframework.web.bind.annotation.GetMapping)")
    private void logAdvicePointcut() {

    }

    // 前置通知
    @Before("logAdvicePointcut()")
    public void binAdvice() {
        System.out.println("aop触发");
    }

     /**
     * @Before：前置通知
     * @After：后置通知
     * @AfterReturning：返回通知
     * @AfterThrowing：异常通知
     * @Around：环绕通知
     */
    
}

创建controller

package com.bin.bintest.Controller;


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

@RestController
public class userController {

    @GetMapping("/name")
    public void getUsername() {
        System.out.println("获取名字");
    }

}

发起请求，结果为

示例二：自定义注解AOP
当你在编写自定义注解时，@Target、@Retention、@Documented 和 @Inherited 是四个你可能会用到的元注解，它们可以帮助你更好地定义和使用注解。

@Target
@Target 注解用于指定注解可以应用的程序元素类型。它的值是一个 ElementType 数组，表示该注解可以应用到哪些地方，包括类、接口、方法、字段等。常用的 ElementType 类型包括：

ElementType.TYPE：类、接口、枚举
ElementType.METHOD：方法
ElementType.FIELD：字段
ElementType.PARAMETER：方法参数
ElementType.CONSTRUCTOR：构造方法
ElementType.LOCAL_VARIABLE：局部变量
ElementType.ANNOTATION_TYPE：注解类型
ElementType.PACKAGE：包

@Retention
@Retention 注解用于指定注解的保留策略，即注解在编译时、运行时或者在类文件中都保留。它的值是一个 RetentionPolicy 枚举，包括：

RetentionPolicy.SOURCE：注解仅保留在源代码中，在编译时丢弃
RetentionPolicy.CLASS：注解保留到类文件中，在运行时丢弃（默认值）
RetentionPolicy.RUNTIME：注解保留到运行时，可以通过反射获取

@Documented
@Documented 注解表示该注解应该被 javadoc 工具记录，因此可以在生成的文档中看到该注解及其说明。它没有任何属性，只需将其放在注解声明之前即可。

@Inherited
@Inherited 注解表示该注解可以被子类继承。当一个类使用了被 @Inherited 注解的注解时，其子类也会继承该注解。需要注意的是，@Inherited 只对类的继承有效，对接口、方法、字段等不起作用。

创建自定义注解

package com.bin.bintest.Config;

import java.lang.annotation.*;

@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {

}

创建service

package com.bin.bintest.service;

import com.bin.bintest.Config.MyAnnotation;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @MyAnnotation
    public void getUsername() {
        System.out.println("你的名字");
    }

}

创建测试

package com.bin.bintest;

import com.bin.bintest.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class BintestApplicationTests {


    @Autowired
    UserService userService;

    @Test
    void contextLoads() {
        userService.getUsername();
    }

}

运行结果：

5. AOP原理

Spring AOP（Aspect Oriented Programming，面向切面编程）主要使用两种动态代理机制来实现AOP的织入（weaving）：

1. JDK动态代理 (Java Dynamic Proxy)：当被代理的对象实现了接口时，Spring AOP会使用JDK动态代理来创建代理对象。JDK动态代理是通过java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口实现的。
2. CGLIB代理 (Code Generation Library)：当被代理的对象没有实现任何接口时，Spring AOP会使用CGLIB来创建代理。CGLIB是一个高性能的代码生成库，它通过字节码技术为一个类创建子类，并对子类进行增强。
   在Spring框架中，默认情况下，如果目标对象实现了至少一个接口，那么Spring将使用JDK动态代理；如果没有实现任何接口，则会使用CGLIB代理。当然，也可以通过配置来指定使用哪种代理方式。

本文章借鉴：
SPRINGBOOT-自定义注解AOP实现及拦截器示例
Spring AOP代码实现：实例演示与注解全解