动态代理技术

动态代理面经：

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

• 静态代理：代理类 + 公共接口 + 被代理类
• Jdk动态代理：代理类 + 公共接口 + 被代理类 + 处理类 (InvocationHandler)
• Cglib动态代理：代理类 + 被代理类 + 方法拦截器 (MethodInterceptor)

---

一、静态代理

实现原理：

• 基于反射：代理类 + 公共接口 + 被代理类
• JVM层面：在编译阶段，代理类 、被代理类 、公共接口就已经变成了.class文件

静态代理存在的问题：

• 问题1）：每当有一个委托类就要对应的写一个代理类
• 问题2）：如果接口需要扩展新方法，那么委托类和代理类都需要修改，重写新增的方法
• 问题3）：代理类只能调用接口中的公共方法，不能调用被代理类中不在公共接口的方法

---

二、Jdk动态代理

实现原理：

• 基于反射：代理类 + 公共接口 + 被代理类 + 处理类 (InvocationHandler)

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

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

解决的问题：

1） 可以通过JdkProxyFactory，获取多个代理类。

• 解决了静态代理中的"每个委托类都需要写一个被代理类" 的问题。

2） 通过引入处理类(InvocationHandler)，将代理类调用委托类方法的动作抽取出来，封装成了一个通用的处理类。基于反射对代理类调用委托类方法这个动作进行统一的调用。

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

jdk存在的问题：

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

---

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

---

三、Cglib动态代理

实现原理：

• 基于反射 + ASM字节码框架 +子类继承：代理类 + 被代理类 + 方法拦截器 (MethodInterceptor)
• 方法调用：当代理类调用父类(委托类)中的方法时，实际调用的是方法拦截器中重写的 intercept()方法
• JVM层面：运行时动态生成代理类的.class字节码文件，并加载到JVM中

解决的问题：

• 1）Cglib与Jdk都能够解决静态代理中的问题1）和2）。
• 2）解决了Jdk动态代理只能调用接口中公共方法的问题。

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

---

Cglib动态代理的步骤

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-核心代理步骤

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

---

四、动态代理失效的几种情况

代理模式	描述
JDK动态代理失效的情况	只能代理public修饰的，static和final无法代理
Cglib动态代理失效的情况	只能代理public和protected修饰的，static和final无法代理