Spring AOPAOP概念组成应用场景实现及实现原理剖析

Posted 2022-08-23 Perceus

@TOC

---

什么是 Spring AOP？

• 面向切面编程（AOP）和 面向对象编程（OOP）类似，也是一种编程模式。Spring AOP 是基于 AOP 编程模式的一个框架，它的使用有效减少了系统间的重复代码，达到了模块间的松耦合目的。
• 它是⼀种思想，它是对某⼀类事情的 集中处理。⽐如⽤户登录权限的效验，没学 AOP 之前，我们所有需要判断⽤户登录的⻚⾯（中的 ⽅法），都要各⾃实现或调⽤⽤户验证的⽅法，然⽽有了 AOP 之后，我们只需要在某⼀处配置⼀ 下，所有需要判断⽤户登录⻚⾯（中的⽅法）就全部可以实现⽤户登录验证了，不再需要每个⽅ 法中都写相同的⽤户登录验证了。
• AOP 是⼀种思想，⽽ Spring AOP 是⼀个框架，提供了⼀种对 AOP 思想的实现，它们的关系和 IoC 与 DI 类似。

---

AOP 相关术语

为了更好地理解 AOP，就需要对 AOP 的相关术语有一些了解，这些专业术语

---

为什要用 AOP？

---

AOP 应用场景

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

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

---

AOP 组成

---

1. 切面（Aspect）

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

---

2. 连接点（Join Point）

应⽤执⾏过程中能够插⼊切⾯的⼀个点，这个点可以是⽅法调⽤时，抛出异常时，甚⾄修改字段 时。切⾯代码可以利⽤这些点插⼊到应⽤的正常流程之中，并添加新的⾏为。

---

3. 切点（Pointcut）

Pointcut 是匹配 Join Point 的谓词。

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

---

4. 通知（Advice）

切⾯也是有⽬标的 ——它必须完成的⼯作。在 AOP 术语中，切⾯的⼯作被称之为通知

Spring 切⾯类中，可以在⽅法上使⽤以下注解，会设置⽅法为通知⽅法，在满⾜条件后会通知本 ⽅法进⾏调⽤：

---

---

Spring AOP 实现

我们使⽤ Spring AOP 来实现⼀下 AOP 的功能。

⽬标是拦截所有 UserController ⾥⾯的 ⽅法，每次调⽤ UserController 中任意⼀个⽅法时，都执⾏相应的通知事件。

Spring AOP 的实现步骤如下：

---

1. 添加 AOP 框架支持

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

<!-- https://mvnrepository.com/artifact/org.springframework.boot/springboot-starter-aop -->
<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

---

2. 定义切⾯和切点

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

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
@Aspect // 表明此类为⼀个切⾯
@Component //在启动时自动加载
public class UserAspect 
    // 定义切点，这⾥使⽤ AspectJ 表达式语法
    @Pointcut("execution(* com.example.demo.controller.UserController.*
(..))")
    public void pointcut() 

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

---

① 切点表达式说明

AspectJ ⽀持三种通配符

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

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

修饰符和异常可以省略。

---

② 表达式示例

1.匹配 User 类⾥的所有⽅法：

execution(* com.cad.demo.User.*(..))

2.匹配该类的⼦类包括该类的所有⽅法。

execution(* com.cad.demo.User+.*(..))

3.匹配 com.cad 包下的所有类的所有⽅法。

 execution(* com.cad.*.*(..))

4.匹配 com.cad 包下、⼦孙包下所有类的所有⽅法。

 execution(* com.cad..*.*(..)) 

5.匹配 addUser ⽅法，且第⼀个参数类型是 String，第⼆个 参数类型是 int。

execution(* addUser(String, int))

---

3. 定义通知 Advice

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

具体实现如下：

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class UserAspect 
    // 定义切点⽅法
    @Pointcut("execution(* com.example.demo.controller.UserController.*
(..))")
    public void pointcut() 
    // 前置通知
    @Before("pointcut()")
    public void doBefore()
        System.out.println("执⾏ Before ⽅法");
   
    // 后置通知
    @After("pointcut()")
    public void doAfter()
        System.out.println("执⾏ After ⽅法");
   
    // return 之前通知
    @AfterReturning("pointcut()")
    public void doAfterReturning()
        System.out.println("执⾏ AfterReturning ⽅法");
   
    // 抛出异常之前通知
    @AfterThrowing("pointcut()")
    public void doAfterThrowing()
        System.out.println("执⾏ doAfterThrowing ⽅法");
   

    // 添加环绕通知
    @Around("pointcut()")
    public Object doAround(ProceedingJoinPoint joinPoint)
        Object obj = null;
        System.out.println("Around ⽅法开始执⾏");
        try 
            // 执⾏拦截⽅法
           obj = joinPoint.proceed();
        catch (Throwable throwable) 
            throwable.printStackTrace();
       
        System.out.println("Around ⽅法结束执⾏");
        return obj;
   

经过以上的代码我们就能实现 Spring AOP 了。

---

Spring AOP 实现原理

---

织⼊（Weaving）：代理的⽣成时机

织⼊是把切⾯应⽤到⽬标对象并创建新的代理对象的过程，切⾯在指定的连接点被织⼊到⽬标对 象中。

在⽬标对象的⽣命周期⾥有多个点可以织⼊：

---

动态代理

此种实现在设计模式上称为动态代理模式，在实现的技术⼿段上，都是在 class 代码运⾏期，动态的织⼊字节码。

我们学习 Spring 框架中的AOP，主要基于两种⽅式：JDK 及 CGLIB 的⽅式。

这两种⽅式的代理⽬标都是被代理类中的⽅法，在运⾏期，动态的织⼊字节码⽣成代理类。

---

JDK 动态代理实现

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

以下为代码实现：

import org.example.demo.service.AliPayService;
import org.example.demo.service.PayService;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.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();
   

---

CGLIB 动态代理实现

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import org.example.demo.service.AliPayService;
import org.example.demo.service.PayService;
import java.lang.reflect.Method;
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();
   

---

JDK 和 CGLIB 实现的区别

---

总结

AOP 是对某⽅⾯能⼒的统⼀实现，它是⼀种实现思想，Spring AOP 是对 AOP 的具体实现，Spring AOP 可通过 AspectJ（注解）的⽅式来实现 AOP 的功能，Spring AOP 的实现步骤是：

---

Spring AOP 是通过动态代理的⽅式，在运⾏期将 AOP 代码织⼊到程序中的，它的实现⽅式有两种：

---