Spring AOP

1.什么是 Spring AOP？

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

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

OOP:面向对象编程

AOP:面向切面编程

2.为什要用AOP？

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

• 统⼀⽇志记录
• 统⼀⽅法执⾏时间统计
• 统⼀的返回格式设置
• 统⼀的异常处理
• 事务的开启和提交等

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

3.Spring AOP 应该怎么学习呢？

Spring AOP 学习主要分为以下 3 个部分：

1. 学习 AOP 是如何组成的？也就是学习 AOP 组成的相关概念。

2. 学习 Spring AOP 使⽤。

3. 学习 Spring AOP 实现原理。

3.1 AOP 组成

3.1.1 切面（Aspect）

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

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

3.1.2 连接点（Join Point）

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

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

3.1.3 切点（Pointcut）

Pointcut 是匹配 Join Point 的谓词。

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

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

3.1.4 通知（Advice）

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

通知：定义了切⾯是什么，何时使⽤，其描述了切⾯要完成的⼯作，还解决何时执⾏这个⼯作的 问题。

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

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

切点相当于要增强的⽅法。

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

3.2 Spring AOP 实现

接下来我们使⽤ Spring AOP 来实现⼀下 AOP 的功能，完成的⽬标是拦截所有 UserController ⾥⾯的 ⽅法，每次调⽤ UserController 中任意⼀个⽅法时，都执⾏相应的通知事件。

Spring AOP 的实现步骤如下：

1. 添加 Spring AOP 框架⽀持。

2. 定义切⾯和切点。

3. 定义通知。

3.2.1 添加 AOP 框架支持

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

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

3.2.2 定义切⾯和切点

切点指的是具体要处理的某⼀类问题，⽐如⽤户登录权限验证就是⼀个具体的问题，记录所有⽅法的执 ⾏⽇志就是⼀个具体的问题，切点定义的是某⼀类问题。

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

package com.example.demo.aspect;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
public class LoginAspect {
    @Pointcut("execution(* com.example.demo.controller.UserController.*(..))")
    public void pointcut(){ }
}

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

切点表达式说明

AspectJ⽀持三种通配符

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

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

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

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

 表达式示例

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。

3.2.3 定义相关通知

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

• 前置通知使⽤@Before：通知⽅法会在⽬标⽅法调⽤之前执⾏。
• 后置通知使⽤@After：通知⽅法会在⽬标⽅法返回或者抛出异常后调⽤。
• 返回之后通知使⽤@AfterReturning：通知⽅法会在⽬标⽅法返回后调⽤。
• 抛异常后通知使⽤@AfterThrowing：通知⽅法会在⽬标⽅法抛出异常后调⽤。
• 环绕通知使⽤@Around：通知包裹了被通知的⽅法，在被通知的⽅法通知之前和调⽤之后执⾏自定义的⾏为。

具体实现如下：

package com.example.demo.aspect;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Slf4j
@Component
@Aspect//这是一个切面类
public class LoginAspect {
    //定义一个切点
    @Pointcut("execution(* com.example.demo.controller.UserController.*(..))")
    public void pointcut(){ }

    //前置通知
    @Before("pointcut()")
    //通知方法
    public void doBefore(){
        log.info("do before...");
    }

    //后置通知
    @After("pointcut()")
    public void doAfter(){
        log.info("do after");
    }

    //return之前通知
    @AfterReturning("pointcut()")
    public void doAfterReturning(){
        log.info("do afterReturning");
    }

    //抛出异常之前通知
    @AfterThrowing("pointcut()")
    public void doAfterThrowing(){
        log.info("do afterThrowing");
    }

    // 添加环绕通知
    @Around("pointcut()")
    public Object doAround(ProceedingJoinPoint joinPoint){
        Object oj = null;
        log.info("环绕通知执行之前...");
        log.info(joinPoint.getSignature().toLongString());
        try {
            oj = joinPoint.proceed();//调用目标方法
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }
        log.info("环绕通知执行之后....");
        return oj;
    }
}

 

3.3 Spring AOP 实现原理

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

Spring AOP ⽀持 JDK Proxy 和 CGLIB ⽅式实现动态代理。默认情况下，实现了接⼝的类，使 ⽤ AOP 会基于 JDK ⽣成代理类，没有实现接⼝的类，会基于 CGLIB ⽣成代理类。

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

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

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

• 编译期：切⾯在⽬标类编译时被织⼊。这种⽅式需要特殊的编译器。AspectJ的织⼊编译器就 是以这种⽅式织⼊切⾯的。
• 类加载期：切⾯在⽬标类加载到JVM时被织⼊。这种⽅式需要特殊的类加载器 （ClassLoader）,它可以在⽬标类被引⼊应⽤之前增强该⽬标类的字节码。AspectJ5的加载 时织⼊（load-time weaving. LTW）就⽀持以这种⽅式织⼊切⾯。
• 运⾏期：切⾯在应⽤运⾏的某⼀时刻被织⼊。⼀般情况下，在织⼊切⾯时，AOP容器会为⽬标对象动态创建⼀个代理对象。SpringAOP就是以这种⽅式织⼊切⾯的。

动态代理 

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

Spring 框架中的AOP，主要基于两种⽅式：JDK 及 CGLIB 的⽅式。这两种⽅式的代理⽬标都是被代理类中的⽅法，在运⾏期，动态的织⼊字节码⽣成代理类。

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

4.代理模式

定义：为其他对象提供⼀种代理以控制对这个对象的访问。在某些情况下，⼀个对象不适合或者不能直接引⽤另⼀个对象，⽽代理对象可以在客户端和⽬标对象之间起到中介的作⽤。

代理类包含委托类和目标类。

代理模式分为静态代理和动态代理

4.1静态代理

静态代理中，我们对⽬标对象的每个⽅法的增强都是⼿动完成的，⾮常不灵活（⽐ 如接⼝⼀旦新增加⽅法，⽬标对象和代理对象都要进⾏修改）且麻烦(需要对每个 ⽬标类都单独写⼀个代理类）。 实际应⽤场景⾮常⾮常少，⽇常开发⼏乎看不到 使⽤静态代理的场景。

上⾯我们是从实现和应⽤⻆度来说的静态代理，从 JVM 层⾯来说， 静态代理在编 译时就将接⼝、实现类、代理类这些都变成了⼀个个实际的 class ⽂件。

4.1.1静态代理实现步骤:

1. 定义⼀个接⼝及其实现类；

2. 创建⼀个代理类同样实现这个接⼝

3. 将⽬标对象注⼊进代理类，然后在代理类的对应⽅法调⽤⽬标类中的对应⽅法。

这样的话，我们就可以通过代理类屏蔽对⽬标对象的访问，并且可以在⽬标⽅法执 ⾏前后做⼀些⾃⼰想做的事情。

实现

1. 定义接⼝

public interface PayService {
 void pay();
}

2. 实现接⼝

public class AliPayService implements PayService {
 @Override
 public void pay() {
 System.out.println("ali pay...");
 }
}

3. 创建代理类, 并同样实现⽀付接⼝

public class StaticProxy implements PayService{
 private final PayService payService;
 public StaticProxy(PayService payService) {
 this.payService = payService;
 }
 @Override
 public void pay() {
 System.out.println("before...");
 payService.pay();
 System.out.println("after...");
 }
}

 4. 实际使⽤

public class Main {
 public static void main(String[] args) {
 PayService service = new AliPayService();
 PayService proxy = new StaticProxy(service);
 proxy.pay();
 }
}

4.2动态代理

相⽐于静态代理来说，动态代理更加灵活。我们不需要针对每个⽬标类都单独创建 ⼀个代理类，并且也不需要我们必须实现接⼝，我们可以直接代理实现类( CGLIB 动态代理机制)。

从 JVM ⻆度来说，动态代理是在运⾏时动态⽣成类字节码，并加载到 JVM 中 的。

说到动态代理，不得不提的是Spring AOP，它的实现依赖了动态代理。

动态代理在我们⽇常开发中使⽤的相对较少，但是在框架中的⼏乎是必⽤的⼀⻔技 术。学会了动态代理之后，对于我们理解和学习各种框架的原理也⾮常有帮助。

就 Java 来说，动态代理的实现⽅式有很多种，⽐如 JDK 动态代理、CGLIB 动态代理等等。

4.2.1JDK动态代理

在 Java 动态代理机制中 InvocationHandler 接⼝和 Proxy 类是核⼼。

4.2.2JDK 动态代理类使⽤步骤:

1. 定义⼀个接⼝及其实现类；

2. ⾃定义 InvocationHandler 并重写invoke⽅法，在 invoke ⽅法中我们会调⽤ 原⽣⽅法（被代理类的⽅法）并⾃定义⼀些处理逻辑；

3. 通过 Proxy.newProxyInstance(ClassLoader loader,Class[] interfaces,InvocationHandler h) ⽅法创建代理对象；

定义JDK动态代理类

package com.example.demo.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class JDKInvocationHandler implements InvocationHandler {
    //⽬标对象即就是被代理对象
    private Object target;
    public JDKInvocationHandler(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();
        //创建⼀个代理类：通过被代理类、被代理实现的接⼝、⽅法调⽤处理器来创建
        PayService proxy = (PayService) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                new Class[]{PayService.class},
                new JDKInvocationHandler(target)
        );
        proxy.pay();
    }

Proxy 类中使⽤频率最⾼的⽅法是：newProxyInstance() ，这个⽅法主要⽤来⽣ 成⼀个代理对象

public static Object newProxyInstance(ClassLoader loader, Class[] interfaces,InvocationHandler h)
 throws IllegalArgumentException
 {
 ....
 }

这个⽅法⼀共有 3 个参数：

1. loader :类加载器，⽤于加载代理对象。

2. interfaces : 被代理类实现的⼀些接⼝；

3. h : 实现了 InvocationHandler 接⼝的对象； 

4.2.3CGLIB动态代理

JDK 动态代理有⼀个最致命的问题是其只能代理实现了接⼝的类。

为了解决这个问题，我们可以⽤ CGLIB 动态代理机制来避免。

CGLIB(Code Generation Library)是⼀个基于ASM的字节码⽣成库，它允许我们在运⾏时对字节码进⾏修改和动态⽣成。CGLIB 通过继承⽅式实现代理。很多知名的开源框架都使⽤到了CGLIB， 例如 Spring 中的 AOP 模块中：如果⽬标对象 实现了接⼝，则默认采⽤ JDK 动态代理，否则采⽤ CGLIB 动态代理。

在 CGLIB 动态代理机制中 MethodInterceptor 接⼝和 Enhancer 类是核⼼。

4.2.4CGLIB 动态代理类使⽤步骤

1. 定义⼀个类；

2. ⾃定义 MethodInterceptor 并重写 intercept ⽅法，intercept ⽤于拦截增强被代理类的⽅法，和 JDK 动态代理中的 invoke ⽅法类似；

3. 通过 Enhancer 类的 create()创建代理类

添加依赖

和JDK 动态代理不同, CGLIB(Code Generation Library) 实际是属于⼀个开源项 ⽬，如果你要使⽤它的话，需要⼿动添加相关依赖。

 cglib
 cglib
 3.3.0

⾃定义 MethodInterceptor（⽅法拦截器） 

package com.example.demo.proxy;

import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

public class CGLIBInterceptor implements MethodInterceptor {
    //被代理对象
    private Object target;
    public CGLIBInterceptor(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 CGLIBInterceptor(target));
        proxy.pay();
    }

需要⾃定义 MethodInterceptor 并重写 intercept ⽅法，intercept ⽤于拦截增 强被代理类的⽅法。

public interface MethodInterceptor
extends Callback{
 // 拦截被代理类中的⽅法
 public Object intercept(Object obj, java.lang.reflect.Method method, Ob
ject[] args,MethodProxy proxy) throws Throwable;
}

 1. obj : 被代理的对象（需要增强的对象）

2. method : 被拦截的⽅法（需要增强的⽅法）

3. args : ⽅法⼊参

4. proxy : ⽤于调⽤原始⽅法

4.3JDK 动态代理和 CGLIB 动态代理对⽐

1. JDK 动态代理只能代理实现了接⼝的类或者直接代理接⼝，⽽ CGLIB 可以代 理未实现任何接⼝的类。

2. CGLIB 动态代理是通过⽣成⼀个被代理类的⼦类来拦截被代理类的⽅法调⽤，因此不能代理声明为 final

性能: ⼤部分情况都是 JDK 动态代理更优秀，随着 JDK 版本的升级，这个优势更加明显。

Spring代理选择

1. proxyTargetClass 为false, ⽬标实现了接⼝, ⽤jdk代理

2. proxyTargetClass 为false, ⽬标未实现接⼝, ⽤cglib代理

3. proxyTargetClass 为true, ⽤cglib代理

总结

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

1. 添加 AOP 框架⽀持。
2. 定义切⾯和切点。
3. 定义通知。

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