JAVA动态代理浅析

1 动态代理使用

先看下动态代理如何使用，然后再分析下实现原理

Object proxy = Proxy.newProxyInstance(person.getClass().getClassLoader(), person.getClass().getInterfaces(), new InvocationHandler() {
    @Override
    public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
        String name = method.getName();

        Log.log("Object o, Method method, Object[] objects----------");
        if (method.getName().equals("setName")) {
            String item=(String) objects[0];
            objects[0]="modify="+item;
        }

        return method.invoke(person, objects);

    }
});

jdk1.8之前动态代理在实现时反射会被频繁调用到，所以在性能上会稍微差一些，但在jdk1.8对动态代理的实现做了改良，性能有所提高

2 JDK 1.7动态代理实现

看下在JDK1.7中动态代理的实现逻辑，大致如下：

根据classloader和动态代理的接口类型先从缓存中获取已经生成的class对象，如果存在该对象则拿到该对象后通过反射生成代理对象。如果该class对象不存在则通过ProxyGenerator的generateProxyClass方法创建出对应的byte数组
最终调用defineclass方法将byte数组转换成class对象并缓存下次使用。

源码分析：

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

调用getProxyClass0，如果缓存存在则直接使用，没有缓存则内部创建。拿到class对象后通过反射创建代理对象。

getProxyClass0整体逻辑如下，先添个整体代码，后面分段看具体逻辑：

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

将上面的代码拆分，先来看下动态代理从缓存获取代理class对象逻辑：

不同的classloader生成的class不是同一个对象，所以需要根据classloader和接口类型来唯一标志一个代理class对象，接口类型如何获取在JDK1.7和JDK1.8逻辑上有区分，这也是JDK1.8效率更高的原因。先看下JDK1.7的接口获取逻辑

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

interfaces即外部传入的需要实现的接口数组，然后会经过一系列逻辑去重处理，最终通过

List<String> key = Arrays.asList(interfaceNames);

来标记需要实现动态代理的class对象最终要实现哪些接口。
查看上述代码可以发现在去重逻辑内部使用到了反射生成class对象，该逻辑是每次调用newProxyInstance生成动态代理对象时都会执行的逻辑，对性能是有一定影响的。

拿到唯一标记key后如何从缓存拿到class代理对象逻辑如下：

    // 通过 Classloader 获取或者创建一个代理类缓存
    Map<List<String>, Object> cache;

    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); //这是一个死循环，直到代理类不为空时，返回代理类
     }

loaderToCache定义如下：

private static Map<ClassLoader, Map<List<String>, Object>> loaderToCache = new WeakHashMap<>();

key是一个classloader对象，value是该classloader生成的所有的动态代理对象，但是不同的动态代理对象可能实现了不同的接口，所以通过一个Map<List<String>, Object>来保存，List<String>用来唯一标记接口类型，Object就是真正的代理class对象了。理解上述意思后再看上面的代码就很清晰了。

最终class对象如何生成就是根据字节码规则生成一个文件，然后往文件中写入字段，方法等来实现，实际上网上有一个著名的开源框架ASM就是专门用来处理字节码插桩工作的，可以允许开发者在对字节码并没有非常熟悉的情况下也可以实现字节码的插桩工作。但是JDK在实现字节码插桩时并没有借助该开源框架而是手写插桩逻辑。到此JDK1.7的动态代理分析就完成了。

3 JDK1.8动态代理实现思路

总体和JDK1.7大致一致，但是在缓存处理上和1.7有部分出入。

private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
    proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
    
private static Class<?> getProxyClass0(ClassLoader loader,
                                       Class<?>... interfaces) {
    if (interfaces.length > 65535) {
        throw new IllegalArgumentException("interface limit exceeded");
    }

    // If the proxy class defined by the given loader implementing
    // the given interfaces exists, this will simply return the cached copy;
    // otherwise, it will create the proxy class via the ProxyClassFactory
    return proxyClassCache.get(loader, interfaces);
}

proxyClassCache获取代理class也是通过classloader和接口来唯一标志。KeyFactory就是接口key的生成逻辑，
ProxyClassFactory就是生成class的工厂类，内部逻辑和1.7大致一致。主要是KeyFactory如何生成key

private static final class KeyFactory
    implements BiFunction<ClassLoader, Class<?>[], Object>
{
    @Override
    public Object apply(ClassLoader classLoader, Class<?>[] interfaces) {
        switch (interfaces.length) {
            case 1: return new Key1(interfaces[0]); // the most frequent
            case 2: return new Key2(interfaces[0], interfaces[1]);
            case 0: return key0;
            default: return new KeyX(interfaces);
        }
    }
}

生成逻辑很简单就是通过interfaces长度来生成不同的key。而在JDK1.7中是通过反射，然后去重等一系列操作来完成的，所以在性能上1.8的处理更优。

proxyClassCache的get方法部分代码：

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

    expungeStaleEntries();

    Object cacheKey = CacheKey.valueOf(key, refQueue);

    // lazily install the 2nd level valuesMap for the particular cacheKey
    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;
        }
    }

    // create subKey and retrieve the possible Supplier<V> stored by that
    // subKey from valuesMap
    Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
    Supplier<V> supplier = valuesMap.get(subKey);
    
    ......
}

这里要在缓存中获取到代理class对象，需要classloader和接口来唯一标志。JDK1.8中将classloader做为key，而把接口类型做为subkey，通过这两个key来获取class对象。知道这层关系后再看上面代码就非常清楚了，后面生成class对象的代码省略，和JDK1.7大同小异。到此1.8的分析也就结束了。

4 android动态代理实现

android中动态代理和JDK实现总体一致，但是真正在生成字节码对象时的逻辑不是在java层处理，generateProxy是一个jni方法

// Android-changed: Generate the proxy directly instead of calling
// through to ProxyGenerator.
List<Method> methods = getMethods(interfaces);
Collections.sort(methods, ORDER_BY_SIGNATURE_AND_SUBTYPE);
validateReturnTypes(methods);
List<Class<?>[]> exceptions = deduplicateAndGetExceptions(methods);

Method[] methodsArray = methods.toArray(new Method[methods.size()]);
Class<?>[][] exceptionsArray = exceptions.toArray(new Class<?>[exceptions.size()][]);

/*
 * Choose a name for the proxy class to generate.
 */
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num;

return generateProxy(proxyName, interfaces, loader, methodsArray,
exceptionsArray);
}

5 JAVA动态代理为什么只能代理有接口的类，而不能代理普通类

如果把JDK生成的代理类保存下来，可以看到类似如下结构

public class $proxy0 extends proxy implements 接口类型{
......
}

可以看到代理类已经继承了proxy类，由于java是单继承结构，所以代理类对象不能代理普通的类

为什么需要继承proxy主要原因：

• 1 newProxyInstance传入了一个invocationHandler对象处理代理方法，如果生成的代理类不继承proxy对象，那么这个invocationHandler的调用时机，保存也需要通过字节码写入到代理class中，增加了逻辑复杂性。继承proxy后通用逻辑就可以放在proxy处理

• 2 在业务处理层面上，一般会在接口层抽象一些公共处理能力，然后通过具体类去实现对应接口是符合业务设计思想，所以通过动态代理相应的接口，对相关的处理方法进行拦截处理从设计角度上看是符合逻辑的。如果在业务层面上一定要代理普通类那么需要使用cglib库来实现。cglib底层也是通过字节码插桩框架ASM来实现的，通过实现一个子类来重写父类的非final方法达到动态代理的目的