转载

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

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

3、为什么要使用动态代理？

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

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

二、动态代理原理

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

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

1、通过

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

反射生成代理类对象。

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

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

3、最终，通过

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

调用目标对象的方法。

三、动态代理实战

1、使用步骤

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

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

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

（4）生成代理类对象。

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

2、实战代码

// （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());
        }
    }
}

复制代码

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

四、动态代理源码分析

生成动态代理对象主要是通过：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 {
        
    ... //省略部分逻辑，直接看主要逻辑
    
    // 1、通过 loader 和 interfaces 创建动态代理类
    Class<?> cl = getProxyClass0(loader, interfaces);

    try {
        // 2、通过反射机制获取动态代理类的构造函数（参数类型是 InvocationHandler.class 类型）
        final Constructor<?> cons = cl.getConstructor(constructorParams);
        final InvocationHandler ih = h;
        
        ...
        
            // 3、通过动态代理类的构造函数和调用处理器对象创建代理类实例
            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;
}
复制代码

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

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

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

3、通过动态代理类的构造函数和调用处理器对象创建代理类实例。

最后，动态创建的代理类可以看上边贴过的代码：$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 {
        ...

        // 2、通过反射机制获取动态代理类的构造函数（参数类型是 InvocationHandler.class 类型）
        final Constructor<?> cons = cl.getConstructor(constructorParams);
            
        ...
            
        // 3、通过动态代理类的构造函数和调用处理器对象创建代理类实例
        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;
        }
    }

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

    // 这是一个死循环，循环跳出条件是 value 不为空
    // 关键点2、这里比较关键的点是 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);
            }
        }
    }
}

// 关键点1、获取 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);
    }
}

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

            V value = null;
            try {
                // 关键点3、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;
        }

// 关键点3、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 提升了很多。