Java-动态代理

不会叫的狼

已于 2023-03-17 11:41:27 修改

阅读量336

点赞数

分类专栏： Java Knowledge-Points 设计模式文章标签： java

于 2021-08-30 00:35:51 首次发布

本文链接：https://blog.csdn.net/weixin_40017062/article/details/119988447

版权

Java Knowledge-Points 同时被 2 个专栏收录

81 篇文章 1 订阅

订阅专栏

设计模式

8 篇文章 0 订阅

订阅专栏

本文详细介绍了Java设计模式中的代理模式，包括静态代理和动态代理。静态代理通过实现相同接口的方式，代理类在运行前已编译完成。动态代理则在运行时创建代理对象，如JDK动态代理利用反射生成代理类，CGLIB通过字节码动态生成子类。动态代理提供了对方法的统一处理和功能增强，常用于AOP场景。在Spring中，根据目标对象是否实现接口选择使用JDK或CGLIB实现动态代理。

摘要由CSDN通过智能技术生成

概述

Java常用的设计模式–代理模式，而对于代理，又可以分为静态代理和动态代理。代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。

代理类与委托类之间通常会存在关联关系，我们在访问实际对象时，是通过代理对象来访问的。代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。代理类提供附加功能。

静态代理

代理类与委托类实现共同的接口。委托类传参代理类构造方法，代理类调用委托类的相关方法，并提供附加功能。

接口Animal ：
public interface Animal {
    public void eat();
    public void run();
}

委托类 Dog：
public class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("Dog eat");
    }

    @Override
    public void run() {
        System.out.println("Dog run");
    }
}

代理类 MyStaticProxy ：
public class MyStaticProxy implements Animal{
    Animal animal;

    public MyStaticProxy(Animal obj){
        animal= obj;
    }

    @Override
    public void eat() {
        System.out.println("+++MyStaticProxy start+++");
        animal.eat();
        System.out.println("+++MyStaticProxy end+++");
    }

    @Override
    public void run() {
        System.out.println("+++MyStaticProxy start+++");
        animal.run();
        System.out.println("+++MyStaticProxy end+++");
    }
}

调用：
public class StaticProxyDemo{
    public static void main( String[] args ) {
        Animal animal = new Dog();
        animal.eat();

        //MyStaticProxy myStaticProxy = new MyStaticProxy(new Dog());
        Animal myStaticProxy = new MyStaticProxy(new Dog());
        myStaticProxy.eat();
    }
}

输出：
Dog eat
+++MyStaticProxy start+++
Dog eat
+++MyStaticProxy end+++

通过调用委托类 Dog 对象的相关方法（eat、run），来提供特定的服务，代理类 MyStaticProxy 提供附加功能。

动态代理

动态代理是反射的一个非常重要的应用场景。动态代理常被用于一些 Java 框架中。例如 Spring 的 AOP，就是基于 Java 动态代理实现的。

代理类在程序运行时创建的代理方式被称为动态代理。相比于静态代理，MyStaticProxy 在程序运行之前就已经编译完成。而动态代理，在程序执行过程中，创建代理对象，通过代理对象执行方法，给目标类的方法增加额外的功能，也叫做功能增强。

静态代理需要重写接口的所有方法，而动态代理则不需要。

动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。

动态代理分类：

JDK动态代理：利用反射机制，动态生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。JDK动态代理只能对实现了接口的类生成代理，而不能针对类。
CGLIB动态代理：利用asm开源包，将代理对象类的 class 文件加载进来，通过修改其字节码动态生成子类来处理。CGLIB 是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法，这种通过继承类的实现方式，不能代理final修饰的类。

动态代理一般分为三个步骤：

创建方法拦截器类（JDK动态代理实现接口InvocationHandler、CGLIB动态代理实现接口MethodInterceptor），编写相应实现方法。委托类传参给代理类构造方法。
使用方法拦截器类，创建动态代理类（JDK动态代理使用Proxy.newProxyInstance、CGLIB动态代理使用Enhancer）。
使用动态代理类调用方法即可。

Java动态代理

JDK动态代理具体实现原理：

通过实现InvocationHandler接口创建自己的调用处理器；
通过为Proxy类指定被代理类的 ClassLoader对象 和 interface集 来创建动态代理；
通过反射机制获取动态代理类的构造函数，其唯一参数类型就是调用处理器接口类型；
通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数参入；

涉及接口InvocationHandler、类Proxy。

动态代理类 MyDynamicProxy ：
public class MyDynamicProxy implements InvocationHandler{
    public Object target;

    public MyDynamicProxy(Object obj){
        this.target  = obj;
    }
    
    @Override
    public Object invoke(Object o, Method method, Object[] objects) throws Throwable {

        enterCheck();

        //反射。执行方法，参数是objects[]，返回值是Object obj。
        Object obj = method.invoke(target,objects);

        exitPrint();

        return obj;
    }

    private void enterCheck() {
        System.out.println("进入检查：enterCheck()!");
    }

    private void exitPrint() {
        System.out.println("退出打印：exitPrint()!");
    }
}

调用：
public class MyDynamicProxyDemo{
    public static void main( String[] args ) {
        Animal animal = new Dog();
        animal.eat();

        MyDynamicProxy myDynamicProxy = new MyDynamicProxy(animal);
        Object obj1 = Proxy.newProxyInstance(animal.getClass().getClassLoader(), animal.getClass().getInterfaces(), myDynamicProxy);
        // Object obj1 = Proxy.newProxyInstance(Dog.class.getClassLoader(), Dog.class.getInterfaces(), myDynamicProxy);
        Animal animalProxy = (Animal) obj1;
        animalProxy.eat();

        System.out.println(obj1.getClass().getName());
    }
}

输出：
Dog eat
进入检查：enterCheck()!
Dog eat
退出打印：exitPrint()!
com.sun.proxy.$Proxy0

注：Proxy.newProxyInstance(Dog.class.getClassLoader(), Dog.class.getInterfaces(), myDynamicProxy); 和 Proxy.newProxyInstance(animal.getClass().getClassLoader(), animal.getClass().getInterfaces(), myDynamicProxy);均可以。

因为 Dog.class 和 animal.getClass() 均是 Dog 的类对象，但不能使用 Animal.class，会报错。

com.sun.proxy.$Proxy0

代理对象的类名：com.sun.proxy.$Proxy0。

通过 Proxy.newProxyInstance 创建的代理对象是在 JVM 运行时动态生成的一个对象，该代理对象会实现该方法的第二个参数上提供的一组接口，这是在运行时动态生成的一个对象，并且命名方式都是这样的形式，以$开头，proxy 为中，最后一个数字表示对象的标号。

当代理类调用方法时，程序就会跳转到由这个代理对象关联到的 handler 中的invoke()方法去执行，而我们的这个 handler 对象又接受了一个 Animal 类型的参数，表示我要代理的就是这个真实对象。

JDK动态代理是利用反射机制动态生成一个实现代理接口的类，在调用具体方法前调用 InvokeHandler 来处理。核心是实现 InvocationHandler接口，使用 invoke() 方法进行面向切面的处理，调用相应的通知；

CGlib动态代理

method.invoke方法

涉及接口MethodInterceptor、类Enhancer。

public void setSuperclass(Class superclass)：设置委托类的字节码文件
public void setCallback(Callback callback)：设置实现接口 MethodInterceptor 的拦截器类
public Object create()：生成代理类对象

动态代理类 MyCGlibProxy：
public class MyCGlibProxy implements MethodInterceptor {
    public Object target;

    public MyCGlibProxy(Object obj){
        target = obj;
    }
    
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

        System.out.println("+++myCGlibProxy start+++");

        //反射。执行方法，参数是objects[]，返回值是Object obj。
        Object obj = method.invoke(target, objects);
        
        System.out.println("+++myCGlibProxy end+++");
        
        return obj;
    }
}

调用：
public class MyDynamicProxyDemo{
    public static void main( String[] args ) {
        Animal animal = new Dog();
        animal.eat();
        System.out.println("\n");

        MyCGlibProxy myCGlibProxy = new MyCGlibProxy(animal);
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Animal.class);
        // enhancer.setSuperclass(Dog.class);
        enhancer.setCallback(myCGlibProxy);
        Object obj2 = enhancer.create();
        
        Animal animalProxy = (Animal) obj2;
        animalProxy.eat();
        System.out.println(obj2.getClass().getName());
    }
}

输出：
Dog eat

+++myCGlibProxy start+++
Dog eat
+++myCGlibProxy end+++
动态代理.Dog$$EnhancerByCGLIB$$f4b84c6e

注：enhancer.setSuperclass(Animal.class); 和 enhancer.setSuperclass(Dog.class); 均可以。

动态代理.Dog$EnhancerByCGLIB$f4b84c6e

代理对象的类名：动态代理.Dog$EnhancerByCGLIB$f4b84c6e。

methodProxy.invokeSuper方法

其他类都不变，修改MyCGlibProxy：

public class MyCGlibProxy implements MethodInterceptor {

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

        System.out.println("+++myCGlibProxy start+++");

        //调用动态代理类中自己生成的 cglib 方法，参数是objects[]，返回值是Object obj。
        Object obj = methodProxy.invokeSuper(o, objects);

        System.out.println("+++myCGlibProxy end+++");

        return obj;
    }
}

调用：

public class MyDynamicProxyDemo{
    public static void main( String[] args ) {
        Animal animal = new Dog();
        animal.eat();
		
        MyCGlibProxy myCGlibProxy = new MyCGlibProxy();
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(animal.getClass());
        enhancer.setCallback(myCGlibProxy);
        Object o = enhancer.create();
		
        Animal animalProxy = (Animal) o;
        animalProxy .eat();
        System.out.println(o.getClass().getName());
    }
}

输出：
Dog eat
+++myCGlibProxy start+++
Dog eat
+++myCGlibProxy end+++
动态代理.Dog$$EnhancerByCGLIB$$f4b84c6e

说明：

动态代理类持有 MethodInterceptor
动态代理类会重写父类 Dog 的非 final、private 方法；也会构建自己的方法（cglib 方法），构建方式：CGLIB”+“$父类方法名$
cglib 方法的方法体：super.方法名，直接调用父类；重写方法：它会调用拦截器中的 intercept() 方法。
methodProxy.invokeSuper()方法会调用动态代理类中的 cglib 方法；methodProxy.invoke()方法会调用动态代理类中的重写方法。

CGLIB 动态代理原理：外界调用了方法后（animalProxy.eat();），由于父类 Dog 被子类（动态代理类）给继承了（已经重写了 eat()），所以，会调用动态代理类中的 eat() 方法。而在这个重写的方法中，又会去调用 MethodInterceptor#intercept()方法。在这个方法中，功能增强后，再去调用动态代理中的 cglib 方法，而此方法又会去调用父类中的方法。

CGLIB动态代理是利用继承机制，使用 asm 开源包，对代理对象类的 class 文件加载进来，通过修改其字节码生成子类来处理。核心是实现 MethodInterceptor 接口，使用 intercept() 方法进行面向切面的处理，调用相应的通知。

两者区别

JDK动态代理是实现了被代理对象的接口；CGLib是继承了被代理对象。
JDK动态代理和CGLib都是在运行期生成字节码，JDK动态代理是直接写class字节码；CGLib使用ASM框架写class字节码，CGLib由于创建多个.class文件，生成代理类比JDK动态代理效率低。
JDK动态代理调用代理方法，是通过反射机制调用；CGLib是通过FastClass机制直接调用方法，CGLib执行效率更高。

动态代理在 Spring 中的应用

如果目标对象实现了接口，默认情况下 Spring 会采用 JDK 的动态代理实现 AOP
如果目标对象实现了接口，Spring 也可以强制使用 CGLIB 实现 AOP
如果目标对象没有实现接口，必须采用 CGLIB 实现动态代理，当然 Spring 可以在 JDK 动态代理和 CGLIB 动态代理之间转换

相关文章：
https://blog.csdn.net/sco5282/article/details/121866799
https://www.cnblogs.com/myitnews/p/12940371.html
https://blog.csdn.net/weixin_36759405/article/details/82770422
https://blog.csdn.net/sco5282/article/details/121866799