【Spring】Spring AOP原理

【Spring】Spring AOP原理_第1张图片

文章目录

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

前言

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

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

代理模式

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

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

这是使用代理之前:

【Spring】Spring AOP原理_第2张图片

使用代理之后:

【Spring】Spring AOP原理_第3张图片
我们生活中最常见的可以体现代理模式的就是房屋中介了,当我们想要租房子的时候,如果我们想要直接找到房东的话,会很难且麻烦,因为我们不知道哪一间房子正在出租,如果一个一个问的话就需要很多时间,所以这个时候我们的选择往往就是寻找房屋中介,告诉中介的诉求了之后,房屋中介就会根据我们的需求去寻找合适的房主,这样就极大的方便了我们租房的过程。

代理模式中的主要角色:

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

【Spring】Spring AOP原理_第4张图片

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

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

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

静态代理

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

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

定义接口(房东要做的事,也就是中介要做的主要的事):

public interface HouseSubject {
    void rentHouse();
}

实现接口(房东出租房子):

public class RealHouseSubject implements HouseSubject {
    @Override
    public void rentHouse() {
        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("我是中介,结束代理");
    }
}

客户租房子:

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

【Spring】Spring AOP原理_第5张图片
通过这个过程,客户就通过中介成功找到了房东租房子,但是呢?由于这是静态代理,如果我们的房东之前已经和中介商量好了要出租房子,但是这时房东又想出租+出售房子,那么这时候房东就需要和中介再进行沟通,通过我们代码的体现就是这样:

接口:

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

【Spring】Spring AOP原理_第6张图片
由此可以看出,当我们需要修改业务的时候,既需要修改接口,也需要修改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();
}

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

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

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

(❁´◡`❁)实现 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();
    }
}

【Spring】Spring AOP原理_第7张图片
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>cglibgroupId>
	<artifactId>cglibartifactId>
	<version>3.3.0version>
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();
    }
}

【Spring】Spring AOP原理_第8张图片

总结

总结一下:
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的方法进行代理。

你可能感兴趣的:(JavaEE,spring,java,后端)