【JavaEE】深入浅出 Spring AOP：概念、实现与原理解析

Spring AOP

1. 了解AOP的概念
2. 学习Spring AOP的实现⽅式以及实现原理, 对代理模式有⼀定了解

AOP概述

学习完Spring的统⼀功能之后, 我们进⼊到AOP的学习. AOP是Spring框架的第⼆⼤核⼼(第⼀⼤核⼼是IoC)

Spring两大核心思想：

1. IoC
2. AOP

什么是AOP？

• Aspect Oriented Programming（⾯向切⾯编程）

什么是⾯向切⾯编程呢? 切⾯就是指某⼀类特定问题, 所以AOP也可以理解为⾯向特定⽅法编程.

什么是⾯向特定⽅法编程呢? ⽐如上个章节学习的"登录校验", 就是⼀类特定问题. 登录校验拦截器, 就是对"登录校验"这类问题的统⼀处理. 所以, 拦截器也是AOP的⼀种应⽤. AOP是⼀种思想, 拦截器是AOP思想的⼀种实现. Spring框架实现了这种思想, 提供了拦截器技术的相关接⼝.

同样的, 统⼀数据返回格式和统⼀异常处理, 也是AOP思想的⼀种实现.

简单来说: AOP是⼀种思想, 是对某⼀类事情的集中处理.

什么是Spring AOP?

AOP是⼀种思想, 它的实现⽅法有很多, 有Spring AOP，也有AspectJ、CGLIB等.

Spring AOP是其中的⼀种实现⽅式.

学会了统⼀功能之后, 是不是就学会了Spring AOP呢, 当然不是.

拦截器作⽤的维度是URL(⼀次请求和响应), @ControllerAdvice 应⽤场景主要是全局异常处理(配合⾃定义异常效果更佳), 数据绑定, 数据预处理. AOP作⽤的维度更加细致(可以根据包、类、⽅法名、参数等进⾏拦截), 能够实现更加复杂的业务逻辑.

举个例⼦:

我们现在有⼀个项⽬, 项⽬中开发了很多的业务功能

现在有⼀些业务的执⾏效率⽐较低, 耗时较⻓, 我们需要对接⼝进⾏优化.

第⼀步就需要定位出执⾏耗时⽐较⻓的业务⽅法, 再针对该业务⽅法来进⾏优化

如何定位呢? 我们就需要统计当前项⽬中每⼀个业务⽅法的执⾏耗时.

如何统计呢? 可以在业务⽅法运⾏前和运⾏后, 记录下⽅法的开始时间和结束时间, 两者之差就是这个⽅法的耗时.

这种⽅法是可以解决问题的, 但⼀个项⽬中会包含很多业务模块, 每个业务模块⼜有很多接⼝, ⼀个接⼝⼜包含很多⽅法, 如果我们要在每个业务⽅法中都记录⽅法的耗时, 对于程序员⽽⾔, 会增加很多的⼯作量.

AOP就可以做到在不改动这些原始⽅法的基础上, 针对特定的⽅法进⾏功能的增强.

AOP的作⽤：在程序运⾏期间在不修改源代码的基础上对已有⽅法进⾏增强（⽆侵⼊性: 解耦）

接下来我们来看Spring AOP如何来实现

Spring AOP快速⼊⻔

学习什么是AOP后, 我们先通过下⾯的程序体验下AOP的开发, 并掌握Spring中AOP的开发步骤.

需求: 统计图书系统各个接⼝⽅法的执⾏时间.

引⼊AOP依赖

在pom.xml⽂件中添加配置

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

编写AOP程序

记录Controller中每个⽅法的执⾏时间

//只是应用了 aspectj 的注解
@Aspect
@Slf4j
@Component
public class TimeAspect {
    @Around("execution(* com.Hsu.book.controller.*.*(..))")//针对的是所有的controller
    public Object timeCost(ProceedingJoinPoint joinPoint) throws Throwable {//这个参数表示的是作用的方法
        long start=System.currentTimeMillis();
        //执行目标方法
        Object result=joinPoint.proceed();
        long end=System.currentTimeMillis();
        log.info(joinPoint.toString()+"消耗时间："+(end-start)+"ms");
        return result;
    }
}

运⾏程序, 观察⽇志

对程序进⾏简单的讲解:

1. @Aspect: 标识这是⼀个切⾯类
2. @Around: 环绕通知, 在⽬标⽅法的前后都会被执⾏. 后⾯的表达式表⽰对哪些⽅法进⾏增强.
3. ProceedingJoinPoint.proceed() 让原始⽅法执⾏

整个代码划分为三部分

我们通过AOP⼊⻔程序完成了业务接⼝执⾏耗时的统计.

通过上⾯的程序, 我们也可以感受到AOP⾯向切⾯编程的⼀些优势：

• 代码⽆侵⼊: 不修改原始的业务⽅法, 就可以对原始的业务⽅法进⾏了功能的增强或者是功能的改变
• 减少了重复代码
• 提⾼开发效率
• 维护⽅便

Spring AOP 详解

下⾯我们再来详细学习AOP, 主要是以下⼏部分

• Spring AOP中涉及的核⼼概念
• Spring AOP通知类型
• 多个AOP程序的执⾏顺序

Spring AOP核⼼概念

切点(Pointcut)

切点(Pointcut), 也称之为"切⼊点"

Pointcut 的作⽤就是提供⼀组规则 (使⽤ AspectJ pointcut expression language 来描述), 告诉程序对哪些⽅法来进⾏功能增强.

上⾯的表达式 execution(* com.Hsu.book.controller.*.*(..)) 就是切点表达式。

这个就是作用域，也就是AOP在哪个环节起作用，以及对哪些方法起作用

ProceedingJoinPoint joinPoint 这个就是目标方法

连接点(Join Point)

满⾜切点表达式规则的⽅法, 就是连接点. 也就是可以被AOP控制的⽅法，也就是目标方法

以⼊⻔程序举例, 所有 com.com.Hsu.book.controller 路径下的⽅法, 都是连接点。

@Slf4j
@RestController
@RequestMapping("/book")
public class BookController {
    @RequestMapping("/getBookListByPage")
    public Result getBookListByPage(PageRequest pageRequest, HttpSession session){   
    }
    
    @RequestMapping(value = "/addBook", produces = "application/json")
    public String addBook(BookInfo bookInfo) {
    }
    
    @RequestMapping("/queryBookInfoById")
    public BookInfo queryBookInfoById(Integer bookId) {
    }
    
    @RequestMapping(value = "/updateBook", produces = "application/json")
    public String updateBook(BookInfo bookInfo) {
    }
    
    @RequestMapping(value = "/batchDelete", produces = "application/json")
    public String batchDelete(@RequestParam List<Integer> ids) {
    }
}

上述 BookController 中的⽅法都是连接点

切点和连接点的关系

连接点是满⾜切点表达式的元素. 切点可以看做是保存了众多连接点的⼀个集合.

⽐如:

切点表达式: 学校全体老师

连接点就是: 张三,李四等各个⽼师

通知(Advice)

通知就是具体要做的⼯作, 指哪些重复的逻辑，也就是共性功能(最终体现为⼀个⽅法)

⽐如上述程序中记录业务⽅法的耗时时间, 就是通知.

在AOP⾯向切⾯编程当中, 我们把这部分重复的代码逻辑抽取出来单独定义, 这部分代码就是通知的内容.

切⾯(Aspect)

切⾯(Aspect) = 切点(Pointcut) + 通知(Advice)

通过切⾯就能够描述当前AOP程序需要针对于哪些⽅法, 在什么时候执⾏什么样的操作。

切⾯既包含了通知逻辑的定义, 也包括了连接点的定义。

切⾯所在的类, 我们⼀般称为切⾯类(被**@Aspect注解标识的类**)

一个类可以用多个切面

通知类型

上⾯我们讲了什么是通知, 接下来学习通知的类型. @Around 就是其中⼀种通知类型, 表⽰环绕通知.

Spring中AOP的通知类型有以下⼏种:

• @Around: 环绕通知, 此注解标注的通知⽅法在⽬标⽅法前, 后都被执⾏
• @Before: 前置通知, 此注解标注的通知⽅法在⽬标⽅法前被执⾏
• @After: 后置通知, 此注解标注的通知⽅法在⽬标⽅法后被执⾏, ⽆论是否有异常都会执⾏
• @AfterReturning: 返回后通知, 此注解标注的通知⽅法在⽬标⽅法后被执⾏, 有异常不会执⾏
• @AfterThrowing: 异常后通知, 此注解标注的通知⽅法发⽣异常后执⾏

接下来我们通过代码来加深对这⼏个通知的理解:

为⽅便学习, 我们可以新建⼀个项⽬

@Slf4j
@Component
@Aspect
public class AspectDemo {
    @Before("execution(* com.Hsu.demo.controller.*.*(..))")
    public void doBefore(){
        log.info("执行Aspect Before");
    }

    @After("execution(* com.Hsu.demo.controller.*.*(..))")
    public void doAfter(){
        log.info("执行Aspect After");
    }

    @AfterReturning("execution(* com.Hsu.demo.controller.*.*(..))")
    public void doAfterReturning(){
        log.info("执行Aspect AfterReturning");
    }

    @AfterThrowing("execution(* com.Hsu.demo.controller.*.*(..))")
    public void doAfterThrowing(){
        log.info("执行Aspect AfterThrowing");
    }

    @Around("execution(* com.Hsu.demo.controller.*.*(..))")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("执行Aspect Around 前");
        Object result=joinPoint.proceed();
        log.info("执行Aspect Around 后");
        return result;
    }
}

写⼀些测试程序:

@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String hello(){
        return "hello";
    }

    @RequestMapping("t1")
    public String t1(){
        int a=10/0;
        return "t1";
    }
}

运⾏程序, 观察⽇志:

1. 正常运⾏的情况

http://127.0.0.1:8080/hello

观察⽇志

程序正常运⾏的情况下, @AfterThrowing 标识的通知⽅法不会执⾏

从上图也可以看出来, @Around 标识的通知⽅法包含两部分, ⼀个"前置逻辑", ⼀个"后置逻辑".其中"前置逻辑" 会先于 @Before 标识的通知⽅法执⾏, “后置逻辑” 会晚于 @After 标识的通知⽅法执⾏

先around，再before，先after，再around

2. 异常时的情况

http://127.0.0.1:8080/t1

观察⽇志:

程序发⽣异常的情况下：

• @AfterReturning 标识的通知⽅法不会执⾏， @AfterThrowing 标识的通知⽅法执⾏了

• @Around 环绕通知中原始⽅法调⽤时有异常，通知中的环绕后的代码逻辑也不会在执⾏了(因为

  原始⽅法调⽤出异常了)

注意事项:

• @Around 环绕通知需要调⽤ ProceedingJoinPoint.proceed() 来让原始⽅法执⾏, 其他通知不需要考虑⽬标⽅法执⾏.
• @Around 环绕通知⽅法的返回值, 必须指定为Object, 来接收原始⽅法的返回值, 否则原始⽅法执⾏完毕, 是获取不到返回值的.
• ⼀个切⾯类可以有多个切点.

@PointCut

上⾯代码存在⼀个问题, 就是存在⼤量重复的切点表达式 execution(* com.example.demo.controller.*.*(..)) , Spring提供了 @PointCut 注解, 把公共的切点表达式提取出来, 需要⽤到时引⽤该切⼊点表达式即可.

上述代码就可以修改为:

@Slf4j
@Component
@Aspect
public class AspectDemo {
    @Pointcut("execution(* com.Hsu.demo.controller.*.*(..))")
    private void pt(){//定义切点，叫pt
    }

    @Before("pt()")
    public void doBefore(){
        log.info("执行Aspect Before");
    }

    @After("pt()")
    public void doAfter(){
        log.info("执行Aspect After");
    }

    @AfterReturning("pt()")
    public void doAfterReturning(){
        log.info("执行Aspect AfterReturning");
    }

    @AfterThrowing("pt()")
    public void doAfterThrowing(){
        log.info("执行Aspect AfterThrowing");
    }

    @Around("pt()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("执行Aspect Around 前");
        Object result=joinPoint.proceed();
        log.info("执行Aspect Around 后");
        return result;
    }
}

当切点定义使⽤private修饰时, 仅能在当前切⾯类中使⽤, 当其他切⾯类也要使⽤当前切点定义时, 就需要把private改为public. 引⽤⽅式为: 类的全限定类名.⽅法名()

@Slf4j
@Aspect
@Component
public class AspectDemo1 {
    @Before("com.Hsu.demo.aspect.AspectDemo.pt()")
    public void doBefore() {
        log.info("执⾏ AspectDemo1 Before ⽅法");
    }

    @After("com.Hsu.demo.aspect.AspectDemo.pt()")
    public void doAfter() {
        log.info("执⾏ AspectDemo1 After ⽅法");
    }
}

切⾯优先级 @Order

当我们在⼀个项⽬中, 定义了多个切⾯类时, 并且这些切⾯类的多个切⼊点都匹配到了同⼀个⽬标⽅法.

当⽬标⽅法运⾏的时候, 这些切⾯类中的通知⽅法都会执⾏, 那么这⼏个通知⽅法的执⾏顺序是什么样的呢?

我们还是通过程序来求证:

定义多个切⾯类:

为防⽌⼲扰, 我们把AspectDemo这个切⾯先去掉(把 @Component 注解去掉就可以)

为简单化, 只写了 @Before 和 @After 两个通知

@Slf4j
@Aspect
@Component
public class AspectDemo1 {
    @Before("com.Hsu.demo.aspect.AspectDemo.pt()")
    public void doBefore() {
        log.info("执⾏ AspectDemo1 Before ⽅法");
    }

    @After("com.Hsu.demo.aspect.AspectDemo.pt()")
    public void doAfter() {
        log.info("执⾏ AspectDemo1 After ⽅法");
    }
}

@Slf4j
@Aspect
@Component
public class AspectDemo2 {
    @Before("com.Hsu.demo.aspect.AspectDemo.pt()")
    public void doBefore() {
        log.info("执⾏ AspectDemo2 Before ⽅法");
    }

    @After("com.Hsu.demo.aspect.AspectDemo.pt()")
    public void doAfter() {
        log.info("执⾏ AspectDemo2 After ⽅法");
    }
}

@Slf4j
@Aspect
@Component
public class AspectDemo3 {
    @Before("com.Hsu.demo.aspect.AspectDemo.pt()")
    public void doBefore() {
        log.info("执⾏ AspectDemo3 Before ⽅法");
    }

    @After("com.Hsu.demo.aspect.AspectDemo.pt()")
    public void doAfter() {
        log.info("执⾏ AspectDemo3 After ⽅法");
    }
}

运⾏程序, 访问接⼝:

http://127.0.0.1:8080/hello

观察⽇志:

通过上述程序的运⾏结果, 可以看出:

存在多个切⾯类时, 默认按照切⾯类的类名字⺟排序：

• @Before 通知：字⺟排名靠前的先执⾏
• @After 通知：字⺟排名靠前的后执⾏

即当有多个切面时，切面的执行顺序按名称进行排序的。优先级高的先执行before，后执行after

但这种⽅式不⽅便管理, 我们的类名更多还是具备⼀定含义的.

Spring 给我们提供了⼀个新的注解, 来控制这些切⾯通知的执⾏顺序: @Order

使⽤⽅式如下:

@Slf4j
@Aspect
@Component
@Order(2)
public class AspectDemo1{
    //省略
}

@Slf4j
@Aspect
@Component
@Order(1)
public class AspectDemo2{
    //省略
}

@Slf4j
@Aspect
@Component
@Order(3)
public class AspectDemo3{
    //省略
}

重新运⾏程序, 访问接⼝ http://127.0.0.1:8080/hello

通过上述程序的运⾏结果, 得出结论:

@Order 注解标识的切⾯类, 执⾏顺序如下:

@Before 通知：数字越⼩先执⾏

@After 通知：数字越⼤先执⾏

@Order 控制切⾯的优先级, 先执⾏优先级较⾼的切⾯, 再执⾏优先级较低的切⾯, 最终执⾏⽬标⽅法.

切点表达式

上⾯的代码中, 我们⼀直在使⽤切点表达式来描述切点. 下⾯我们来介绍⼀下切点表达式的语法.

切点表达式常⻅有两种表达⽅式

1. execution(……)：根据⽅法的签名来匹配。

   @Pointcut("execution(* com.Hsu.demo.controller.*.*(..))")

2. @annotation(……)：根据注解匹配

execution表达式

execution() 是最常⽤的切点表达式, ⽤来匹配⽅法, 语法为:

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

其中: 访问修饰符和异常可以省略

注意，第一个 * 即那个返回类型，后面需要加个空格

切点表达式⽀持通配符表达:

1. * ：匹配任意字符，只匹配⼀个元素(返回类型, 包, 类名, ⽅法或者⽅法参数)

   1. 包名使⽤ * 表⽰任意包(⼀层包使⽤⼀个*)

   2. 类名使⽤ * 表⽰任意类

   3. 返回值使⽤ * 表⽰任意返回值类型

   4. ⽅法名使⽤ * 表⽰任意⽅法

   5. 参数使⽤ * 表⽰⼀个任意类型的参数

2. .. ：匹配多个连续的任意符号, 可以通配任意层级的包, 或任意类型, 任意个数的参数

3. 使⽤ .. 配置包名，标识此包以及此包下的所有⼦包

4. 可以使⽤ .. 配置参数，任意个任意类型的参数

切点表达式⽰例

TestController 下的 public 修饰, 返回类型为 String ⽅法名为 t1, ⽆参⽅法

execution(public String com.example.demo.controller.TestController.t1())

省略访问修饰符

execution(String com.example.demo.controller.TestController.t1())

匹配所有返回类型

execution(* com.example.demo.controller.TestController.t1())

匹配 TestController 下的所有⽆参⽅法

execution(* com.example.demo.controller.TestController.*())

匹配 TestController 下的所有⽅法

execution(* com.example.demo.controller.TestController.*(..))

匹配 controller 包下所有的类的所有⽅法

execution(* com.example.demo.controller.*.*(..))

匹配所有包下⾯的 TestController

execution(* com..TestController.*(..))

匹配 com.example.demo 包下, ⼦孙包下的所有类的所有⽅法

execution(* com.example.demo..*(..))

@annotation

execution表达式更适⽤有规则的, 如果我们要匹配多个⽆规则的⽅法呢, ⽐如：TestController中的t1()和UserController中的u1()这两个⽅法.

这个时候我们使⽤execution这种切点表达式来描述就不是很⽅便了.

我们可以借助⾃定义注解的⽅式以及另⼀种切点表达式 @annotation 来描述这⼀类的切点

实现步骤：

1. 编写⾃定义注解
2. 使⽤ @annotation 表达式来描述切点
3. 在连接点的⽅法上添加⾃定义注解

@Target({ElementType.METHOD})//修饰范围
@Retention(RetentionPolicy.RUNTIME)//生命周期
public @interface MyAspect {
}

⾃定义注解 @MyAspect

创建⼀个注解类(和创建Class⽂件⼀样的流程, 选择Annotation就可以了)

@Target({ElementType.METHOD})//修饰范围
@Retention(RetentionPolicy.RUNTIME)//生命周期
public @interface MyAspect {
}

代码简单说明, 了解即可. 不做过多解释

1. @Target 标识了 Annotation 所修饰的对象范围, 即该注解可以⽤在什么地⽅.

常⽤取值:

ElementType.TYPE: ⽤于描述类、接⼝(包括注解类型) 或enum声明

ElementType.METHOD: 描述⽅法

ElementType.PARAMETER: 描述参数

ElementType.TYPE_USE: 可以标注任意类型

2. @Retention 指Annotation被保留的时间⻓短, 标明注解的⽣命周期

@Retention 的取值有三种:

1. RetentionPolicy.SOURCE：表⽰注解仅存在于源代码中, 编译成字节码后会被丢弃. 这意味着在运⾏时⽆法获取到该注解的信息, 只能在编译时使⽤. ⽐如 @SuppressWarnings , 以及lombok提供的注解 @Data , @Slf4j

2. RetentionPolicy.CLASS：编译时注解. 表⽰注解存在于源代码和字节码中, 但在运⾏时会被丢弃. 这意味着在编译时和字节码中可以通过反射获取到该注解的信息, 但在实际运⾏时⽆法获取. 通常⽤于⼀些框架和⼯具的注解.

3. RetentionPolicy.RUNTIME：运⾏时注解. 表⽰注解存在于源代码, 字节码和运⾏时中. 这意味着在编译时, 字节码中和实际运⾏时都可以通过反射获取到该注解的信息. 通常⽤于⼀些需要在运⾏时处理的注解, 如Spring的 @Controller @ResponseBody

切⾯类

使⽤ @annotation 切点表达式定义切点, 只对 @MyAspect ⽣效

切⾯类代码如下:

@Aspect
@Component
@Slf4j
public class MyAspectDemo {
    @Before("@annotation(com.Hsu.demo.aspect.MyAspect)")
    public void doBefore() {
        log.info("执⾏ MyAspectDemo Before ⽅法");
    }

    @After("@annotation(com.Hsu.demo.aspect.MyAspect)")
    public void doAfter() {
        log.info("执⾏ MyAspectDemo After ⽅法");
    }
}

添加⾃定义注解

在TestController中的t2()和HelloController中的h1()这个⽅法上添加⾃定义注解 @MyAspect , 其他⽅法不添加

@RequestMapping("/test")
@RestController
public class TestController {
    @RequestMapping("t1")
    public String t1(){
        return "t1";
    }

    @MyAspect
    @RequestMapping("t2")
    public String t2(){
        return "t2";
    }
}

@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String hello(){
        return "hello";
    }

    @MyAspect
    @RequestMapping("h1")
    public String h1(){
        return "h1";
    }

    @RequestMapping("h2")
    public String h2(){
        return "h2";
    }
}

运⾏程序, 测试接⼝

http://127.0.0.1:8080/test/t2

观察⽇志:

可以看到, 切⾯通知被执⾏了.

我们其他类比如AspectDemo1的已经将@Component这个注解注释掉了，这样就不会交给Spring管理，就不会生效了，只有自定义注解了

继续测试:

http://127.0.0.1:8080/test/t1, 切⾯通知未执⾏

http://127.0.0.1:8080/h1 , 切⾯通知执⾏.

Spring AOP的实现⽅式(常⻅⾯试题)

1. 基于注解 @Aspect (参考上述内容)

2. 基于⾃定义注解 (参考⾃定义注解 @annotation 部分的内容)

3. 基于Spring API (通过xml配置的⽅式, ⾃从SpringBoot ⼴泛使⽤之后, 这种⽅法⼏乎看不到了, ⾃⼰了解下即可)

4. 基于代理来实现(更加久远的⼀种实现⽅式, 写法笨重, 不建议使⽤)

参考: https://cloud.tencent.com/developer/article/2032268

Spring AOP 原理

上⾯我们主要学习了Spring AOP的应⽤, 接下来我们来学习Spring AOP的原理, 也就是Spring 是如何实现AOP的.

Spring AOP 是基于动态代理来实现AOP的, 咱们学习内容主要分以下两部分

1. 代理模式
2. Spring AOP源码剖析

AOP常见的实现方式

1. Spring AOP
2. aspectj

上面我们导入了aspectj的包，其实就是Spring用了aspectj的注解，自己再进行了实现

代理模式

代理模式, 也叫委托模式.

定义：为其他对象提供⼀种代理以控制对这个对象的访问. 它的作⽤就是通过提供⼀个代理类, 让我们在调⽤⽬标⽅法的时候, 不再是直接对⽬标⽅法进⾏调⽤, ⽽是通过代理类间接调⽤.

在某些情况下, ⼀个对象不适合或者不能直接引⽤另⼀个对象, ⽽代理对象可以在客⼾端和⽬标对象之间起到中介的作⽤.

使⽤代理前:

使⽤代理后:

⽣活中的代理

• 艺⼈经纪⼈: ⼴告商找艺⼈拍⼴告, 需要经过经纪⼈,由经纪⼈来和艺⼈进⾏沟通.
• 房屋中介: 房屋进⾏租赁时, 卖⽅会把房屋授权给中介, 由中介来代理看房, 房屋咨询等服务.
• 经销商: ⼚商不直接对外销售产品, 由经销商负责代理销售.
• 秘书/助理: 合作伙伴找⽼板谈合作, 需要先经过秘书/助理预约.

代理模式的主要⻆⾊

1. Subject: 业务接⼝类. 可以是抽象类或者接⼝(不⼀定有)
2. RealSubject: 业务实现类. 具体的业务执⾏, 也就是被代理对象
3. Proxy: 代理类. RealSubject的代理

⽐如房屋租赁

Subject 就是提前定义了房东做的事情, 交给中介代理, 也是中介要做的事情

RealSubject: 房东

Proxy: 中介

UML类图如下:

代理模式可以在不修改被代理对象的基础上, 通过扩展代理类, 进⾏⼀些功能的附加与增强.

根据代理的创建时期, 代理模式分为静态代理和动态代理.

• 静态代理: 由程序员创建代理类或特定⼯具⾃动⽣成源代码再对其编译, 在程序运⾏前代理类的.class ⽂件就已经存在了.
• 动态代理: 在程序运⾏时, 运⽤反射机制动态创建⽽成.

静态代理

静态代理: 在程序运⾏前, 代理类的 .class⽂件就已经存在了. (在出租房⼦之前, 中介已经做好了相关的⼯作, 就等租⼾来租房⼦了)

我们通过代码来加深理解. 以房租租赁为例

1. 定义接⼝(定义房东要做的事情, 也是中介需要做的事情)

public interface HouseSubject {
    void rentHouse();
}

2. 实现接⼝(房东出租房⼦)

public class RealHouseSubject implements HouseSubject{
    @Override
    public void rentHouse() {
        System.out.println("房东出租房子");
    }
}

3. 代理(中介, 帮房东出租房⼦)

public class HouseProxy implements HouseSubject{
    //目标对象/被代理对象
    private HouseSubject houseSubject;

    public HouseProxy(HouseSubject houseSubject) {
        this.houseSubject = houseSubject;
    }

    @Override
    public void rentHouse() {
        System.out.println("开始代理");
        houseSubject.rentHouse();
        System.out.println("结束代理");
    }
}

4. 使⽤

public class Main {
    public static void main(String[] args) {
        //目标对象
        HouseSubject subject=new RealHouseSubject();
        HouseProxy proxy=new HouseProxy(subject);

        proxy.rentHouse();
    }
}

运⾏结果:

上⾯这个代理实现⽅式就是静态代理(仿佛啥也没⼲).

从上述程序可以看出, 虽然静态代理也完成了对⽬标对象的代理, 但是由于代码都写死了, 对⽬标对象的每个⽅法的增强都是⼿动完成的，⾮常不灵活. 所以⽇常开发⼏乎看不到静态代理的场景.

接下来新增需求: 中介⼜新增了其他业务: 代理房屋出售

我们需要对上述代码进⾏修改

1. 接⼝定义修改

public interface HouseSubject {
    void rentHouse();
    void saleHouse();
}

2. 接⼝实现修改

public class RealHouseSubject implements HouseSubject{
    @Override
    public void rentHouse() {
        System.out.println("房东出租房子");
    }

    @Override
    public void saleHouse() {
        System.out.println("房东出售房子");
    }
}

3. 代理类修改

public class HouseProxy implements HouseSubject{
    //目标对象/被代理对象
    private HouseSubject houseSubject;

    public HouseProxy(HouseSubject houseSubject) {
        this.houseSubject = houseSubject;
    }

    @Override
    public void rentHouse() {
        System.out.println("开始代理");
        houseSubject.rentHouse();
        System.out.println("结束代理");
    }

    @Override
    public void saleHouse() {
        System.out.println("开始代理");
        houseSubject.saleHouse();
        System.out.println("结束代理");
    }
}

从上述代码可以看出, 我们修改接⼝(Subject)和业务实现类(RealSubject)时, 还需要修改代理类(Proxy).

同样的, 如果有新增接⼝(Subject)和业务实现类(RealSubject), 也需要对每⼀个业务实现类新增代理类(Proxy).

既然代理的流程是⼀样的, 有没有⼀种办法, 让他们通过⼀个代理类来实现呢?

这就需要⽤到动态代理技术了

动态代理

相⽐于静态代理来说，动态代理更加灵活.

我们不需要针对每个⽬标对象都单独创建⼀个代理对象, ⽽是把这个创建代理对象的⼯作推迟到程序运⾏时由JVM来实现. 也就是说动态代理在程序运⾏时, 根据需要动态创建⽣成.

⽐如房屋中介, 我不需要提前预测都有哪些业务, ⽽是业务来了我再根据情况创建.

我们还是先看代码再来理解.

Java也对动态代理进⾏了实现, 并给我们提供了⼀些API, 常⻅的实现⽅式有两种:

1. JDK动态代理

2. CGLIB动态代理

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

静态代理和动态代理有点像饿汉和懒汉

JDK动态代理

JDK 动态代理类实现步骤

1. 定义⼀个接⼝及其实现类(静态代理中的 HouseSubject 和 RealHouseSubject )

2. ⾃定义 InvocationHandler 并重写 invoke ⽅法，在 invoke ⽅法中我们会调⽤⽬标⽅法(被代理类的⽅法)并⾃定义⼀些处理逻辑

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

JDK只能代理接口，不能代理类，这是API决定的，没法修改

定义JDK动态代理类

实现 InvocationHandler 接⼝

/**
 * JDK动态代理实现
 */
public class JDKInvocation implements InvocationHandler {
    //目标对象
    private Object target;

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

    /**
     * 参数说明
     * proxy：代理对象
     * method：代理对象要实现的方法，即其中需要重写的方法
     * args：method所对应方法的参数
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("开始代理");
        //调用目标对象
        //proxy是代理对象
        Object result=method.invoke(target,args);//底层通过反射实现
        System.out.println("结束代理");
        return result;
    }
}

创建⼀个代理对象并使⽤

public class Main {
    public static void main(String[] args) {
        //目标对象
        HouseSubject subject=new RealHouseSubject();

        //静态代理
        //HouseProxy proxy=new HouseProxy(subject);
        //proxy.rentHouse();
        //proxy.saleHouse();

        //JDK动态代理
        HouseSubject proxy= (HouseSubject) Proxy.newProxyInstance(
                subject.getClass().getClassLoader(),
                new Class[]{HouseSubject.class},
                new JDKInvocation(subject)
        );

        proxy.rentHouse();
        proxy.saleHouse();
    }
}

代码简单讲解

主要是学习API的使⽤, 我们按照Java API的规范来使⽤即可

1. InvocationHandler

InvocationHandler 接⼝是Java动态代理的关键接⼝之⼀, 它定义了⼀个单⼀⽅法 invoke() , ⽤于处理被代理对象的⽅法调⽤.

public interface InvocationHandler {
    /**
     * 参数说明
     * proxy：代理对象
     * method：代理对象需要实现的⽅法，即其中需要重写的⽅法
     * args：method所对应⽅法的参数
     */
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable;
}

通过实现 InvocationHandler 接⼝, 可以对被代理对象的⽅法进⾏功能增强.

2. Proxy

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

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
        throws IllegalArgumentException {
    //...代码省略
}

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

Loader: 类加载器, ⽤于加载代理对象.

interfaces : 被代理类实现的⼀些接⼝(这个参数的定义, 也决定了JDK动态代理只能代理实现了接⼝的⼀些类)

h : 实现了 InvocationHandler 接⼝的对象

CGLIB动态代理

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

有些场景下, 我们的业务代码是直接实现的, 并没有接⼝定义. 为了解决这个问题, 我们可以⽤ CGLIB 动态代理机制来解决.

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

CGLIB 动态代理类实现步骤

1. 定义⼀个类(被代理类)

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

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

接下来看下实现:

添加依赖

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

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>

⾃定义 MethodInterceptor（⽅法拦截器）

实现MethodInterceptor接⼝

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

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

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

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("开始代理...");
        //调用目标对象
        Object result=methodProxy.invoke(target,objects);
        System.out.println("结束代理...");
        return result;
    }
}

创建代理类, 并使⽤

public class Main {
    public static void main(String[] args) {
        //目标对象
        HouseSubject target = new RealHouseSubject();
        //目标对象2
        HouseSubjectClass houseSubjectClass=new HouseSubjectClass();
        
        //CGLib动态代理
        HouseSubject proxy2= (HouseSubject) Enhancer.create(target.getClass(),new CGLibIntercepter(target));
        proxy2.rentHouse();
        proxy2.saleHouse();
        
        //CGLib代理类
        HouseSubjectClass proxy3= (HouseSubjectClass) 		Enhancer.create(houseSubjectClass.getClass(),new CGLibIntercepter(houseSubjectClass));
        proxy3.rentHouse();
    }
}

CGLib既可以代理类也可以代理接口

代码简单讲解

1. MethodInterceptor

MethodInterceptor 和 JDK动态代理中的 InvocationHandler 类似, 它只定义了⼀个⽅法 intercept() , ⽤于增强⽬标⽅法.

和invoke方法类似

public interface MethodInterceptor extends Callback {
    /**
	 * 参数说明:
	 * o: 被代理的对象
	 * method: ⽬标⽅法(被拦截的⽅法, 也就是需要增强的⽅法)
	 * objects: ⽅法⼊参
	 * methodProxy: ⽤于调⽤原始⽅法
	 */
    Object intercept(Object var1, Method var2, Object[] var3, MethodProxy var4) throws Throwable;
}

2. Enhancer.create()

Enhancer.create() ⽤来⽣成⼀个代理对象

public static Object create(Class type, Callback callback) {
    //...代码省略
}

参数说明:

type: 被代理类的类型(类或接⼝)

callback: ⾃定义⽅法拦截器 MethodInterceptor

Spring AOP 源码剖析(了解)

1. SpringAOP是怎么实现的

SpringAOP是基于动态代理实现的

2. 动态代理是怎么实现的？

Spring AOP （动态代理）主要基于两种⽅式实现的: JDK 及 CGLIB 的⽅式

3. Spring使用哪个？

两个都用

4. 什么时候用JDK？什么时候用CGLib？

运⾏时使⽤哪种⽅式与项⽬配置和代理的对象有关

代理类只能使用CGLib，代理接口可以使用JDK也可以使用CGLib

5. JDK和CGLib有什么区别？

看下面

Spring 源码过于复杂, 我们只摘出⼀些主要内容, 以了解为主

Spring对于AOP的实现，基本上都是靠 AnnotationAwareAspectJAutoProxyCreator 去完成⽣成代理对象的逻辑在⽗类 AbstractAutoProxyCreator 中

protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
                                 @Nullable Object[] specificInterceptors, TargetSource targetSource) {

        if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
            AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory)
                    this.beanFactory, beanName, beanClass);
        }
        //创建代理⼯⼚
        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.copyFrom(this);

        /**
         * 检查proxyTargetClass属性值，spring默认为false
         * proxyTargetClass 检查接⼝是否对类代理, ⽽不是对接⼝代理
         * 如果代理对象为类, 设置为true, 使⽤cglib代理
         */
        if (!proxyFactory.isProxyTargetClass()) {
            //是否有设置cglib代理
            if (shouldProxyTargetClass(beanClass, beanName)) {
                //设置proxyTargetClass为true,使⽤cglib代理
                proxyFactory.setProxyTargetClass(true);
            } else {
                /**
                 * 如果beanClass实现了接⼝，且接⼝⾄少有⼀个⾃定义⽅法，则使⽤JDK代理
                 * 否则CGLIB代理(设置ProxyTargetClass为true )
                 * 即使我们配置了proxyTargetClass=false, 经过这⾥的⼀些判断还是可能会将其
                 设为true
                 */
                evaluateProxyInterfaces(beanClass, proxyFactory);
            }
        }

        Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
        proxyFactory.addAdvisors(advisors);
        proxyFactory.setTargetSource(targetSource);
        customizeProxyFactory(proxyFactory);

        proxyFactory.setFrozen(this.freezeProxy);
        if (advisorsPreFiltered()) {
            proxyFactory.setPreFiltered(true);
        }

        // Use original ClassLoader if bean class not locally loaded in overriding 
        class loader
 ClassLoader classLoader =getProxyClassLoader();
        if (classLoader instanceof SmartClassLoader && classLoader !=
                beanClass.getClassLoader()) {
            classLoader = ((SmartClassLoader) classLoader).getOriginalClassLoader();
        }
        //从代理⼯⼚中获取代理
        return proxyFactory.getProxy(classLoader);
    }

代理⼯⼚有⼀个重要的属性: proxyTargetClass, 默认值为 false . 也可以通过程序设置

可以通过 @EnableAspectJAutoProxy(proxyTargetClass = true) 来设置

注意:

Spring Boot 2.X开始, 默认使⽤CGLIB代理

可以通过配置项 spring.aop.proxy-target-class=false 来进⾏修改,设置默认为jdk代理

SpringBoot设置 @EnableAspectJAutoProxy ⽆效, 因为Spring Boot 默认使⽤AopAutoConfiguration进⾏装配

@SpringBootApplication
public class DemoApplication {
 public static void main(String[] args) {
     ApplicationContext context =
             SpringApplication.run(DemoApplication.class, args);
     /**
         * HouseProxy houseProxy = context.getBean(HouseProxy.class);
         * 设置spring.aop.proxy-target-class=true cglib代理, 运⾏成功
         * 设置spring.aop.proxy-target-class=false jdk代理, 运⾏失败, 不能代理类
         * 因为 HouseProxy 是⼀个类, ⽽不是接⼝, 需要修改为
         * HouseSubject houseProxy = (HouseSubject) 
         context.getBean("realHouseSubject")
         *
         */
        HouseProxy houseProxy = context.getBean(HouseProxy.class);
        //HouseSubject houseProxy = (HouseSubject) 
        context.getBean("realHouseSubject");//正确运⾏
        System.out.println(houseProxy.getClass().toString());
    }
}

使⽤context.getBean() 需要添加注解,使HouseProxy,RealHouseSubject被Spring管理

测试AOP代理, 需要把这些类交给AOP管理(⾃定义注解或使⽤@Aspect)

我看点进去看代理⼯⼚的代码

public class ProxyFactory extends ProxyCreatorSupport {
    //...代码省略
    //获取代理
    public Object getProxy(@Nullable ClassLoader classLoader) {
        //分两步 先createAopProxy,后getProxy
        return createAopProxy().getProxy(classLoader);
    }

    protected final synchronized AopProxy createAopProxy() {
        if (!this.active) {
            activate();
        }
        return getAopProxyFactory().createAopProxy(this);
    }
    //...代码省略
        
}

createAopProxy的实现在 DefaultAopProxyFactory 中

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
    //...代码省略
    @Override
    public AopProxy createAopProxy(AdvisedSupport config) throws
            AopConfigException {
        /**
         * 根据proxyTargetClass判断
         * 如果⽬标类是接⼝, 使⽤JDK动态代理
         * 否则使⽤cglib动态代理
         */
        if (!NativeDetector.inNativeImage() &&
                (config.isOptimize() || config.isProxyTargetClass() ||
                        hasNoUserSuppliedProxyInterfaces(config))) {
            Class<?> targetClass = config.getTargetClass();
            if (targetClass == null) {
                throw new AopConfigException("TargetSource cannot determine target class:" +
                "Either an interface or a target is required for proxy creation. ");
            }
            if (targetClass.isInterface() || Proxy.isProxyClass(targetClass) ||
                    ClassUtils.isLambdaClass(targetClass)) {
                return new JdkDynamicAopProxy(config);
            }
            return new ObjenesisCglibAopProxy(config);
        } else {

            return new JdkDynamicAopProxy(config);
        }
    }
    //...代码省略
}

接下来就是创建代理了

JDK动态代理

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
    //...代码省略
    @Override
    public Object getProxy(@Nullable ClassLoader classLoader) {
        if (logger.isTraceEnabled()) {
            logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
        }
        return Proxy.newProxyInstance(determineClassLoader(classLoader), this.proxiedInterfaces, this);
    }
    //...代码省略
}

CGLIB动态代理

class CglibAopProxy implements AopProxy, Serializable {
    //...代码省略
    @Override
    public Object getProxy(@Nullable ClassLoader classLoader) {
        //...代码省略

        // Configure CGLIB Enhancer...
        Enhancer enhancer = createEnhancer();

        // Generate the proxy class and create a proxy instance.
        return createProxyClassAndInstance(enhancer, callbacks);

    }
    //...代码省略
}

总结

1. AOP是⼀种思想, 是对某⼀类事情的集中处理. Spring框架实现了AOP, 称之为SpringAOP

2. Spring AOP常⻅实现⽅式有两种: 1. 基于注解@Aspect来实现 2. 基于⾃定义注解来实现, 还有⼀些更原始的⽅式,⽐如基于代理, 基于xml配置的⽅式, 但⽬标⽐较少⻅

3. Spring AOP 是基于动态代理实现的, 有两种⽅式: 1. 基本JDK动态代理实现 2. 基于CGLIB动态代理实现. 运⾏时使⽤哪种⽅式与项⽬配置和代理的对象有关.