【Spring】Spring AOP原理

太过爱你忘了你带给我的痛 2024-04-20 12:04 70阅读 0赞

![在这里插入图片描述][655e73b9704447f199f7a0402018b8c2.webp_pic_center]

#### 文章目录 ####

*  前言
 *  代理模式
 *   *  静态代理
     *  动态代理
     *   *  JDK动态代理
         *  CGLib 动态代理
 *  总结

## 前言 ##

前面我们学习了关于 Spring AOP 的使用，那么今天这篇文章，我们将深入理解 Spring AOP 的原理，也就是 Spring 是如何实现 AOP 的。

Spring AOP 是基于动态代理来实现 AOP 的，那么什么是代理呢？这里的代理其实是一种模式——代理模式。

## 代理模式 ##

代理模式是一种设计模式，它为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

代理模式的主要作用是扩展目标对象的功能，例如在目标对象的某个方法执行前后可以增加一些自定义的操作。此外，代理模式还可以结合享元模式以减少存储器用量，例如创建一个复杂对象及多个代理者，每个代理者会引用到原本的复杂对象，作用在代理者的运算会转送到原本对象。一旦所有的代理者都不存在时，复杂对象会被移除。

这是使用代理之前：

![在这里插入图片描述][df1044fd4f2546c08540bd507ed72351.png]

使用代理之后：

![在这里插入图片描述][1d90bb3dd47848f79c784470344117d3.png]  
我们生活中最常见的可以体现代理模式的就是房屋中介了，当我们想要租房子的时候，如果我们想要直接找到房东的话，会很难且麻烦，因为我们不知道哪一间房子正在出租，如果一个一个问的话就需要很多时间，所以这个时候我们的选择往往就是寻找房屋中介，告诉中介的诉求了之后，房屋中介就会根据我们的需求去寻找合适的房主，这样就极大的方便了我们租房的过程。

代理模式中的主要角色：

1.  Subject：业务接口类，可以是抽象类或者接口（不一定有）
2.  RealSubject：业务实现类。具体的业务执行，也就是被代理对象，上面的例子中房东就是体现
3.  Proxy：代理类。RealSubject的代理，通过中介体现

![在这里插入图片描述][94c497584c464bceb2d3e54858766027.png]

代理模式可以分为静态代理和动态代理。静态代理中，我们对目标对象的每个方法的增强都是手动完成的，非常不灵活且麻烦。而动态代理则是通过在运行时创建一个子类实例来实现的，可以更加灵活地实现代理。

*  静态代理：有程序员创建代理类或特定工具自动生成源代码再对其进行编译，在程序运行前代理类的 .class 文件就已经存在了。
 *  动态代理：在程序运行时，运用反射机制动态创建而成

在实际开发中，代理模式可以帮助降低主要业务与辅助业务的耦合度，同时提高辅助业务代码的重用度。

### 静态代理 ###

静态代理是指代理类在程序运行前就已经定义好，其与目标类的关系在程序运行前就已经确立。在静态代理中，代理类和目标类都实现相同的接口，代理类通过调用目标类的方法来实现接口中定义的业务逻辑，同时可以在调用前后增加额外的操作。

根据租房子的案例来讲就是：在用户租房子之前 ，我中介和房东就已经协商好了，中介就知道你房东要出租房子还是出售房子，然后当客户有相同的需求的话，我中介就可以直接联系客户和房东进行对接。通过代码展示就是这样的：

定义接口（房东要做的事，也就是中介要做的主要的事）：

public interface HouseSubject {
        
        void rentHouse();
    }

实现接口（房东出租房子）：

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

代理（中介帮房东出租房子）：

客户租房子：

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

![在这里插入图片描述][64f93c6cf4d542478b4b347c9486f7e1.png]  
通过这个过程，客户就通过中介成功找到了房东租房子，但是呢？由于这是静态代理，如果我们的房东之前已经和中介商量好了要出租房子，但是这时房东又想出租+出售房子，那么这时候房东就需要和中介再进行沟通，通过我们代码的体现就是这样：

接口：

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

被代理对象：

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

代理对象：

public class HouseProxy implements HouseSubject {
        
        //将被代理对象声明为成员变量
        private HouseSubject subject;
    
        public HouseProxy(RealHouseSubject realHouseSubject) {
        
            this.subject = realHouseSubject;
        }
    
        @Override
        public void rentHouse() {
        
            System.out.println("我是中介，开始代理");
            subject.rentHouse();
            System.out.println("我是中介，结束代理");
        }
    
        @Override
        public void saleHouse() {
        
            System.out.println("我是中介，开始代理");
            subject.saleHouse();
            System.out.println("我是中介，结束代理");
        }
    }

客户需要买房子：

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

![在这里插入图片描述][8df4bb1280254a9daf7fa81f6e06f409.png]  
由此可以看出，当我们需要修改业务的时候，既需要修改接口，也需要修改RealSubject 类，还需要修改代理类，那么是否有一种方法，可以使用一种代理类来实现变动业务的代理呢？是可以的，这时就需要用到我们的代理类了。

### 动态代理 ###

动态代理是一种在运行时动态生成代理对象的技术，它通过在程序运行时创建代理对象来间接访问原始对象，并在访问前后执行额外的操作。动态代理通常用于在不修改原始对象的情况下增强对象的功能，例如实现横切关注点（cross-cutting concerns）如日志记录、性能监控、事务管理等。

在动态代理中，代理类在程序运行期间创建代理对象，而不是在代码中事先定义好。代理对象中的方法是对目标对象方法的增强方法，可以在方法执行前后插入额外的逻辑。动态代理能够根据需要在运行时动态生成代理对象，因此可以更加灵活地扩展对象的功能。

常见的动态代理有JDK代理和CGLib代理，分别可以针对实现了接口的类代理以及没有实现接口的类代理。

#### JDK动态代理 ####

JDK动态代理实现的关键步骤如下：

1.  定义接口：首先定义一个接口，该接口将由目标对象和代理对象实现。
2.  创建目标对象：创建目标对象的实例，该实例将被代理对象代理。
3.  实现InvocationHandler接口：创建一个实现了java.lang.reflect.InvocationHandler接口的类，该类将定义代理对象的方法4调用逻辑。在该类中，需要重写invoke()方法，以便在目标对象的方法调用前后执行额外的操作。
4.  创建代理对象：使用java.lang.reflect.Proxy类和InvocationHandler对象创建代理对象。具体来说，通过Proxy类的静态方法newProxyInstance()创建一个代理实例，该实例将调用InvocationHandler对象的invoke()方法来处理方法调用。
5.  使用代理对象：使用代理对象来调用目标对象的方法，在方法调用前后会执行额外的逻辑。

(❁´◡\`❁)定义接口

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

(❁´◡\`❁)创建目标对象

(❁´◡\`❁)实现 InvocationHandler 接口

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 Main {
        
        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.saleHouse();
        }
    }

![在这里插入图片描述][d6ffb91a56b54e39b6bd58458b8d01c4.png]  
InvocationHandler 接⼝是Java动态代理的关键接⼝之⼀,它定义了⼀个单⼀⽅法 invoke() ,⽤于处理被代理对象的⽅法调⽤:

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

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

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

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

*  Loder：类加载器，用于加载代理对象
 *  interfaces：被代理类实现的⼀些接⼝(这个参数的定义，也决定了JDK动态代理只能代理实现了接⼝的⼀些类)
 *  h：实现了 InvocationHandler 接口的对象

#### CGLib 动态代理 ####

CGLib是另一个流行的Java动态代理框架，它扩展了Java的反射机制，并提供了更高级的功能。CGLib可以用来创建具有完全功能的代理类，并且能够代理没有接口的类。

CGLib动态代理实现的关键步骤如下：

1.  下载CGLib库：首先需要下载CGLib库，并将其添加到项目的类路径中。
2.  创建目标对象：创建一个目标对象的实例，该实例将被代理对象代理。
3.  创建Enhancer对象：创建一个org.easymock.classextension.Enhancer对象，用于创建代理对象。Enhancer类是CGLib的核心类，用于生成代理类和实例化代理对象。
4.  设置代理类和回调函数：通过调用Enhancer对象的setSuperclass()方法设置代理类的父类为目标类，然后通过setCallback()方法设置回调函数。回调函数是一个实现了目标类方法的拦截器对象，用于拦截目标方法调用并执行额外的逻辑。
5.  创建代理对象：通过调用Enhancer对象的create()方法创建代理对象。
6.  使用代理对象：使用代理对象来调用目标对象的方法，在方法调用前后会执行额外的逻辑。

与JDK动态代理相比，CGLib提供了更多的灵活性和功能。它支持代理没有接口的类，并且能够动态地修改和扩展类的行为。CGLib还支持方法级别的拦截和过滤，可以更加精细地控制目标方法的调用。因此，CGLib在许多场景中得到了广泛应用，例如AOP编程、测试框架、远程调用等。

(❁´◡\`❁)添加依赖

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

(❁´◡\`❁)⾃定义MethodInterceptor（⽅法拦截器，并且实现MethodInterceptor接⼝）

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[] objects, MethodProxy methodProxy) throws Throwable {
        
            System.out.println("我是中介，开始代理...");
            Object retVal = methodProxy.invoke(target,objects);
            System.out.println("我是中介，结束代理...");
            return retVal;
        }
    }

(❁´◡\`❁)创建类并使用

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

![在这里插入图片描述][71e4ae0573df422285cfc2a71960c83c.png]

## 总结 ##

总结一下：  
1. Spring AOP 是如何实现的？

*  Spring AOP（Aspect-Oriented Programming）通过动态代理实现了面向切面编程。具体来说，Spring在创建某个bean的时候，实际上创建的是这个bean的一个代理对象。后续对bean中方法的调用，实际上调用的是代理类重写的代理方法。

2. 动态代理是如何实现的？

*  参考上文

3. Spring使用的是 JDK 动态代理和 CGLib 代理中的哪一个？

*  两个都用了

4. 什么时候使用 JDK 代理，什么时候使用 CGLib 代理？

*  在Spring中，JDK动态代理和CGLib动态代理的选择取决于目标对象的类型。
 *  1.  当目标对象实现了接口时，Spring会使用JDK动态代理。这是因为JDK动态代理通过实现java.lang.reflect.InvocationHandler接口来创建代理对象，并且使用目标对象的接口来定义代理对象的行为。这种情况下，Spring会在运行时动态地创建一个实现了目标对象接口的代理类，该代理类将拦截对目标对象的调用并执行额外的逻辑。
 *  1.  当目标对象没有实现接口时，Spring会使用CGLib动态代理。CGLib是一个代码生成库，可以在运行时动态地创建一个目标对象的子类，并重写目标类的方法以实现额外的逻辑。这种情况下，Spring会在运行时动态地创建一个目标对象的子类，该子类将拦截对目标对象的调用并执行额外的逻辑。

5. JDK 代理和 CGLib 代理有什么区别?

1.  实现方式：JDK代理是基于接口实现的，因此必须先定义接口；而CGLib代理则直接基于被代理类实现，不需要定义接口。
2.  代理机制：JDK动态代理机制是委托机制，通过委托handler调用原始实现类方法；而CGLib则使用继承机制，被代理类和代理类是继承关系，因此代理类对象可以赋值给被代理类类型的变量。
3.  对final方法的处理：由于CGLib的原理是动态生成被代理类的子类，因此无法对声明为final的方法进行代理。

[655e73b9704447f199f7a0402018b8c2.webp_pic_center]: https://img-blog.csdnimg.cn/direct/655e73b9704447f199f7a0402018b8c2.webp#pic_center
[df1044fd4f2546c08540bd507ed72351.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/38adeb3d0c0f4875be6b7a751d0eaa51.png
[1d90bb3dd47848f79c784470344117d3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/80a1c8712338438295f1a9129037d948.png
[94c497584c464bceb2d3e54858766027.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/8eb94227de5a42db9e28cba9dfbd7089.png
[64f93c6cf4d542478b4b347c9486f7e1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/61f11683e7df429296e44dd18101663d.png
[8df4bb1280254a9daf7fa81f6e06f409.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/6b9fcf18dbdc446488b9fa30f16a0680.png
[d6ffb91a56b54e39b6bd58458b8d01c4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/17616a6b782644e9adc4e6f978685579.png
[71e4ae0573df422285cfc2a71960c83c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/e0a18a63eceb46d480d555ce2c99a992.png