Spring AOP

一. AOP概述

AOP是Spring框架的第⼆⼤核⼼(第⼀⼤核⼼是 IoC)

1.1 什么是AOP？

AOP：AspectOrientedProgramming（面向切面编程）

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

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

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

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

1.2 什么是SpringAOP?

AOP的实现方法有很多种，主流的有AspectJ，CGLIB，Spring AOP

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

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

实例：

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

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

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

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

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

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

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

二，Spring AOP应用

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

2.1 引入AOP依赖

在pom.xml⽂件中添加配置

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

2.2 编写AOP程序

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

@Slf4j
@Aspect
@Component
public class TimeAspect {

@Around("execution(* com.luoyaoyun.bookdemo.controller.*.*(..))")
public Object recordTime(ProceedingJoinPoint joinPoint) throws Throwable {
long start = System.currentTimeMillis();

//执行业务逻辑代码
Object proceed = joinPoint.proceed();

long end = System.currentTimeMillis();

log.info(joinPoint.getSignature() + "方法耗时:{}ms",end-start);
return proceed;
}

}

1. @Aspect:标识这是⼀个切⾯类

2. @Around: 环绕通知,在⽬标⽅法的前后都会被执⾏.后⾯的表达式表⽰对哪些⽅法进⾏增强.

3. ProceedingJoinPoint.proceed() 让原始⽅法执⾏

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

• 代码⽆侵⼊:不修改原始的业务⽅法,就可以对原始的业务⽅法进⾏了功能的增强或者是功能的改变

• 减少了重复代码

• 提⾼开发效率

• 维护⽅便

三，Spring AOP详解

3.1 SpringAOP核心概念

3.1.1 切点(Pointcut)

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

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

表达式 execution(* com.example.demo.controller.*.*(..)) 就是切点表达式.

3.1.2 连接点(JoinPoint)

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

切点和连接点的关系：

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

⽐如:

切点表达式:全体教师

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

3.1.3 通知(Advice)

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

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

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

3.1.4 切面(Aspect)

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

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

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

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

3.2 通知类型

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

• @Around:环绕通知,此注解标注的通知⽅法在⽬标⽅法前,后都被执⾏

• @Before:前置通知,此注解标注的通知⽅法在⽬标⽅法前被执⾏

• @After:后置通知,此注解标注的通知⽅法在⽬标⽅法后被执⾏,⽆论是否有异常都会执⾏

• @AfterReturning: 返回后通知,此注解标注的通知⽅法在⽬标⽅法后被执⾏,有异常不会执⾏

• @AfterThrowing:异常后通知,此注解标注的通知⽅法发⽣异常后执⾏

@Slf4j
@Aspect
@Component
public class AspectDemo1 {

@Before("execution(* com.luoyaoyun.springaopdemo.controller.*.*(..))")
public void doBefore(){
log.info("执行doBefore…");
}

@After("execution(* com.luoyaoyun.springaopdemo.controller.*.*(..))")
public void doAfter(){
log.info("执行doAfter…");
}

@AfterReturning("execution(* com.luoyaoyun.springaopdemo.controller.*.*(..))")
public void doAfterReturning(){
log.info("执行doAfterReturning…");
}

@AfterThrowing("execution(* com.luoyaoyun.springaopdemo.controller.*.*(..))")
public void doAfterThrowing(){
log.info("执行doAfterThrowing…");
}

@Around("execution(* com.luoyaoyun.springaopdemo.controller.*.*(..))")
public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
log.info("Around⽅法开始执⾏ ");
Object result = joinPoint.proceed();
log.info("Around⽅法结束执⾏ ");
return result;
}

}

@Slf4j
@RequestMapping("/test")
@RestController
public class TestController {
@RequestMapping("/t1")
public String t1(){
log.info("执行t1方法");
return "t1";
}

// @TimeRecord
@RequestMapping("/t2")
public Integer t2(){
log.info("执行t2方法");
return 10/0;
}

@RequestMapping("/t3")
public boolean t3(){
log.info("执行t3方法");
return true;
}
}

1）正常运行的情况

2）异常运行的情况

程序发⽣异常的情况下：

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

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

注意事项:

1）@A round 环绕通知需要调⽤ ProceedingJoinPoint.proceed() 来让原始⽅法执⾏,其他通知不需要考虑⽬标⽅法执⾏.

2）@Around 环绕通知⽅法的返回值,必须指定为Object,来接收原始⽅法的返回值,否则原始⽅法执 ⾏完毕,是获取不到返回值的.

3）⼀个切⾯类可以有多个切点

3.3 @PointCut

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

@Slf4j
@Aspect
@Component
public class AspectDemo1 {

@Pointcut("execution(* com.luoyaoyun.springaopdemo.controller.*.*(..))")
private void pt(){}

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

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

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

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

@Around("pt()")
public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
log.info("Around⽅法开始执⾏ ");
Object result = joinPoint.proceed();
log.info("Around⽅法结束执⾏ ");
return result;
}
}

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

3.4 切面优先级@Order

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

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

定义多个切⾯类:

@Aspect
@Slf4j
@Component
public class AspectDemo2 {

@Pointcut("execution(* com.luoyaoyun.springaopdemo.controller.*.*(..))")
public void pt(){}

@Before("pt()")
public void doBefore(){
log.info("执行AspectDemo2 -> Before方法");
}

@After("pt()")
public void doAfter(){
log.info(" 执⾏ AspectDemo2 -> After⽅法 ");
}

// @Before("com.luoyaoyun.springaopdemo.aspect.AspectDemo1.pt()")
// public void doBefore(){
// log.info("执行AspectDemo2的deBefore方法");
// }

}

@Aspect
@Slf4j
@Component
public class AspectDemo3 {

@Pointcut("execution(* com.luoyaoyun.springaopdemo.controller.*.*(..))")
public void pt(){}

@Before("pt()")
public void doBefore(){
log.info("执行AspectDemo3 -> Before方法");
}

@After("pt()")
public void doAfter(){
log.info(" 执⾏ AspectDemo3 -> After⽅法 ");
}
}

@Aspect
@Slf4j
@Component
public class AspectDemo4 {

@Pointcut("execution(* com.luoyaoyun.springaopdemo.controller.*.*(..))")
public void pt(){}

@Before("pt()")
public void doBefore(){
log.info("执行AspectDemo4 -> Before方法");
}

@After("pt()")
public void doAfter(){
log.info(" 执⾏ AspectDemo4 -> After⽅法 ");
}
}

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

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

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

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

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

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

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

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

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

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

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

注意：@Order中的数字并不要求连续

3.5 切点表达式

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

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

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

3.5.1 execution表达式

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

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

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

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

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

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

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

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

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

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

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

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

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

切点表达式示例

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..*(..))

3.5.2 @annotation

execution表达式更适⽤有规则的,如果我们要匹配多个⽆规则的⽅法呢,

⽐如：TestController中的t1() 和UserController中的u1()这两个⽅法.

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

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

实现步骤：

        1. 编写⾃定义注解

        2. 使⽤ @annotation 表达式来描述切点

3.5.2.1 自定义注解 @MyAspect

创建一个注解类

@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

3.5.2.2 切面类

使用@annotation 切点表达式定义切点,只对@MyAspect生效

@Aspect
@Component
@Slf4j
public class MyAspectDemo {
@Before("@annotation(com.luoyaoyun.springaopdemo.aspect.MyAspect)")
public void before(){
log.info("MyAspect -> before …");
}

@After("@annotation(com.luoyaoyun.springaopdemo.aspect.MyAspect)")
public void after(){
log.info("MyAspect -> after …");
}
}

3.5.2.3 添加自定义注解

在TestController中的t1()和UserController中的u1()这两个⽅法上添加⾃定义注解@MyAspect，其

他⽅法不添加

Spring AOP的实现⽅式：

1. 基于注解 @Aspect

2. 基于⾃定义注解

3. 基于SpringAPI(通过xml配置的⽅式）

4. 基于代理来实现

四，Spring AOP原理

4.1 代理模式

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

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

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

代理模式的主要角色

1. Subject: 业务接⼝类.可以是抽象类或者接⼝(不⼀定有)

2. RealSubject: 业务实现类. 具体的业务执⾏,也就是被代理对象.

3. Proxy: 代理类.RealSubject的代理.

⽐如房屋租赁

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

         RealSubject: 房东

        Proxy: 中介

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

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

• 动态代理:在程序运⾏时,运⽤反射机制动态创建⽽成

4.1.1 静态代理

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

示例：租房子

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("我是中介, 结束代理");
}

}

4. 使用

public class Main {
public static void main(String[] args) {
HouseProxy houseProxy = new HouseProxy(new RealHouseSubject());
houseProxy.rentHouse();
}
}

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

我们修改接⼝(Subject)和业务实现类(RealSubject)时,还需要修改代理类 (Proxy).

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

4.1.2 动态代理

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

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

Java也对动态代理进⾏了实现,并给我们提供了⼀些API

常⻅的实现⽅式有两种: 1. JDK动态代理 2. CGLIB动态代理

JDK动态代理

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

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

3. 通过 Proxy.newProxyInstance(ClassLoader loader,Class[] interfaces,InvocationHandler h)

⽅法创建代理对象

定义JDK动态代理类

实现 InvocationHandler 接⼝

public class JDKInvocationHandler implements InvocationHandler {
//目标对象
private Object target;

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

/**
* proxy: 代理对象
* method: 目标方法
* args: 参数
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("我是JDK动态代理中介, 开始代理");
Object result = method.invoke(target, args);
System.out.println("我是JDK动态代理中介, 结束代理");
return result;
}

}

创建一个代理对象并使用

public class DynamicMain {
public static void main(String[] args) {
//被代理的对象/目标对象
HouseSubject target = new RealHouseSubject();

//动态创建一个代理类
HouseSubject houseProxy = (HouseSubject)Proxy.newProxyInstance(target.getClass().getClassLoader(),
new Class[]{HouseSubject.class}, new JDKInvocationHandler(target));

houseProxy.rentHouse();
}
}

1）InvocationHandler

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

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

2）Proxy

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

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

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

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

h:实现了InvocationHandler接⼝的对象

CGLIB动态代理

JDK动态代理有⼀个最致命的问题是其只能代理实现了接⼝的类. 有些场景下,我们的业务代码是直接实现的,并没有接⼝定义

.为了解决这个问题,我们可以⽤CGLIB动 态代理机制来解决.

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

CGLIB动态代理类实现步骤

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

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

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

使用cglib有两种方式，一种是添加依赖，另一种是使用spring中自带的

1）添加依赖

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

2）spring中的

1）⾃定义MethodInterceptor（⽅法拦截器）

public class CglibInteceptor implements MethodInterceptor {

//目标对象
private Object target;

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

@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
//代理增强
System.out.println("我是CGlib代理, 开始代理");
//通过反射调用被代理对象的方法
Object result = method.invoke(target, args);
System.out.println("我是CGlib代理, 结束代理");
return result;
}

}

2）创建代理类,并使用

public class DynamicMain {
public static void main(String[] args) {
//被代理的对象/目标对象
HouseSubject target = new RealHouseSubject();

//JDK动态创建一个代理类
// HouseSubject houseProxy = (HouseSubject) Proxy.newProxyInstance(target.getClass().getClassLoader(),
// new Class[]{HouseSubject.class}, new JDKInvocationHandler(target));
// houseProxy.rentHouse();
// houseProxy.saleHouse();

//CGLIB 动态创建一个代理类
HouseSubject houseSubject = (HouseSubject) Enhancer.create(target.getClass(), new CglibInteceptor(target));
houseSubject.rentHouse();
}
}

Java 9引⼊模块化系统（JPMS）,默认情况下核⼼模块（如java.base）的包是封闭的，不允许外部代码通过反射访问

使⽤CGlib的话,需要添加JVM启动参数

–add-opens java.base/java.lang=ALL-UNNAMED