动态代理相关

ashore℡

已于 2022-09-08 09:54:52 修改

阅读量238

点赞数

文章标签：代理模式 java 开发语言

于 2022-08-04 22:01:35 首次发布

本文链接：https://blog.csdn.net/weixin_49238443/article/details/126166806

版权

一、静态代理

二、Jdk动态代理

三、Cglib动态代理

动态代理面经：

代理模式

概述：使用代理对象来代替真实对象的访问，可以在不修改原目标的情况下，提供额外的功能操作，扩展目标对象的功能

——静态代理：代理类+公共接口+被代理类

——jdk动态代理：代理类+公共接口+被代理类+处理类（InvocationHandler）

——Cglib动态代理：代理类+被代理类+方法拦截器（MethodInterceptor）

一、静态代理

1.实现原理：

（1）基于反射：代理类+公共接口+被代理类

（2）JVM层面：在编译阶段，代理类、被代理类、公共接口就已经编程了.class文件

2.静态代理存在的问题：

（问题1）：每当有一个委托类就要对应的写一个代理类

（问题2）：如果接口需要扩展新方法，那么委托类和代理类都需要修改，重写新增的方法

（问题3）：代理类只能调用接口中的公共方法，不能调用被代理中不在公共接口的方法

二、Jdk动态代理

1.实现原理：

（1）基于反射：代理类+公共接口+被代理类+处理类（InvocationHandler）

（2）方法调用：当代理类调用接口中的公共方法时，实际调用的是InvocationHandler中重写的invoke()方法

（3）JVM层面：运行时动态生成代理的.class字节码文件，并加载到JVM中

2.解决的问题

（解决1）：可以通过JdkProyxFactory，获取多个代理类。

——解决了静态代理中的“每个委托类都需要写一个被历代类”的问题。

（解决2）：通过引入处理类（InvocationHander），将代理类调用委托方法的动作抽取处理，封装成了一个通用的处理类。基于反射对代理类调用委托类方法这个动作进行统一的调用。

——解决了静态代理中的“如果接口需要扩展新方法，那么委托类和代理类都需要修改，重写新增的方法”的问题。

jdk存在的问题：

代理类只能调用接口中的公共方法，不能调用被代理类中不在公共接口的方法

3.Jdk动态代理的步骤

（1）被代理类

public class Student implements Person {
    String name;
    //cglib必须要有空参构造器
    public Student() {
    }
    public Student(String name) {
        this.name = name;
    }
    /*
        存钱这个方法没有在公共接口中
        jdk动态代理就无法调用，而由于cglib是基于继承的方法，因此cglib可以调用
     */
    public void saveMoney() {
        System.out.println("花费了50元");
    }
    @Override
    public void giveMoney(double money) {
        System.out.println(name + "上交班费 => " + money + "元");
    }
}

（2）公共接口

public interface Person {
    void giveMoney(double money);
}

（3）处理类(InvocationHandler)

public class JdkInvocationHandler implements InvocationHandler {

    //被代理对象
    private Object target;

    public JdkInvocationHandler(Object target) {
        this.target = target;
    }

    /**
     * proxy: 代表动态代理对象
     * method：被代理对象的方法
     * args：代表调用目标方法时传入的实参
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Jdk动态代理，监听开始！");
        Object result = method.invoke(target, args);
        System.out.println("Jdk动态代理，监听结束！");
        return result;
    }
}

(4)生成代理对象，方法调用

public class JdkProxyTest {
    public static void main(String[] args) {
        //1、实际被代理的对象
        Student student = new Student("张三");
        //2、创建被代理对象的处理类
        JdkInvocationHandler invocationHandler = new JdkInvocationHandler(student);
        /*
         * 3、通过jdk代理工程创建代理类(其代理类必须转换为接口Person,不能强转为Student,因此不能调用Person中没有定义的方法)
         *    即Student中的私有方法是无法调用的
         */
        Person proxy = (Person) Proxy.newProxyInstance(student.getClass().getClassLoader(),
                student.getClass().getInterfaces(),
                invocationHandler);
        //4、动态代理调用，实际调用的是invocationHandler中的invoke()方法
        proxy.giveMoney(100);
        //5、jdk动态代理不能调用不在接口中的方法
        //proxy.saveMoney(100);
    }
}

(5)工厂类 JdkProxyFactory （即实现步骤的总结）

public class JdkProxyFactory {
    /**
     * target：被代理类
     * target.getClass().getClassLoader()：被代理类的类加载器
     * target.getClass().getInterfaces()：被代理类实现的接口
     * new JdkInvocationHandler(target)：处理类
     */
    public static Object getProxy(Object target) {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                                      target.getClass().getInterfaces(),
                                      new JdkInvocationHandler(target));
    }
}

4.JDK动态代理只能代理有接口的类？

我认为这个问题的核心本质是JDK动态代理本身的机制来决定的，首先在Java里面，动态代理是通过Proxy.newProxyInstance() 这个方法来实现的，它需要传入被动态代理的一个接口类，之所以要传入接口而不能传入类，还是取决于动态代理的一个底层实现，JDK动态代理会在程序的运行期间去动态生成一个代理类，叫$Proxy0，那么这个动态生成的代理类呢，会去继承一个java.lang.reflect.ProxyS这样一个类，同时还会去实现被代理类的接口，在java里面是不支持多种继承的，而每个动态代理类都继承了一个Proxy，所以就导致JDK里面的动态代理只能代理接口而不能代理实现类。我之前有分析过动态代理的源码，发现Proxy这个类只是保存了动态代理的一个处理器叫InvocationHandler，如果不抽出来直接设置到$Proxy这个动态代理的里面，我认为也是可以的，如果这么去实现的话呢，就可以针对实现类去做动态代理了，作者为什么这么设计，我认为可能是这么几个原因，首先动态代理本身的使用行家或者需求，只是对原始实现的一个拦截，但后去做一些功能的增强或者扩展，而实际的开发模式都是基于面向接口来开发的，所以基于接口来是心啊动态代理，从需求和场景呢，我认为都是吻合的，当然确实会存在一些没有实现接口的一些类，那么这个时候我们要去实现动态代理，那么JDK很显然无法满足的；第二个是在Java里面，类的技能关系的设计啊，更多的是考虑到共性能力的抽象，从而去提高代码的重用性和扩展性，而动态代理其实也在做这样一件事，它封装了动态代理类生成的抽象逻辑，以及判断一个类是否是一个动态代理类，以及InvocationHandler的一个持有等等，那么我们去把这些抽象的公共逻辑放在Proxy这个父类里面，很显然也是一个比较正常的一个设计思路，所以总的来说，这个地方并没有什么值得特别去讨论的地方，因为我认为技术的方案的设计，是解决特定的场景问题，如果一定要针对普通类来去做动态代理，我们可以选择Cglib这样一个组件，它会动态生成一个被代理类的子类，子类重写父类所有非final修饰的方法，在子类中去拦截父类的所有方法的一个调用，从而去实现动态代理。

三、Cglib动态代理

1.实现原理：

基于反射+ASM字节码框架+子类继承：代理类+被代理类+方法拦截器(MethodInterceptor)

方法调用：当代理类调用父类（委托类）中的方法时，实际调用的方法是方法拦截器中重写的intercept()方法

JVM层面：运行时动态此时代理类.class字节码文件，并加载到JVM中

2.解决的问题：

（1）Cglic和Jdk都能解决静态代理中的问题（1）和问题（2）；

（2）解决了Jdk动态代理只能调用接口中公共方法的问题。

——Cglib不需要公共接口。而是通过在运行时，生成被代理类的子对象，然后在方法拦截器中拦截父类的方法调用请求，加以额外的逻辑处理。因此，它也能够解决Jdk动态代理中存在改问题。

1-方法拦截器（MethodInterceptor）

public class CglibMethodInterceptor implements MethodInterceptor {

    //被代理类
    private Object target;
    
    public CglibMethodInterceptor(Object target) {
        this.target = target;
    }
    /**子类拦截父类的方法调用，当代理类调用方法时，实际上执行的是intercept()方法
     * proxy:代表动态代理对象本身
     * method：被代理对象的方法
     * args：代表调用目标方法时传入的实参
     * methodProxy：方法的代理
     */
    @Override
    public Object intercept(Object proxy, Method method, Object[] args, 
    						MethodProxy methodProxy) throws Throwable {
        System.out.println("Cglib动态代理，监听开始！");
        Object result = method.invoke(target, args);//方法执行参数：target 目标对象 arr参数数组
        System.out.println("Cglib动态代理，监听结束！");
        return result;
    }
}

2-实现Cglib动态代理的步骤

public class CglibProxyTest {
    public static void main(String[] args) {
        //0、创建被代理类
        Student student = new Student("李四");
        //1、创建字节码增强器
        Enhancer enhancer = new Enhancer();
        //2、设置被代理类Student为其父类
        enhancer.setSuperclass(student.getClass());
        //3、设置回调，拦截器拦截父类的方法调用
        enhancer.setCallback(new CglibMethodInterceptor(student));
        //4、创建并返回代理类
        Student proxy = (Student) enhancer.create();
        //5、调用方法
        proxy.giveMoney(1000);
        //saveMoney()方法，在jdk动态代理中就不能调用
        proxy.saveMoney();
    }
}

3-工厂类CglibProxyFactory（即实现步骤的总结）

public class CglibProxyFactory {
    public static Object getCglibProxy(Object target) {
        //0、target为被代理类
        
        //1、创建字节码增强器
        Enhancer enhancer = new Enhancer();
        //2、设置代理类为其父类
        enhancer.setSuperclass(target.getClass());
        //3、设置回调，拦截器拦截父类的方法调用
        enhancer.setCallback(new CglibMethodInterceptor(target));
        //4、创建并返回代理类
        Object result = enhancer.create();
        
        return result;
    }
}