1.什么是 Spring AOP

AOP（Aspect Oriented Programming）：面向切面编程，它是一种思想，它是对某一类事情的集中处理。比如用户登录权限的效验，没学 AOP 之前，我们所有需要判断用户登录的页面（中的方法），都要各自实现或调用用户验证的方法，然而有了 AOP 之后，我们只需要在某一处配置一下，所有需要判断用户登录页面（中的方法）就全部可以实现用户登录验证了，不再需要每个方法中都写相同的用户登录验证了。

Spring AOP 是⼀个框架，提供了⼀种对 AOP 思想的实现，它们的关系和 IoC 与 DI 类似。

2.为什要用 AOP

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

AOP可以实现的功能：

• 用户登录判断
• 统一日志记录
• 统一方法执行时间统计
• 统一的返回格式设置
• 统一的异常处理
• 事务的开启和提交等

3.AOP 组成

AOP 整个组成部分的概念如下图所示，以多个页面都要访问用户登录权限为例：

3.1 切面（Aspect）

切面（Aspect）由切点（Pointcut）和通知（Advice）组成，它既包含了横切逻辑的定义，也包括了连接点的定义。

切面是包含了 通知、切点 和 切面 的类，相当于 AOP 实现的某个功能的集合。

3.2 连接点（Join Point）

应用执行过程中能够插入切⾯的一个点，这个点可以是方法调用时，抛出异常时，甚至修改字段时。切面代码可以利⽤这些点插入到应用的正常流程之中，并添加新的行为。

连接点相当于需要被增强的某个 AOP 功能的所有方法。

3.3 切点（Pointcut）

Pointcut 的作用就是提供一组规则（使用 AspectJ pointcut expression language 来描述）来匹配 Join Point，给满足规则的 Join Point 添加 Advice。

切点相当于保存了众多连接点的一个集合（如果把切点看成一个表，而连接点就是表中一条一条的数据）。

3.5 通知（Advice）

切面的工作被称之为通知。通知 定义了切面是什么，何时使用，其描述了切面要完成的工作，解决何时执行这个工作的问题。
Spring 切面类中，可以在方法上使用以下注解，会设置方法为通知方法，在满足条件后会通知本方法进行调⽤：

• 前置通知 @Before：通知方法会在目标方法调用之前执行。
• 后置通知 @After：通知方法会在目标方法返回或者抛出异常后调用。
• 返回之后通知 @AfterReturning：通知方法会在目标方法返回后调用。
• 抛异常后通知 @AfterThrowing：通知方法会在目标方法抛出异常后调用。
• 环绕通知 @Around：通知包裹了被通知的方法，在被通知的方法通知之前和调用之后执行⾃定义的行为。

4.Spring AOP 实现

使用 Spring AOP 来实现一下 AOP 的功能，完成的目标是拦截所有 UserController 里面的方法，每次调用 UserController 中任意一个方法时，都执行相应的通知事件。

Spring AOP 的实现步骤如下：

1. 添加 Spring AOP 框架支持。
2. 定义切面和切点。
3. 定义通知。

4.1 添加 AOP 框架支持

在 pom.xml 中添加如下配置：

<dependency>
	<groupId>org.springframework.bootgroupId>
	<artifactId>spring-boot-starter-aopartifactId> 
dependency>
1
2
3
4
5
6

4.2 定义切面和切点

Spring AOP 切点的定义如下，在切点中我们要定义拦截的规则，具体实现如下：

@Aspect // 表明此类为⼀个切⾯ 
@Component
public class UserAspect {
	// 定义切点，这⾥使⽤ AspectJ 表达式语法
	@Pointcut("execution(* com.example.demo.controller.UserController.* (..))")
	public void pointcut(){ } 
}
1
2
3
4
5
6
7

其中 pointcut 方法为空方法，它不需要有方法体，此方法名就是起到一个“标识”的作用，标识下面的通知方法具体指的是哪个切点（因为切点可能有很多个）。

切点表达式说明

AspectJ 支持三种通配符：

• * ：匹配任意字符，只匹配一个元素（包，类，或⽅法，方法参数）
• .. ：匹配任意字符，可以匹配多个元素 ，在表示类时，必须和 * 联合使⽤。
• + ：表示按照类型匹配指定类的所有类，必须跟在类名后面，如 com.cad.Car+ ,表示继承该类的 所有子类包括本身

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

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

修饰符和异常可以省略。

表达式示例:

• execution(* com.cad.demo.User.*(..)) ：匹配 User 类里的所有方法。
• execution(* com.cad.demo.User+.*(..)) ：匹配该类的子类包括该类的所有方法。
• execution(* com.cad.*.*(..)) ：匹配 com.cad 包下的所有类的所有方法。
• execution(* com.cad..*.*(..)) ：匹配 com.cad 包下、子孙包下所有类的所有方法。
• execution(* addUser(String, int)) ：匹配 addUser 方法，且第一个参数类型是 String，第⼆个参数类型是 int。

4.3 定义通知

通知定义的是被拦截的方法具体要执行的业务，比如用户登录权限验证方法就是具体要执行的业务。
Spring AOP 中，可以在方法上使用以下注解，会设置方法为通知方法，在满足条件后会通知本方法进行调用，具体实现如下：

@Aspect     // 当前面是一个切面
@Component
@Slf4j
public class UserAspect {
    // 切点（定义规则：拦截UserController下的所有方法）
    @Pointcut("execution(* com.example.springaop.controller.UserController.*(..))")
    public void pointCut() {}

    // 1.定义前置通知（AOP拦截之后具体的业务执行）
    @Before("pointCut()")
    public void doBefore() {
        log.info("执行了前置通知方法");
    }

    // 2.定义后置通知方法
    @After("pointCut()")
    public void doAfter() {
        log.info("执行了后置通知方法");
    }

    // 3.定义返回后通知
    @AfterReturning("pointCut()")
    public void doReturn() {
        log.info("执行了返回后通知");
    }

    // 4.定义异常后通知
    @AfterThrowing("pointCut()")
    public void doAfterThrowing() {
        log.info("执行了异常之后的通知");
    }

    // 5.环绕通知
    @Around("pointCut()")
    public Object doAround(ProceedingJoinPoint joinPoint) {
        Object obj;
        long start = System.currentTimeMillis();
        log.info("环绕通知的前置方法");
        try {
            obj = joinPoint.proceed();  // 执行了拦截方法
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }
        log.info("环绕通知的后置方法");
        long end = System.currentTimeMillis();
        log.info("方法执行共花费了：" + (end - start) + "ms");
        return obj;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

实现UserController：

@RestController
@Slf4j
@RequestMapping("/user")
public class UserController {
    @RequestMapping("sayhi")
    public String sayHi(String name) {
        log.info("执行了sayhi方法");
        return "你好" + name;
    }
}
1
2
3
4
5
6
7
8
9
10

通过浏览器访问 sayhi 调用 sayHi方法：

5.Spring AOP 实现原理

Spring AOP 是构建在动态代理基础上，因此 Spring 对 AOP 的支持局限于方法级别的拦截。

Spring AOP 支持 JDK Proxy 和 CGLIB 方式实现动态代理。默认情况下，实现了接口的类，使用AOP 会基于 JDK 生成代理类，没有实现接口的类，会基于 CGLIB 生成代理类。

织入（Weaving）：代理的生成时机

织入是把切面应用到目标对象并创建新的代理对象的过程，切⾯在指定的连接点被织入到目标对象中。在目标对象的生命周期里有多个点可以进行织入：

• 编译期：切面在目标类编译时被织入。这种方式需要特殊的编译器。AspectJ的织入编译器就是以这种方式织入切面的。
• 类加载期：切面在目标类加载到JVM时被织入。这种方式需要特殊的类加载器（ClassLoader）,它可以在目标类被引入应用之前增强该目标类的字节码。AspectJ5的加载时织入（load-timeweaving. LTW）就支持以这种方式织入切面。
• 运行期：切面在应用运行的某一时刻被织入。一般情况下，在织入切面时，AOP容器会为目标对象动态创建一个代理对象。SpringAOP就是以这种方式织入切面的。

动态代理

此种实现在设计模式上称为动态代理模式，在实现的技术⼿段上，都是在 class 代码运行期，动态的织入字节码。
Spring 框架中的AOP，主要基于两种饭式：JDK 及 CGLIB 的方式。这两种方式的代理目标都是被代理类中的方法，在运行期，动态的织入字节码生成代理类。

• CGLIB是Java中的动态代理框架，主要作用就是根据目标类和方法，动态生成代理类。
• Java中的动态代理框架，几乎都是依赖字节码框架（如 ASM，Javassist 等）实现的。
• 字节码框架是直接操作 class 字节码的框架。可以加载已有的class字节码文件信息，修改部分信息，或动态生成一个 class。

JDK 动态代理实现

JDK 实现时，先通过实现 InvocationHandler 接⼝创建方法调用处理器，再通过 Proxy 来创建代理类。

//动态代理：使⽤JDK提供的api（InvocationHandler、Proxy实现），此种⽅式实现，要求被代理类必须实现接⼝
public class PayServiceJDKInvocationHandler implements InvocationHandler {
    //⽬标对象即就是被代理对象
    private Object target;

    public PayServiceJDKInvocationHandler(Object target) {
        this.target = target;
    }

    //proxy代理对象
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        //1.安全检查
        System.out.println("安全检查");
        //2.记录⽇志
        System.out.println("记录⽇志");
        //3.时间统计开始
        System.out.println("记录开始时间");
        //通过反射调⽤被代理类的⽅法
        Object retVal = method.invoke(target, args);
        //4.时间统计结束
        System.out.println("记录结束时间");
        return retVal;
    }

    public static void main(String[] args) {
        PayService target = new AliPayService();
        //⽅法调⽤处理器
        InvocationHandler handler =
                new PayServiceJDKInvocationHandler(target);
        //创建⼀个代理类：通过被代理类、被代理实现的接⼝、⽅法调⽤处理器来创建
        PayService proxy = (PayService) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                new Class[]{PayService.class},
                handler
        );
        proxy.pay();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

CGLIB 动态代理实现

public class PayServiceCGLIBInterceptor implements MethodInterceptor {
    //被代理对象
    private Object target;

    public PayServiceCGLIBInterceptor(Object target) {
        this.target = target;
    }

    @Override
    public Object intercept(Object o, Method method, Object[] args,
                            MethodProxy methodProxy) throws Throwable {
        //1.安全检查
        System.out.println("安全检查");
        //2.记录⽇志
        System.out.println("记录⽇志");
        //3.时间统计开始
        System.out.println("记录开始时间");
        //通过cglib的代理⽅法调⽤
        Object retVal = methodProxy.invoke(target, args);
        //4.时间统计结束
        System.out.println("记录结束时间");
        return retVal;
    }

    public static void main(String[] args) {
        PayService target = new AliPayService();
        PayService proxy = (PayService)
                Enhancer.create(target.getClass(), new
                        PayServiceCGLIBInterceptor(target));
        proxy.pay();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

JDK 和 CGLIB 实现的区别：

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