【动态代理】JDK 动态代理的使用及原理

妖狐艹你老母 2023-10-01 08:38 13阅读 0赞

在说动态代理之前，还是简单地回顾一下静态代理吧。

### 1. 静态代理 ###

应用场景：

> 学生交作业给老师。现在想通过静态代理的方式，让班长（代理类）代替学生（被代理类）交作业给老师。

为了让代理类与被代理类有相同的行为，那么，通过会让被代理类去实现一个接口，而且，被代理类也会去实现相同的接口。如下：

静态代理案例

`Person`：公共接口

public interface Person {
        
    	// 交作业的方法
        void handOut();
    }

`Student`：被代理类

public class Student implements Person {
        
    
        @Override
        public void handOut() {
        
            System.out.println("学生交作业。");
        }
    }

不使用静态代理

public class Test {
        
    
        public static void main(String[] args) {
        
            Person student = new Student();
            // 学生交作业。
            student.handOut();
        }
    
    }

如果不使用静态代理，那么运行测试代码后，控制台将直接打印出：学生交作业。

使用静态代理

`StudentProxy`：代理类

public class StudentProxy implements Person {
        
    	// 目标对象
        private Person person;
    
        public StudentProxy(Person person) {
        
            this.person = person;
        }
    
        @Override
        public void handOut() {
        
            System.out.println("【代理类】增强原方法");
            person.handOut();
        }
    
    }

说明：

1.  代理类中持有目标对象，然后通过构造器将目标对象传入；
2.  重写 `handOut()` 方法，可增强被代理类的方法的功能。

修改测试类：

public class Test {
        
    
        public static void main(String[] args) {
        
            Person student = new Student();
            Person monitor = new StudentProxy(student);
            // 【代理类】增强原方法
    		// 学生交作业。
            monitor.handOut();
        }
    
    }

使用静态代理后，运行测试代码后，控制台将直接打印出：【代理类】增强原方法；学生交作业。

可见，`StudentProxy#handOut()` 方法确实增强了 `Student#handOut()` 方法  
。

静态代理优、缺点

**优点：** 静态代理使用起来简单、方便  
**缺点：** 一个代理类只能对一个业务接口的实现类进行包装，如果有多个业务接口的话就要定义很多实现类和代理类才行

### 2. JDK 动态代理 ###

常用的动态代理有两类：JDK 动态代理、CGLIB 动态代理。这里主要讲下 JDK 动态代理。

#### 2.1 JDK 动态代理介绍 ####

JDK 动态代理是 JRE 提供给我们的类库，可以直接使用，不依赖第三方。

Java 动态代理类位于 `java.lang.reflect` 包下，一般主要涉及到以下两个类：

`1. InvocationHandler`：该接口中仅定义了一个方法：

public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable;

*  proxy：动态代理对象
 *  method：被代理的方法
 *  args：方法的参数数组

这个抽象方法在代理类中动态实现

`2. Proxy`：该类即为动态代理类

`Proxy#newProxyInstance()`：返回代理类的一个实例

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

动态代理类：它是在运行时生成的一种类，在生成它时，必须提供一组 interfaces 给它，然后该类就会实现这些 interface。动态代理类就是 `Proxy`，它不会替你干任何事，在生成它的时候，也必须提供一个 handler，由它接管实际的工作。

#### 2.2 JDK 动态代理使用 ####

JDK 动态代理使用步骤

**动态代理步骤**：

1.  创建一个实现了接口 `InvocationHandler` 的类，它必须实现 `invoke()` 方法
2.  创建被代理的类和公共接口
3.  调用 `Proxy.newProxyInstance()` 方法创建一个代理类
4.  通过代理对象调用方法

我们使用 JDK 动态代理来实现下上面的应用场景吧。

`Person`：公共接口

public interface Person {
        
    	// 交作业的方法
        void handOut();
    }

`Student`：被代理类

public class Student implements Person {
        
    
        @Override
        public void handOut() {
        
            System.out.println("学生交作业。");
        }
    }

InvocationHandler 实现类

添加一个 `InvocationHandler`，它不是代理类，因为它并没有实现公共接口 `Person`，它仅仅是一个包装器 wrapper。包装了 `target` 对象。

public class PersonHandlerImpl<T> implements InvocationHandler {
        
    
        // 被代理对象
        private T target;
    
        public PersonHandlerImpl(T target) {
        
            this.target = target;
        }
    
        /**
         * @param proxy: 动态代理对象
         * @param method: 正在执行的方法
         * @param args: 调用目标方法时传入的实参
         **/
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
            System.out.println("【增强方法】代理对象正在执行的方法：" + method.getName());
            Object result = method.invoke(target, args);
            return result;
        }
    
    }

添加一个代理工厂类 `ProxyFactory`：生产代理对象

public class ProxyFactory {
        
    
        public static Object creatProxyObj(Object target) {
        
            PersonHandlerImpl handler = new PersonHandlerImpl(target);
            return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), handler);
        }
    
    }

测试类：

public class Test {
        
    
        public static void main(String[] args) {
        
            Person student = new Student();
            Person studentProxy = (Person) ProxyFactory.creatProxyObj(student);
            studentProxy.handOut();
        }
    
    }

`Proxy` 根据 `target` 的接口生成了一个实现类，它就是动态代理类 `$Proxy0`。

**生成过程**：由于拿到的是接口，那么，我们便可以获知接口的所有的信息（方法的定义），也就能声明一个类去实现这个接口，并重写这个接口中所有的方法。而在这些重写的方法中会调用其它对象的方法。当然，这个被调用的对象不能是 `target`。因为，如果是 `target` 对象，那么，我们如何增强其中的方法 `handOut()`。

所以，它调用的是 `target` 的包装类，这个类需要我们来实现。但是，JDK 给出了约束，这个包装类要实现 `InvocationHandler` 接口。上述例子中，就是 `PersonHandlerImpl`。这个类里面有个方法，它是 `target` 的所有方法的调用入口 `invoke()`。在调用它之前，我们可以加自己的代码增强。

所以，可以这么认为：动态代理类 代理了 `InvocationHandler`，而 `InvocationHandler` 又代理了我们的 `target`，两级代理

#### 2.3 JDK 动态代理的原理 ####

通过 Debug 模式，我们可以知道：当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的 handler 对象的 invoke() 方法来进行调用。

即：当调用 `studentProxy.handOut()` 方法时，

Person studentProxy = (Person) ProxyFactory.creatProxyObj(student);
    studentProxy.handOut();

会自动调用 `PersonHandlerImpl#invoke()` 方法：

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
        System.out.println("【增强方法】代理对象正在执行的方法：" + method.getName());
        Object result = method.invoke(target, args);
        return result;
    }

这是为什么呢？？？

过程分析：

我们通过 Debug 模式看代码慢慢分析：

首先看看 `Proxy#newProxyInstance()` 方法：返回一个代理类对象

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        
    	// 1.校验 InvocationHandler 是否为空
        Objects.requireNonNull(h);
    
        // 2.根据类加载器和接口来获取动态代理类对应的 Class 类型
        Class<?> cl = getProxyClass0(loader, intfs);
    
    	// 3.通过反射来获取构造器对象并生成动态代理对象
        try {
         
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            //...
            return cons.newInstance(new Object[]{
        h});
        } catch (IllegalAccessException|InstantiationException e) {
        
            throw new InternalError(e.toString(), e);
        }
        // ...
    }

重点看第2步：`Proxy#getProxyClass0` 方法：

// 代理类缓存
    private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
            proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
    // ...
    
    private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
        
        // 1.公共接口数量不能超过 2^16 - 1 个
        if (interfaces.length > 65535) {
        
            throw new IllegalArgumentException("interface limit exceeded");
        }
    
        // 2.先从缓存中取代理类实例。如果缓存中有，则直接去；否则，需要ProxyClassFactory生成代理类
        return proxyClassCache.get(loader, interfaces);
    }

查看 `WeakCache#get()` 方法：

public V get(K key, P parameter) {
        
        //...
    
        while (true) {
        
            if (supplier != null) {
        
                V value = supplier.get();
                if (value != null) {
        
                    return value;
                }
            }
        }
        //...
    }

虽然，这个 `get()` 方法有很多逻辑，但是，它最后一定会调用 `V value = supplier.get();` 并且，会返回 `value`。因为，这是一个 `while(true)` 循环，且只有一个 `return` 语句。

查看 `Factory#get()` 方法：

`Factory` 为 `WeakCache` 的一个内部类

public synchronized V get() {
         // serialize access
            //...
            
            V value = null;
            try {
        
                value = Objects.requireNonNull(valueFactory.apply(key, parameter));
            } finally {
        
                if (value == null) {
         // remove us on failure
                    valuesMap.remove(subKey, this);
                }
            }
          	//...
          	
            return value;
        }
    }

查看 `valueFactory.apply(key, parameter)` 语句。其中，`valueFactory` 是一个代理工厂 `Proxy$ProxyClassFactory`。

`Proxy$ProxyClassFactory#apply()` 方法：

public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
        
            //...
    
            if (proxyPkg == null) {
        
                proxyPkg = com.sun.proxy + ".";
            }
    
            // 代理对象的名称
            long num = nextUniqueNumber.getAndIncrement();
            String proxyName = proxyPkg + "$Proxy" + num;
    
            // 1.生成代理对象字节码
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
            try {
        
                return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
            } 
            //...
        }
    }

通过这个方法，我们来生成一个字节码文件看看：

public class Test2 {
        
    
        public static void main(String[] args) {
        
            Person student = new Student();
            Person studentProxy = (Person) ProxyFactory.creatProxyObj(student);
            studentProxy.handOut();
            // 生成字节码文件
            createProxyClassFile();
        }
    
        private static void createProxyClassFile(){
        
            String name = "ProxyObject";
            byte[] data = ProxyGenerator.generateProxyClass(name, new Class[]{
        Person.class});
            FileOutputStream out =null;
            try {
        
                out = new FileOutputStream(name + ".class");
                out.write(data);
            } catch (FileNotFoundException e) {
        
                e.printStackTrace();
            } catch (IOException e) {
        
                e.printStackTrace();
            }finally {
        
                if(null != out) {
        
                    try {
        
                        out.close();
                    } catch (IOException e) {
        
                        e.printStackTrace();
                    }
                }
            }
        }
    
    }

反编译这个 class 文件：

public final class ProxyObject extends Proxy implements Person {
        
        private static Method m1;
        private static Method m3;
        private static Method m2;
        private static Method m0;
    
        public ProxyObject(InvocationHandler var1) throws  {
        
            super(var1);
        }
    
        public final boolean equals(Object var1) throws  {
        
            try {
        
                return (Boolean)super.h.invoke(this, m1, new Object[]{
        var1});
            } catch (RuntimeException | Error var3) {
        
                throw var3;
            } catch (Throwable var4) {
        
                throw new UndeclaredThrowableException(var4);
            }
        }
    
        public final void handOut() throws  {
        
            try {
        
                super.h.invoke(this, m3, (Object[])null);
            } catch (RuntimeException | Error var2) {
        
                throw var2;
            } catch (Throwable var3) {
        
                throw new UndeclaredThrowableException(var3);
            }
        }
    
        public final String toString() throws  {
        
            try {
        
                return (String)super.h.invoke(this, m2, (Object[])null);
            } catch (RuntimeException | Error var2) {
        
                throw var2;
            } catch (Throwable var3) {
        
                throw new UndeclaredThrowableException(var3);
            }
        }
    
        public final int hashCode() throws  {
        
            try {
        
                return (Integer)super.h.invoke(this, m0, (Object[])null);
            } catch (RuntimeException | Error var2) {
        
                throw var2;
            } catch (Throwable var3) {
        
                throw new UndeclaredThrowableException(var3);
            }
        }
    
        static {
        
            try {
        
                m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
                m3 = Class.forName("com.zzc.proxy.dynamicproxy.Person").getMethod("handOut");
                m2 = Class.forName("java.lang.Object").getMethod("toString");
                m0 = Class.forName("java.lang.Object").getMethod("hashCode");
            } catch (NoSuchMethodException var2) {
        
                throw new NoSuchMethodError(var2.getMessage());
            } catch (ClassNotFoundException var3) {
        
                throw new NoClassDefFoundError(var3.getMessage());
            }
        }
    }

这就是我们生成的真正的动态代理类：`$Proxy0`。

它继承了 `Proxy` 类，并且实现了公共的接口 `Person`。

语句：`Person studentProxy = (Person) ProxyFactory.creatProxyObj(student);` 中的  
`studentProxy` 就是它的一个实例。

语句：`studentProxy.handOut();` 就是调用动态代理类中的方法：

public final void handOut() throws  {
        
        try {
        
            super.h.invoke(this, m3, (Object[])null);
        }
        //...
    }

所以，为什么会自动调用 `PersonHandlerImpl#invoke()` 方法？

因为 JDK 生成了一个动态代理类，它继承 `Proxy`，并实现了 `Person` 接口，自然会重写 `handOut()` 方法。在重新的方法中，又通过反射去调用了 `PersonHandlerImpl#invoke()` 方法。