详解Spring AOP（二）-优快云博客

本文链接：https://blog.youkuaiyun.com/Romised/article/details/139832166

承接上文：详解Spring AOP（一）

1.切点表达式

之前的代码中，我们一直在使用切点表达式来描述切点.下面我们来介绍一下切点表达式的语法.切点表达式常见有两种表达方式：
execution(.....):根据方法的签名来匹配
@annotation(...):根据注解匹配

1.1execution表达式

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

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

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

切点表达式支持通配符表达：
*:匹配任意字符，只匹配一个元素(返回类型，包，类名，方法或者方法参数)
包名使用*表示任意包(一层包使用一个*)
类名使用*表示任意类
返回值使用*表示任意返回值类型
方法名使用*表示任意方法
参数使用*表示一个任意类型的参数
.. :匹配多个连续的任意符号，可以通配任意层级的包，或任意类型，任意个数的参数
使用..配置包名，标识此包以及此包下的所有子包
可以使用..配置参数，任意个任意类型的参数

切点表达式示例：
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.*())

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

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

匹配所有包下面的TestController

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

匹配com.example.demo包下, 子孙包下的所有类的所有方法

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

1.2 @annotation

execution表达式更适用有规则的，如果我们要匹配多个无规则的方法，比如：TestController中的t1()和UserController中的u1()这两个方法.
这个时候我们使用execution这种切点表达式来描述就不是很方便了.
我们可以借助自定义注解的方式以及切点表达式@annotation来描述这一类的切点实现步骤：
1.编写自定义注解
2.使用@annotation表达式来描述切点
3.在连接点的方法上添加自定义注解
准备测试代码：

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



	@RequestMapping("/t2")
	public boolean t2() {
	return true;
	}
}


	
    @RequestMapping("/user")
	    @RestController
	    public class UserController {
	    @RequestMapping("/u1")
	    public String u1(){
	        return "u1";
	    }
	    @RequestMapping("/u2")
	    public String u2(){
	        return "u2";
	    }
	}

1.2.1自定义注解@MyAspect

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

 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被保留的时间长短，标明注解生命周期@Retention的取值有三种：

1.RetentionPolicy.SOURCE:表示注解仅存在于源代码中，编译成字节码后会被丢弃.这意味着在运行时无法获取到该注解的信息，只能在编译时使用.比如@SuppressWarnings,以及lombok提供的注解@Data,@slf4j
2.RetentionPolicy.CLASS:编译时注解.表示注解存在于源代码和字节码中，但在运行时会被丢弃.这意味着在编译时和字节码中可以通过反射获取到该注解的信息，但在实际运行时无法获取.通常用于一些框架和工具的注解.
3.RetentionPolicy.RUNTIME:运行时注解.表示注解存在于源代码，字节码和运行时中.这意味着在编译时，字节码中和实际运行时都可以通过反射获取到该注解的信息.通常用于一些需要在运行时处理的注解，如Spring的@Controller @ResponseBody

1.2.2切面类

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

切面类代码如下:

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

     //后置通知
     @After("@annotation(com.example.demo.aspect.MyAspect)")
     public void after(){
        log.info("MyAspect -> after ...");
     }
 }

1.2.3添加自定义注解

在TestController中的t1()和UserController中的u1()这两个方法上添加自定义注解@MyAspect,其他方法不添加

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

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

运行程序测试接口：

http://127.0.0.1:8080/test/t1

观察日志：

可以看到，切面通知被执行了

继续测试:

http://127.0.0.1:8080/test/t2, 切面通知未执行

http://127.0.0.1:8080/user/u1 , 切面通知执行

2.Sping AOP原理

上面我们主要学习了Spring AOP的应用，接下来我们来学习SpringAOP的原理，也就是Spring是如何实现AOP的.
Spring AOP是基于动态代理来实现AOP的，学习内容主要分以下两部分
1.代理模式
2.Spring AOP源码剖析

2.1代理模式

代理模式，也叫委托模式.
定义：为其他对象提供一种代理以控制对这个对象的访问.它的作用就是通过提供一个代理类，让我们在调用目标方法的时候，不再是直接对目标方法进行调用，而是通过代理类间接调用.
在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用.
使用代理前：

使用代理后:

生活中的代理

艺人经纪人：广告商找艺人拍广告，需要经过经纪人，由经纪人来和艺人进行沟通.
房屋中介：房屋进行租赁时，卖方会把房屋授权给中介，由中介来代理看房，房屋咨询等服务.
秘书/助理：合作伙伴找老板谈合作，需要先经过秘书/助理预约.

代理模式的主要角色：

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

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

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

比如房屋租赁

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

RealSubject: 房东

Proxy: 中介

UML类图如下:

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

根据代理的创建时期，代理模式分为静态代理和动态代理.
静态代理：由程序员创建代理类或特定工具自动生成源代码再对其编译，在程序运行前代理类的.class文件就已经存在了.
动态代理：在程序运行时，运用反射机制动态创建而成.

2.1.1静态代理

静态代理：在程序运行前，代理类的.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 StaticMain {
     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).
既然代理的流程是一样的，有没有一种办法，让他们通过一个代理类来实现呢?这就需要用到动态代理技术了

2.1.2动态代理

相比于静态代理来说，动态代理更加灵活.
我们不需要针对每个目标对象都单独创建一个代理对象，而是把这个创建代理对象的工作推迟到程序运行时由JVM来实现.也就是说动态代理在程序运行时，根据需要动态创建生成.比如房屋中介，我不需要提前预测都有哪些业务，而是业务来了我再根据情况创建.我们先看代码再来理解.
Java也对动态代理进行了实现，并给我们提供了一些API,常见的实现方式有两种：

2.1.3JDK动态代理

JDK动态代理类实现步骤
1.定义一个接口及其实现类(静态代理中的HouseSubject和RealHouseSubject)
2.自定义InvocationHandler并重写invoke方法，在invoke方法中我们会调用目标方法(被代理类的方法)并自定义一些处理逻辑
3.通过Proxy.newProxyInstance(ClassLoader loader,Class<?>[ ] interfaces,InvocationHandlerh)方法创建代理对象

 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; 
     }
  }

创建⼀个代理对象并使用

 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)
         );
        proxy.rentHouse();
     }
 }

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接口的对象

2.1.4CGLIB动态代理

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

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

创建代理类, 并使用

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

1.MethodInterceptor

MethodInterceptor和JDK动态代理中的InvocationHandler类似，它只定义了一个方法intercept(),用于增强目标方法.

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

2. Enhancer.create()

Enhancer.create()用来生成一个代理对象

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

参数说明:

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

callback: ⾃定义⽅法拦截器 MethodInterceptor

3.总结

1.AOP是一种思想，是对某一类事情的集中处理.Spring框架实现了AOP,称之为SpringAOP
2.SpringAOP常见实现方式有两种：1.基于注解@Aspect来实现2.基于自定义注解来实现，还有一些更原始的方式，比如基于代理，基于xml配置的方式，但目标比较少见
3.SpringAOP是基于动态代理实现的，有两种方式：1.基本JDK动态代理实现2.基于CGLIB动态代理实现.运行时使用哪种方式与项目配置和代理的对象有关.