SpringAOP详解+快速入门

目录

1.什么是SpringAOP？

2.为什么要使用AOP？

3.AOP的组成

    3.1 切面-Aspect

    3.2 连接点-JoinPoint

    3.3 切入点-Pointcut

    3.4 通知-Advice

4.SpringAOP简单实例展示

    4.1 添加AOP相关框架支持

    4.2 定义切面和切点

    4.3 定义相关通知

5.SpringAOP的实现原理

    5.1 JDK动态代理

    5.2 CGLIB代理

6.SpringAOP相关体系总结

---

1.什么是SpringAOP？

在介绍 Spring AOP 之前，首先要了解一下什么是 AOP？

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，它是一种思想，它是对某一类事情的集中处理。通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性和可维护性，同时提高了开发的效率。 

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

官方网站：春季AOP |春季AOP术语和春季AOP的需求 (educba.com)

 2.为什么要使用AOP？

想象一个场景，我们在做后台系统时，除了登录和注册等几个功能不需要做用户登录验证之外，其他几乎所 有页面调用的前端控制器（ Controller）都需要先验证用户登录的状态，那这个时候我们要怎么处理呢？

我们之前的处理方式可能是每个 Controller 都要写一遍用户登录验证，然而当你的功能越来越多，那么你要写的 登录验证也越来越多，而这些方法又是相同的，这么多的方法就会代码修改和维护的成本。那有没有简单的 处理方案呢？答案是对于这种功能统一，且使用的地方较多的功能，就可以考虑 AOP 来统一处理 了。

除了统一的用户登录判断之外，AOP 还可以实现：

统一日志记录

统一方法执行时间统计

统一的返回格式设置

统一的异常处理

事务的开启和提交等

也就是说使用 AOP 可以扩充多个对象的某个能力，所以 AOP 可以说是 OOP（Object Oriented Programming，面向对象编程）的补充和完善。

3.AOP的组成

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

 3.1 切面-Aspect

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

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

3.2 连接点-JoinPoint

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

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

3.3 切入点-Pointcut

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

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

3.4 通知-Advice

在 AOP 术语中，切面的工作被称之为通知

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

前置通知使用 @Before：通知方法会在（该注解的value）切入目标方法调用之前执行。

后置通知使用 @After： 通知方法会在（该注解的value）切入目标方法返回或者抛出异常之后调用。

返回之后通知使用 @AfterReturning： 通知方法会在目标方法正常执行完毕之后调用。

抛异常后通知使用 @AfterThrowing： 通知方法会在目标方法抛出异常后调用。

环绕通知使用 @Around：设置指定的通知处理方法（该注解的value）切入到目标方法前后执行

这个功能强大比较常用。功能约等于@Before+@AfterReturning。

 注意点：

• @Around通知处理方法的第一个形参必须是ProceedingJoinPoint类型，在通知处理方法体内，调用ProceedingJoinPoint的proceed方法才会执行目标方法。如果程序没有调用ProceedingJoinPoint的proceed方法，则目标方法不会执行。
• 调用ProceedingJoinPoint的proceed方法时，还可以传入一个Object[ ]对象，该数组中的值将被传入目标方法作为实参。如果传入的Object[ ]数组长度与目标方法所需要的参数个数不相等，或者Object[ ]数组元素与目标方法所需参数的类型不匹配，程序就会出现异常。
• 通知处理方法返回类型可以设置为void，如果接收返回值的话，则必须设置为Object。

 4.SpringAOP简单实例展示

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

4.1 添加AOP相关框架支持

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

!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-bootstarter-aop -->

org.springframework.boot
spring-boot-starter-aop

4.2 定义切面和切点

切点指的是具体要处理的某一类问题，比如用户登录权限验证就是一个具体的问题，记录所有方法的执行日 志就是一个具体的问题，切点定义的是某一类问题。

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

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
//表示是一个切面，要使用aop进行方法增强
@Aspect
//注册到容器中
@Component
public class AopAspect {

    //切点：定义要增强的方法增强
    @Pointcut("execution(* com.example..service.*Service.query(..))")
    public void qiedian(){

   }
}

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

切点表达式说明:

AspectJ 支持三种通配符：

* ：匹配任意字符，只匹配一个元素（包，类，或方法，方法参数）。

* .. ：匹配任意字符，可以匹配多个元素 ，在表示类时，必须和 * 联合使用。

+ ：表示按照类型匹配指定类的所有类，必须跟在类名后面，如 com.cad.Car+ ,表示继承该类的所有子 类包括本身。

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

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

修饰符和异常可以省略。

表达式示例：

4.3 定义相关通知 

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

AopAspect类具体实现如下：

package com.example.springaopstudy.config;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
//表示是一个切面，要使用aop进行方法增强
@Aspect
//注册到容器中
@Component
public class AopAspect {

    //切点：定义要增强的方法增强
    @Pointcut("execution(* com.example..service.*Service.query(..))")
    public void qiedian(){}

    @Around("qiedian()")
    public Object around(ProceedingJoinPoint joinPoint){
        try {
            //统计方法的时间
            Long start=System.currentTimeMillis();
            //这个方法，就是@Pointcut匹配到的方法，然后执行
            Object object = joinPoint.proceed();
            Long end=System.currentTimeMillis();
            System.out.println("===========================");
            System.out.println("执行时间: "+(end-start)+" ms");
            return object;
        } catch (Throwable e) {
            throw new RuntimeException();
        }
    }

    //添加其他的通知
    @Before("qiedian()")
    public void before(){
        System.out.println("=================before===============");
    }

    @After("qiedian()")
    public void after(){
        System.out.println("=================after===============");
    }

    @AfterReturning("qiedian()")
    public void afterReruening(){
        System.out.println("=================afterReturning===============");
    }

    @AfterThrowing("qiedian()")
    public void afterThrowing(){
        System.out.println("=================afterThrowing");
    }

}

其中相关的UserController类相关代码为：

package com.example.springaopstudy.controller;

import com.example.springaopstudy.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/user")
public class UserController {
    @Autowired
    private UserService userService;

    @RequestMapping("/query")
    public Object query(){
        return userService.query();
    }
}

UserService类的相关代码为：

package com.example.springaopstudy.service;

import com.example.springaopstudy.model.Userinfo;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

@Service
public class UserService {

    public List query() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return new ArrayList<>();
    }
}

在我们编写好了代码以后，我们可以启动通过使用postman工具来查看执行结果

 

在此也可以看出通知中各个方法的执行顺序 

注意：此时如果我在UserService类中执行方法前使其执行报错，那么各个方法的运行顺序又是什么样子呢？请看代码：

首先看UserService修改后要报错的代码：

package com.example.springaopstudy.service;

import com.example.springaopstudy.model.Userinfo;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

@Service
public class UserService {

    public List query() {
        //故意报错
        int i=1/0;
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return new ArrayList<>();
    }
}

我们通过postman测试后查看结果：

相信你看到这里，对于AOP的流程应该有了一个基础的了解 

5.SpringAOP的实现原理

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

Spring AOP 的实现原理是基于动态代理和字节码操作的。

      在编译时， Spring 会使用 AspectJ 编译器将切面代码编译成字节码文件。在运行时， Spring 会使用 Java 动态代理或 CGLIB 代理生成代理类，这些代理类会在目标对象方法执行前后插入切面代码，从而实现AOP的功能。

       Spring AOP 可以使用两种代理方式：JDK动态代理和 CGLIB 代理。如果目标对象实现了至少一个接口，则使用JDK动态代理；否则，使用 CGLIB 代理。下面分别介绍这两种代理方式的实现原理。

5.1 JDK动态代理

      JDK 动态代理是 Java 自带的动态代理实现方式。使用JDK动态代理时，需要目标对象实现至少一个接口。JDK 动态代理会在运行时生成一个实现了目标对象接口的代理类，该代理类会在目标对象方法执行前后插入切面代码。

      下面是JDK动态代理的实现代码：

public class JdkDynamicAopProxy implements AopProxy, InvocationHandler {

    private final AdvisedSupport advised;

    public JdkDynamicAopProxy(AdvisedSupport advised) {
        this.advised = advised;
    }

    @Override
    public Object getProxy() {
        return Proxy.newProxyInstance(
                getClass().getClassLoader(),
                advised.getTargetSource().getInterfaces(),
                this
        );
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        MethodInterceptor methodInterceptor = advised.getMethodInterceptor();
        MethodInvocation methodInvocation = new ReflectiveMethodInvocation(
                advised.getTargetSource().getTarget(),
                method,
                args,
                methodInterceptor,
                advised.getTargetSource().getTargetClass()
        );
        return methodInvocation.proceed();
    }
}

在该代码中，JdkDynamicAopProxy 类实现了 AopProxy 和 InvocationHandler 接口。getProxy 方法返回一个代理对象，该代理对象实现了目标对象实现的所有接口。invoke 方法用于执行代理方法，该方法会在目标对象方法执行前后插入切面代码。

5.2 CGLIB代理

      CGLIB 代理是一个基于字节码操作的代理方式，它可以为没有实现接口的类创建代理对象。CGLIB 代理会在运行时生成一个目标对象的子类，并覆盖其中的方法，以实现AOP的功能。

      下面是 CGLIB 代理的实现代码：

public class CglibAopProxy implements AopProxy {

    private final AdvisedSupport advised;

    public CglibAopProxy(AdvisedSupport advised) {
        this.advised = advised;
    }

    @Override
    public Object getProxy() {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(advised.getTargetSource().getTargetClass());
        enhancer.setCallback(new DynamicAdvisedInterceptor(advised));
        return enhancer.create();
    }

    private static class DynamicAdvisedInterceptor implements MethodInterceptor {

        private final AdvisedSupport advised;

        public DynamicAdvisedInterceptor(AdvisedSupport advised) {
            this.advised = advised;
        }

        @Override
        public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
            MethodInvocation methodInvocation = new CglibMethodInvocation(
                    advised.getTargetSource().getTarget(),
                    method,
                    args,
                    proxy,
                    advised.getMethodInterceptor(),
                    advised.getTargetSource().getTargetClass()
            );
            return methodInvocation.proceed();
        }
    }
}

在该代码中，CglibAopProxy 类实现了 AopProxy 接口。getProxy 方法返回一个代理对象，该代理对象是目标对象的子类，并覆盖了其中的方法。DynamicAdvisedInterceptor 类实现了 MethodInterceptor 接口，用于在目标对象方法执行前后插入切面代码。

6.SpringAOP相关体系总结

本文介绍了 Spring AOP 的实现原理，并通过实例解析详细阐述了其实现过程。在使用 Spring AOP时，我们需要定义切面类，并为需要实现AOP的方法添加注解。 Spring 会自动将切面逻辑插入到这些方法中，从而实现AOP的功能。

SpringAOP相关的知识可以用一张图来表示清楚：