Spring AOP

什么是AOP?

Spring框架有两大核心,第一是IoC第二就是AOP
AOP又称为Aspect Oriented Programming（面向切面编程)

从概念上讲，AOP 是将那些与业务逻辑无关，但又遍布在应用程序多个模块中的功能（例如日志记录、性能监控、事务管理、安全检查等）抽取出来，形成独立的切面（Aspect）

例如"登录校验"就是⼀类特定问题. 登录校验拦截器, 就是对"登录校验"这类问题的统⼀处理. 所以, 拦截器也是AOP的⼀种应⽤. AOP是⼀种思想, 拦截器是AOP思想的⼀种实现. Spring框架实现了这种思想, 提供了拦截器技术的相关接口

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

什么是Spring AOP?
AOP是一种思想,而SpringAOP就是实现它的一种实现方式;

Spring AOP入门

引入AOP依赖
再pom.xml中添加配置文件

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

为了能更好的理解AOP的开发,我们通过一个案例
统计各个接口方法的执行时间.

记录Controller中每个方法的执行时间

package com.example.book.aspect;

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

@Slf4j
@Aspect
@Component
public class TimeAspect {
    @Around("execution(* com.example.book.demos.web.controller.*.*(..))")
    public Object  timeCost(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        log.info("方法执行前");
        Object result = joinPoint.proceed();
        long  end = System.currentTimeMillis();
        log.info("方法执行后");
        log.info(joinPoint+"消耗时间"+(end-start)+"ms");
        return result;
    }
}

查看日志

对于上述的简单描述

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

方法执行之前逻辑

原始方法执行

方法执行后逻辑

这就是一个AOP入门的程序完成了业务接口执行耗时的统计.
我们通过这可以感受道AOP的面向切片的一些优势:

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

Spring AOP 详解

Spring AOP中涉及的核心概念

切点(Pointcut)
Pointcut的作用就是提供一组规则使用,告诉程序对
哪些⽅法来进⾏功能增强

这一个表达式就是切点表达式

连接点(Join Point)

满足切点表达式规则的方法,就是连接点,也就是可以被AOP控制的方法
例如

* com.example.book.demos.web.controller.*.*(..))"

路径下的⽅法, 都是连接点
上述BookController 中的⽅法都是连接点

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

通知(Advice)

通知就是具体要做的工作,指哪些重复逻辑,具体实现为一个方法,比如上面的记录业务时间的耗时方法,这就是通知

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

切面(Aspect)

切面(Aspect) = 切点(Pointcut) + 通知(Advice)
通过切面就能描述当前AOP程序需要针对哪些方法,在什么时候执行什么操作

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

一般切面所在的类,我们称为切面类(@Aspect注解标识的类)

通知类型

@Around就是其中一种通知类型,表示环绕通知
Spring中AOP的通知类型有以下几种

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

接下来我们写的一个小项目看看他们的区别

AspectDemo类

package com.example.demo1.demos.web.controller;

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 AspectDemo {
    //前置通知
    @Before("execution(* com.example.demo1.demos.web.controller.TestController*.*(..))")
    public void doBefore(){
        log.info("执⾏ Before ⽅法");
    }
    //后置通知
    @After("execution(* com.example.demo1.demos.web.controller.TestController*.*(..))")
    public void doAfter(){
        log.info("执⾏ After ⽅法");
    }
    //返回后通知
    @AfterReturning("execution(* com.example.demo1.demos.web.controller.TestController*.*(..))")
    public void AfterReturning(){
        log.info("执⾏ AfterReturning ⽅法");
    }
    //抛出异常后通知
    @AfterThrowing("execution(* com.example.demo1.demos.web.controller.TestController*.*(..))")
    public void doAfterThrowing(){
        log.info("执⾏ AfterThrowing ⽅法");
    }
    //添加环绕通知
    @Around("execution(* com.example.demo1.demos.web.controller.TestController*.*(..))")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("执⾏ Around ⽅法开始");
        Object result = joinPoint.proceed();
        log.info("执⾏ Around ⽅法结束");
        return result;
    }
}

控制类

package com.example.demo1.demos.web.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/test")
public class TestController {
    @RequestMapping("/t1")
    public String t1(){
        return "t1";
    }
   @RequestMapping("/t2")
    public boolean t2(){
        int a   = 10/0;
        return true;
    }
}

我们发出请求
http://localhost:8080/test/t1

我们观察日志可以发现
如果程序正常运行
@AfterThrowing不会执行
执⾏ Around ⽅法开始
执⾏ Before ⽅法
执⾏ AfterReturning ⽅法
执⾏ After ⽅法
执⾏ Around ⽅法结束

如果程序发送异常
http://localhost:8080/test/t2

我们可以看到顺序为
执⾏ Around ⽅法开始
执⾏ Before ⽅法
执⾏ AfterThrowing ⽅法
执⾏ After ⽅法

注意事项:

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

@PointCut

上面的代码重复着大量的切点表达式

“execution(*
com.example.demo1.demos.web.controller.TestController*.*(…))”

Spring提供了@PointCut注解,需要引用时把公共表达式提取出来,需要时引用切入点表达式即可

上述代码就可以修改为:

package com.example.demo1.demos.web.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 AspectDemo {
    @Pointcut("execution(* com.example.demo1.demos.web.controller.TestController*.*(..))")
    private void pt(){}
    //前置通知
    @Before("pt()")
    public void doBefore(){
        log.info("执⾏ Before ⽅法");
    }
    //后置通知
    @After("pt()")
    public void doAfter(){
        log.info("执⾏ After ⽅法");
    }
    //返回后通知
    @AfterReturning("pt()")
    public void AfterReturning(){
        log.info("执⾏ AfterReturning ⽅法");
    }
    //抛出异常后通知
    @AfterThrowing("pt()")
    public void doAfterThrowing(){
        log.info("执⾏ AfterThrowing ⽅法");
    }
    //添加环绕通知
    @Around("pt()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("执⾏ Around ⽅法开始");
        Object result = joinPoint.proceed();
        log.info("执⾏ Around ⽅法结束");
        return result;
    }
}

注意:

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

我们定义另一个切面类

package com.example.demo1.demos.web.aspect;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Slf4j
@Component
@Aspect
public class AspectDemo2 {
    @Before("com.example.demo1.demos.web.aspect.AspectDemo.pt()")
    public void doBfore(){
        log.info("执⾏ AspectDemo2 -> Before ⽅法");
    }
}

优先级 @Order

在一个项目中定义了多个切面时,切面类多个切⼊点都匹配到了同⼀个⽬标⽅法,这些切面类可以由优先级@Order决定

我们定义多个切面类
AspectDemo2,AspectDemo3,AspectDemo4
访问端口
http://localhost:8080/test/t1

可以看到Before方法执行在前
After方法执行在后

但这种⽅式不⽅便管理, 我们的类名更多还是具备⼀定含义的.
Spring 给我们提供了⼀个新的注解, 来控制这些切⾯通知的执⾏顺序: @Order
使⽤⽅式如下

@Aspect
@Component
@Order(2)
public class AspectDemo2 {
 //...代码省略
}
@Aspect
@Component
@Order(1)
public class AspectDemo3 {
 //...代码省略
}
@Aspect
@Component
@Order(3)
public class AspectDemo4 {
 //...代码省略
}

通过上述程序的运⾏结果, 得出结论:
@Order 注解标识的切⾯类, 执⾏顺序如下:
• @Before 通知：数字越⼩先执⾏
• @After 通知：数字越⼤先执⾏

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

切点表达式

execution表达式

execution(* com.example.demo1.demos.web.controller.*.*(..))

*:返回类型
com.example.demo1.demos.web.controller:包名.类名.方法.(方法参数)

 * ：匹配任意字符，只匹配⼀个元素(返回类型, 包, 类名, ⽅法或者⽅法参数)
a. 包名使⽤ * 表⽰任意包(⼀层包使⽤⼀个*)
b. 类名使⽤ * 表⽰任意类
c. 返回值使⽤ * 表⽰任意返回值类型
d. ⽅法名使⽤ * 表⽰任意⽅法
e. 参数使⽤ * 表⽰⼀个任意类型的参数
.. ：匹配多个连续的任意符号, 可以通配任意层级的包, 或任意类型, 任意个数的参数
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..*(..))

@annotation

execution表达式更适⽤有规则的, 如果我们要匹配多个⽆规则的⽅法呢, ⽐如：TestController中的t1()和UserController中的u1()这两个⽅法
这个时候我们使用execution就不合适了
我们可以借助⾃定义注解的⽅式以及另⼀种切点表达式 @annotation 来描述这⼀类的切点

1. 编写自定义注解
   创建⼀个注解类(和创建Class⽂件⼀样的流程, 选择Annotation就可以了)
   

package com.example.demo1.demos.web;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAspect {
    
}

@Target 标识了 Annotation 所修饰的对象范围, 即该注解可以⽤在什么地⽅
常⽤取值:
ElementType.TYPE: ⽤于描述类、接⼝(包括注解类型) 或enum声明
ElementType.METHOD: 描述⽅法
ElementType.PARAMETER: 描述参数
ElementType.TYPE_USE: 可以标注任意类型

@Retention指Annotation被保留的时间⻓短, 标明注解的⽣命周期
RetentionPolicy.SOURCE：
表⽰注解仅存在于源代码中, 编译成字节码后会被丢弃. 这意味着
在运⾏时⽆法获取到该注解的信息, 只能在编译时使⽤. ⽐如 @SuppressWarnings , 以及
lombok提供的注解 @Data , @Slf4j
RetentionPolicy.CLASS:
编译时注解. 表⽰注解存在于源代码和字节码中, 但在运⾏时会被丢
弃. 这意味着在编译时和字节码中可以通过反射获取到该注解的信息, 但在实际运⾏时⽆法获
取. 通常⽤于⼀些框架和⼯具的注解
RetentionPolicy.RUNTIME：
运⾏时注解. 表⽰注解存在于源代码, 字节码和运⾏时中. 这意味
着在编译时, 字节码中和实际运⾏时都可以通过反射获取到该注解的信息. 通常⽤于⼀些需要
在运⾏时处理的注解, 如Spring的 @Controller @ResponseBody

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

package com.example.demo1.demos.web.aspect;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Slf4j
@Component
@Aspect
public class MyAspectDemo {
    //前置通知
    @Before("@annotation(com.example.demo1.demos.web.MyAspect)")
    public void before(){
        log.info("MyAspect -> before ...");
    }
    @After("@annotation(com.example.demo1.demos.web.MyAspect)")
    public void after(){
        log.info("MyAspect -> after ...");
    }

}

3. 在连接点的⽅法上添加⾃定义注解
   在TestController中的t1()和UserController中的u1()这两个⽅法上添加⾃定义注解 @MyAspect , 其
   他⽅法不添加

 @MyAspect
    @RequestMapping("/u1")
    public String u1(){
        return "u1";
    }
     @MyAspect
    @RequestMapping("/t1")
    public String t1(){
        return "t1";
    }
  

Spring AOP 原理

Spring AOP 是基于动态代理来实现AOP的

代理模式

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

例如:
经纪人
房屋中介

代理模式的主要角色

Subject:业务接口类,可以是抽象类或者接口
RealSubject:业务实现类,具体的业务执⾏, 也就是被代理对象
Proxy:代理类,RealSubject的代理

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

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

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

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

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

静态代理

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

定义接口(房东和中介要做的事)

package com.example.demo1.demos.web.proxy;

public interface HouseSubject {
    //租房子
    void rentHouse();
}

实现接口

package com.example.demo1.demos.web.proxy;

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

代理

package com.example.demo1.demos.web.proxy;

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

运行结果

package com.example.demo1.demos.web.proxy;

public class StaticMain {
    public static void main(String[] args) {
        HouseSubject subject = new RealHouseSubject();
        //创建代理类
        HouseProxy houseProxy = new HouseProxy(subject);
        //通过代理类访问⽬标⽅法
        houseProxy.rentHouse();
    }
}

这就是静态代理

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

对于上述代码我们又增加了新的业务:
例如代理房屋出售
就需要对代码进行修改

接⼝定义修改

package com.example.demo1.demos.web.proxy;

public interface HouseSubject {
    //租房子
    void rentHouse();
    void saleHouse();
}

接⼝实现修改

package com.example.demo1.demos.web.proxy;

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

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

代理类修改

package com.example.demo1.demos.web.proxy;

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动态代理

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

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

3. 通过

 Proxy.newProxyInstance(ClassLoader loader,Class<?>[] 
interfaces,InvocationHandler h)

⽅法创建代理对象

实现 InvocationHandler 接⼝

package com.example.demo1.demos.web.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;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 代理增强内容
        System.out.println("我是中介, 开始代理");
        //通过反射调⽤被代理类的⽅法
        Object retVal = method.invoke(target,args);
        //代理增强内容
        System.out.println("我是中介, 代理结束");
        return retVal;
    }
}

创建⼀个代理对象并使⽤

package com.example.demo1.demos.web.proxy;

import org.aspectj.lang.annotation.Pointcut;

import java.lang.reflect.Proxy;

public class DynamicMain {
    public static void main(String[] args) {
        HouseSubject target = new RealHouseSubject();
        //创建⼀个代理类：通过被代理类、被代理实现的接⼝、⽅法调⽤处理器来创建
        HouseSubject proxy = (HouseSubject) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                new Class[]{HouseSubject.class},
                new JDKInvocationHandler(target)
        );
    }
}

InvocationHandler接口

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

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

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

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

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

这个⽅法⼀共有 3 个参数：
Loader: 类加载器, ⽤于加载代理对象
interfaces : 被代理类实现的⼀些接⼝(这个参数的定义, 也决定了JDK动态代理只能代理实现了接⼝的⼀些类)
h : 实现了 InvocationHandler 接⼝的对象

CGLIB动态代理

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

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接⼝

package com.example.demo1.demos.web.proxy;

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.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[] objects, MethodProxy methodProxy) throws Throwable {
        // 代理增强内容
        System.out.println("我是中介, 开始代理");
        //通过反射调⽤被代理类的⽅法
        Object retVal = methodProxy.invoke(target, objects);
        //代理增强内容
        System.out.println("我是中介, 代理结束");
        return retVal;
    }
}

package com.example.demo1.demos.web.proxy;

import net.sf.cglib.proxy.Enhancer;

public class DynamicMain2 {
    public static void main(String[] args) {
        HouseSubject target= new RealHouseSubject();
        HouseSubject proxy= (HouseSubject)
                Enhancer.create(target.getClass(),new CGLIBInterceptor(target));
        proxy.rentHouse();
        proxy.saleHouse();
    }
}

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

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

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