动态代理原理及在 Android 中的应用

1、动态代理简介

一、什么是动态代理？

经过反射机制动态生成代理者对象的一种设计模式。

二、如何区分静态代理和动态代理？

• 静态代理：程序运行前，代理类已经存在。
• 动态代理：程序运行前，代理类不存在，运行过程当中，动态生成代理类。

三、为何要使用动态代理？

由于一个静态代理类只能服务一种类型的目标对象，在目标对象较多的状况下，会出现代理类较多、代码量较大的问题。

而使用动态代理动态生成代理者对象能避免这种状况的发生。

2、动态代理原理

先看一下动态代理的 UML 图：

图片参考：设计模式（11）动态代理 JDK VS CGLIB面试必问

一、经过

Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h); 
复制代码

反射生成代理类对象。

二、调用动态代理类对象方法，会回调

h.invoke(thisObject proxy, Method method, Object[] args); //最终调用的是 InvocationHandler 实现类中重写的 invoke() 方法
复制代码

三、最终，经过

method.invoke(Object obj, Object... args);
复制代码

调用目标对象的方法。

3、动态代理实战

一、使用步骤

（1）声明目标对象的抽象接口。

（2）声明调用处理类（实现 InvocationHandler 接口）。

（3）生成目标对象类（实现目标对象的抽象接口，这里因为每一个代理类都继承了 Proxy 类，又 Java 的单继承特性，因此，只能针对接口建立代理类，不能针对类建立代理类，后续会解释）。

（4）生成代理类对象。

（5）经过代理类对象，调用目标对象的方法。

二、实战代码

// （1）声明目标对象的抽象接口
public interface ISubject {
    void buy();
}

// （2）声明调用处理类（实现 InvocationHandler 接口）
public class InvocationHandlerImpl implements InvocationHandler{
    private Object mRealObject;

    public InvocationHandlerImpl(Object realObject) {
        mRealObject = realObject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("proxy invoke, proxy = " + proxy.getClass() + ", realObject = " + mRealObject.getClass());
        Object result = method.invoke(mRealObject, args);
        return result;
    }
}

// （3.1）实现目标对象类 1
public class Buyer1 implements ISubject {
    @Override
    public void buy() {
        System.out.println("buyer1 buy");
    }
}

// （3.2）实现目标对象类 2
public class Buyer2 implements ISubject {
    @Override
    public void buy() {
        System.out.println("buyer2 buy");
    }
}

public class DynamicProxyDemo {
    public static void main(String[] args) {
        // 在工程目录下生成 $Proxy0 的 class 文件
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

        Buyer1 buyer1 = new Buyer1(); //建立目标对象的对象
        InvocationHandlerImpl invocationHandlerImpl1 = new InvocationHandlerImpl(buyer1); //建立调用处理类对象
        
        //（4）生成代理类对象
        ISubject buyer1Proxy = (ISubject) Proxy.newProxyInstance(buyer1.getClass().getClassLoader(), buyer1.getClass().getInterfaces(), invocationHandlerImpl1);
        
        //（5）经过代理类对象，调用目标对象的方法
        buyer1Proxy.buy();

        System.out.println("目标对象1：" + buyer1.getClass());
        System.out.println("代理对象1：" + buyer1Proxy.getClass());

        Buyer2 buyer2 = new Buyer2();
        InvocationHandlerImpl invocationHandlerImpl2 = new InvocationHandlerImpl(buyer2);
        ISubject buyer2Proxy = (ISubject) Proxy.newProxyInstance(buyer2.getClass().getClassLoader(), buyer2.getClass().getInterfaces(), invocationHandlerImpl2);
        buyer2Proxy.buy();

        System.out.println("目标对象2：" + buyer2.getClass());
        System.out.println("代理对象2：" + buyer2Proxy.getClass());
    }
}

复制代码

咱们运行一下这个 Demo，运行结果以下：

proxy invoke, proxy = class com.sun.proxy.$Proxy0, realObject = class com.trampcr.proxy.Buyer1
buyer1 buy
目标对象1：class com.trampcr.proxy.Buyer1
代理对象1：class com.sun.proxy.$Proxy0
proxy invoke, proxy = class com.sun.proxy.$Proxy0, realObject = class com.trampcr.proxy.Buyer2
buyer2 buy
目标对象2：class com.trampcr.proxy.Buyer2
代理对象2：class com.sun.proxy.$Proxy0
复制代码

从日志中能够看到代理类是 com.sun.proxy.$Proxy0，咱们都知道动态代理是动态生成代理类对象，若是能看到动态生成的这个代理类，是否是能更好的理解动态代理的原理？

细心的同窗可能已经看到以上代码中有一行比较特殊的代码，这行代码的做用是把 sun.misc.ProxyGenerator.saveGeneratedFiles 这个变量赋值为 true，这个变量为 true 时，将会在工程目录下生成 $Proxy0 的 class 文件（因为生成代理类的 ProxyGenerator 类在 sun.misc 包中，在 Android Studio 中没法调用，因此这里是在 Intellij 中写的 Demo 进行调用）：

System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
复制代码

运行后，在项目的 src 同级目录下，会出现一个 com.sun.proxy 包，这个包里放的就是动态生成的代理类 $Proxy0。

package com.sun.proxy;

// $Proxy0 默认继承了 Proxy，因此这里解释了“只能针对接口（ISubject）建立代理类，不能针对类建立代理类”。
public final class $Proxy0 extends Proxy implements ISubject {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws {
        try {
            return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    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 void buy() throws {
        try {
            // m3 = Class.forName("com.trampcr.proxy.ISubject").getMethod("buy", new Class[0]);
            // 经过代理类访问目标对象的方法
            // 最终会经过 super.h.invoke() 回调到咱们重写的 InvocationHandler 实现类的 invoke() 中。
            super.h.invoke(this, m3, (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)).intValue();
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m3 = Class.forName("com.trampcr.proxy.ISubject").getMethod("buy", new Class[0]);
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

复制代码

看到这里咱们对动态代理的使用以及动态生成的代理类有了必定认识，但对于代理对象是如何动态生成的，还须要进一步看源码。

4、动态代理源码分析

生成动态代理对象主要是经过：Proxy.newProxyInstance()。

这里的源码分析分为两个版本：JDK 1.7，JDK 1.8。

JDK 1.7

// loader：生成代理对象的类加载器（须要和目标对象是同一个类加载器）
// interfaces：目标对象实现的接口，代理类也须要实现这个接口
// h：InvocationHandler 的实现类对象，动态代理对象调用目标对象方法时，最终会回调 h.invoke()
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException {
        
    ... //省略部分逻辑，直接看主要逻辑
    
    // 一、经过 loader 和 interfaces 建立动态代理类
    Class<?> cl = getProxyClass0(loader, interfaces);

    try {
        // 二、经过反射机制获取动态代理类的构造函数（参数类型是 InvocationHandler.class 类型）
        final Constructor<?> cons = cl.getConstructor(constructorParams);
        final InvocationHandler ih = h;
        
        ...
        
            // 三、经过动态代理类的构造函数和调用处理器对象建立代理类实例
            return newInstance(cons, ih);
        ...
        
    } catch (NoSuchMethodException e) {
        throw new InternalError(e.toString());
    }
}

// loader：生成代理对象的类加载器
// interfaces：目标对象实现的接口，如下简称接口
private static Class<?> getProxyClass0(ClassLoader loader, Class<?>... interfaces) {
    
    ...

    Class<?> proxyClass = null;

    // 接口名称数组，用于收集接口的名称做为代理类缓存的 key
    String[] interfaceNames = new String[interfaces.length];

    // 接口集合，用于检查是否重复的接口
    Set<Class<?>> interfaceSet = new HashSet<>();

    // 遍历目标对象实现的接口
    for (int i = 0; i < interfaces.length; i++) {
        // 获取接口名称
        String interfaceName = interfaces[i].getName();
        Class<?> interfaceClass = null;
        try {
            // 经过反射加载目标类实现的接口到内存中
            interfaceClass = Class.forName(interfaceName, false, loader);
        } catch (ClassNotFoundException e) {
        }
        if (interfaceClass != interfaces[i]) {
            throw new IllegalArgumentException(
                interfaces[i] + " is not visible from class loader");
        }

        ...

        // 若是接口重复，抛出异常
        if (interfaceSet.contains(interfaceClass)) {
            throw new IllegalArgumentException("repeated interface: " + interfaceClass.getName());
        }
        interfaceSet.add(interfaceClass);
        interfaceNames[i] = interfaceName;
    }

    // 将接口名称数组转换为接口名称列表
    List<String> key = Arrays.asList(interfaceNames);

    // 经过 Classloader 获取或者建立一个代理类缓存
    Map<List<String>, Object> cache;
    
    // 将一个 ClassLoader 映射到该 ClassLoader 的代理类缓存
    // private static Map<ClassLoader, Map<List<String>, Object>> loaderToCache = new WeakHashMap<>();
    
    synchronized (loaderToCache) {
        cache = loaderToCache.get(loader);
        if (cache == null) {
            cache = new HashMap<>();
            loaderToCache.put(loader, cache);
        }
    }

    synchronized (cache) {
        do {
            Object value = cache.get(key);
            if (value instanceof Reference) {
                proxyClass = (Class<?>) ((Reference) value).get();
            }
            if (proxyClass != null) {
                return proxyClass;
            } else if (value == pendingGenerationMarker) {
                // 正在建立代理类，等待，代理类建立完成后会执行 notifyAll() 进行通知
                try {
                    cache.wait();
                } catch (InterruptedException e) {
                }
                continue;
            } else {
                // 代理类为空，往代理类缓存中添加一个 pendingGenerationMarker 标识，表示正在建立代理类
                cache.put(key, pendingGenerationMarker);
                break;
            }
        } while (true); //这是一个死循环，直到代理类不为空时，返回代理类
    }

    // 如下为生成代理类逻辑
    try {
        String proxyPkg = null;

        // 遍历接口的访问修饰符，若是是非 public 的，代理类包名为接口的包名
        for (int i = 0; i < interfaces.length; i++) {
            int flags = interfaces[i].getModifiers();
            if (!Modifier.isPublic(flags)) {
                String name = interfaces[i].getName();
                int n = name.lastIndexOf('.');
                String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                if (proxyPkg == null) {
                    proxyPkg = pkg;
                } else if (!pkg.equals(proxyPkg)) {
                    throw new IllegalArgumentException("non-public interfaces from different packages");
                }
            }
        }

        if (proxyPkg == null) {
            // 若是接口都是 public 的，则用 com.sun.proxy 做为包名，这个从 $Proxy0 类中能够看到
            proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
        }

        {
            long num;
            synchronized (nextUniqueNumberLock) {
                num = nextUniqueNumber++;
            }
            String proxyName = proxyPkg + proxyClassNamePrefix + num;

            // 根据代理类全路径和接口建立代理类的字节码
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);
            try {
                // 根据代理类的字节码生成代理类
                proxyClass = defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {
                throw new IllegalArgumentException(e.toString());
            }
        }
        
        // 建立的全部代理类集合
        // private static Map<Class<?>, Void> proxyClasses = Collections.synchronizedMap(new WeakHashMap<Class<?>, Void>());
        proxyClasses.put(proxyClass, null);
    } finally {
        synchronized (cache) {
            if (proxyClass != null) {
                // 建立好代理类后存到代理类缓存中
                cache.put(key, new WeakReference<Class<?>>(proxyClass));
            } else {
                // 不然，清除以前存入的 pendingGenerationMarker 标识
                cache.remove(key);
            }
            cache.notifyAll();
        }
    }
    return proxyClass;
}
复制代码

源码有点多，总结一下动态生成代理类对象的过程：

一、经过 loader 和 interfaces 建立动态代理类（首先，根据代理类全路径和接口建立代理类的字节码，其次，根据代理类的字节码生成代理类）。

二、经过反射机制获取动态代理类的构造函数（参数类型是 InvocationHandler.class 类型）。

三、经过动态代理类的构造函数和调用处理器对象建立代理类实例。

最后，动态建立的代理类能够看上边贴过的代码：$Proxy0。

JDK 1.8

// loader：生成代理对象的类加载器（须要和目标对象是同一个类加载器）
// interfaces：目标对象实现的接口，代理类也须要实现这个接口
// h：InvocationHandler 的实现类对象，动态代理对象调用目标对象方法时，最终会回调 h.invoke()
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException {
    ..

    // clone 传入的目标对象实现的接口
    final Class<?>[] intfs = interfaces.clone();
        
    ...

     1、经过 loader 和 interfaces 建立动态代理类
    Class<?> cl = getProxyClass0(loader, intfs);

    try {
        ...

        // 二、经过反射机制获取动态代理类的构造函数（参数类型是 InvocationHandler.class 类型）
        final Constructor<?> cons = cl.getConstructor(constructorParams);
            
        ...
            
        // 三、经过动态代理类的构造函数和调用处理器对象建立代理类实例
        return cons.newInstance(new Object[]{h});
    } 
        
    ...
}

private static Class<?> getProxyClass0(ClassLoader loader, Class<?>... interfaces) {
    
    ...

    // 代理类缓存
    // private static final WeakCache<ClassLoader, Class<?>[], Class<?>> proxyClassCache = 
    // new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
    
    // 根据传入的 loader 和 interfaces 从缓存中获取代理类，若是没有缓存，经过 ProxyClassFactory 建立代理类
    return proxyClassCache.get(loader, interfaces);
}

public V get(K key, P parameter) {
        
    ...

    // private final ReferenceQueue<K> refQueue = new ReferenceQueue<>();
    Object cacheKey = CacheKey.valueOf(key, refQueue); //把 key 转为 CacheKey

    // map 的 key 是 Object 类型，key 的值支持 null
    // private final ConcurrentMap<Object, ConcurrentMap<Object, Supplier<V>>> map = new ConcurrentHashMap<>();
    ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
    if (valuesMap == null) {
        ConcurrentMap<Object, Supplier<V>> oldValuesMap = map.putIfAbsent(cacheKey, valuesMap = new ConcurrentHashMap<>());
        if (oldValuesMap != null) {
            valuesMap = oldValuesMap;
        }
    }

    // 关键点一、subKeyFactory 被传进来的是 new KeyFactory()，稍后看下 KeyFactory.apply()
    Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
    Supplier<V> supplier = valuesMap.get(subKey);
    Factory factory = null;

    // 这是一个死循环，循环跳出条件是 value 不为空
    // 关键点二、这里比较关键的点是 supplier.get()，这里会经过 ProxyClassFactory 建立代理类
    while (true) {
        if (supplier != null) {
            // supplier 多是一个 Factory 或 CacheValue<V> 实例
            V value = supplier.get();
            if (value != null) {
                return value;
            }
        }

        if (factory == null) {
            factory = new Factory(key, parameter, subKey, valuesMap);
        }

        if (supplier == null) {
            supplier = valuesMap.putIfAbsent(subKey, factory);
            if (supplier == null) {
                supplier = factory;
            }
        } else {
            if (valuesMap.replace(subKey, supplier, factory)) {
                supplier = factory;
            } else {
                supplier = valuesMap.get(subKey);
            }
        }
    }
}

// 关键点一、获取 subKey（KeyFactory.apply()）
// 这个方法主要是根据接口个数建立 subKey
public Object apply(ClassLoader classLoader, Class<?>[] interfaces) {
    switch (interfaces.length) {
        case 1: return new Key1(interfaces[0]);
        case 2: return new Key2(interfaces[0], interfaces[1]);
        
        // private static final Object key0 = new Object();
        case 0: return key0;
        default: return new KeyX(interfaces);
    }
}

// 关键点二、supplier.get() == WeakCache.Factory.get()
public synchronized V get() {
            // 双重校验
            Supplier<V> supplier = valuesMap.get(subKey);
            if (supplier != this) {
                // 出现这种状况的缘由可能有：
                // 一、被 CacheValue 代替
                // 二、由于失败被移除
                return null;
            }

            V value = null;
            try {
                // 关键点三、valueFactory = ProxyClassFactory
                // 真正建立代理类的代码在 ProxyClassFactory.apply() 中
                value = Objects.requireNonNull(valueFactory.apply(key, parameter));
            } finally {
                if (value == null) {
                    valuesMap.remove(subKey, this);
                }
            }

            assert value != null;

            CacheValue<V> cacheValue = new CacheValue<>(value);

            if (valuesMap.replace(subKey, this, cacheValue)) {
                reverseMap.put(cacheValue, Boolean.TRUE);
            } else {
                throw new AssertionError("Should not reach here");
            }

            return value;
        }

// 关键点三、Proxy.ProxyClassFactory.apply()：建立代理类
// 这个方法的代码就很熟悉了，和 JDK 1.7 中 getProxyClass0() 方法几乎同样
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
    Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
    for (Class<?> intf : interfaces) {
        Class<?> interfaceClass = null;
        try {
            interfaceClass = Class.forName(intf.getName(), false, loader);
        } catch (ClassNotFoundException e) {
        }
        
        ...
    }

    String proxyPkg = null;
    int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

    for (Class<?> intf : interfaces) {
        int flags = intf.getModifiers();
        if (!Modifier.isPublic(flags)) {
            accessFlags = Modifier.FINAL;
            String name = intf.getName();
            int n = name.lastIndexOf('.');
            String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
            if (proxyPkg == null) {
                proxyPkg = pkg;
            } else if (!pkg.equals(proxyPkg)) {
                throw new IllegalArgumentException("non-public interfaces from different packages");
            }
        }
    }

    if (proxyPkg == null) {
        proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
    }

    long num = nextUniqueNumber.getAndIncrement();
    String proxyName = proxyPkg + proxyClassNamePrefix + num;

    byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);
    try {
        return defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length);
    } catch (ClassFormatError e) {
        throw new IllegalArgumentException(e.toString());
    }
}

复制代码

JDK 1.7 和 JDK 1.8 中的源码分析完了，咱们发现其实生成代理类的方法都是同样的，区别主要体如今缓存方式上，JDK 1.8 做了性能上的优化，速度明显比 1.7 提高了不少。

5、动态代理在 Android 中的应用

一、Android 的跨进程通讯中使用了动态代理

好比 Activity 的启动过程，其实就隐藏了远程代理的使用。

二、Retrofit 中 create() 方法经过动态代理获取接口对象。

这些场景可能不够全面，你们能够在评论区补充，看到新的场景，我后续也会补充的。

参考：

公共技术点之 Java 动态代理

代理模式（Proxy Pattern）：动态代理 - 最易懂的设计模式解析