Java 动态代理

2015-10-24

诚然，java并不是一门十分死板的语言，反射的功能给开发者们带来了不少的便利（虽然反过来也对代码安全性本身有影响），最近在网上逛的时候意外发现了java除了能进行一般的反射调用外，也支持对接口对象方法的扩展，这种技术官方就叫“动态代理”。虽然这东西已经是很久以前的技术了，但我居然到最近才了解到，惭愧。

所谓的动态代理，说白了一点，就是通过自定义的一个代理类，对原对象的接口方法进行扩展，以达到在运行时执行方法的过程中对定义好的流程进行一点干预。以下是一个简单的例子。

定义一个接口

1
2
3

public interface Flyable {
    void fly();
}

定义一个实现该接口的类

public class Bird implements Flyable {

    @Override
    public void fly() {
        System.out.println("I am Flying");
    }
}

再实现一个代理类

public class FlyProxy implements InvocationHandler {

    private Object bird;

    public FlyProxy(Object bird) {
        this.bird = bird;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before flying...");
        Object obj = method.invoke(this.bird, args);
        System.out.println("after flying...");
        return obj;
    }
}

这个类需要实现InvocationHandler接口，还需要把需要代理的类实例以参数的形式传进来，以在触发接口方法的时候不仅能调用到干预的代码，也能执行原对象的代码。

最后是一个简单的测试类

public class ProxyTest {

    public static void main(String[] args) {
        Bird bird = new Bird();
        FlyProxy proxy = new FlyProxy(bird);

        bird.fly();

        System.out.println();
        Flyable flyObj = (Flyable) Proxy.newProxyInstance(bird.getClass().getClassLoader(), bird.getClass().getInterfaces(), proxy);

        flyObj.fly();
    }
}

最后执行的结果就是

I am Flying

before flying...
I am Flying
after flying...

容易看到，同样是执行fly方法，但不仅把bird实例的fly执行了，还执行了代理类中的两行输出。

开始的时候我只是认为只是一个简单对bird对象再进行了一次封装，然后在实际调用的时候通过调用另一个代理对象来实现扩展。但是，Proxy.newProxyInstance创建的对象同样是Flyable类型的，jvm创建的这个这个类的时候怎么知道需要创建的代理类的类型呢，接口又不能直接创建实例。整个过程中比较关键的地方有两点，一个就是需要有一个实现了InvocationHandler接口的类，这个理解没难度；另一个就是Proxy.newProxyInstance是怎么把代理类给创建出来的。

对于java而言，创建一个实例，最重要的是找到其对应的class，在但这里很明显是没有这个类的（有也只是代理类Proxy，一个通用的类），先来看一下Proxy.newProxyInstance的实现（以下代码刨去了安全检查相关的）：

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
    throws IllegalArgumentException
{
    if (h == null) {
        throw new NullPointerException();
    }

    final Class<?>[] intfs = interfaces.clone();

    /*
     * Look up or generate the designated proxy class.
     */
    Class<?> cl = getProxyClass0(loader, intfs);

    /*
     * Invoke its constructor with the designated invocation handler.
     */
    try {
        final Constructor<?> cons = cl.getConstructor(constructorParams);
        final InvocationHandler ih = h;
        return newInstance(cons, ih);
    } catch (NoSuchMethodException e) {
        throw new InternalError(e.toString());
    }
}

参数interfaces就是从bird.getClass().getInterfaces()中来的，指的是bird这个类实现的接口类，loader即为bird类的类加载器。显然，此处是通过getProxyClass0来获取，再深看

private static Class<?> getProxyClass0(ClassLoader loader,
                                       Class<?>... interfaces) {
    if (interfaces.length > 65535) {
        throw new IllegalArgumentException("interface limit exceeded");
    }
    return proxyClassCache.get(loader, interfaces);
}

getProxyClass0就是通过proxyClassCache这个对象来获取对应的类的。proxyClassCache的定义是

1 2	private static final WeakCache<ClassLoader, Class<?>[], Class<?>> proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

从名字上可以推断，它是一个带自动生成键/值工厂类的键值对。KeyFactory和ProxyClassFactory都是实现接口BiFunction的类.

来到WeakCache的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));//实际上就是调用subKeyFactory.apply方法，获取一个WeakReference类型的key,这个key在这里就是用Class的接口类来生成的，按0,1,2,x四种规格选择不同的生成方法
    Supplier<V> supplier = valuesMap.get(subKey);
    Factory factory = null;

    while (true) {
        if (supplier != null) {
            //supplier就是一个Factory或者CacheValue<V>对象
            V value = supplier.get();
            if (value != null) {
                return value;
            }
        }
        // else no supplier in cache
        // or a supplier that returned null (could be a cleared CacheValue
        // or a Factory that wasn't successful in installing the CacheValue)

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

        if (supplier == null) {
            supplier = valuesMap.putIfAbsent(subKey, factory);
            if (supplier == null) {
                // successfully installed Factory
                supplier = factory;
            }
            // else retry with winning supplier
        } else {
            if (valuesMap.replace(subKey, supplier, factory)) {
                // successfully replaced
                // cleared CacheEntry / unsuccessful Factory
                // with our Factory
                supplier = factory;
            } else {
                // retry with current supplier
                supplier = valuesMap.get(subKey);
            }
        }
    }
}

WeakCache的结构简述如下表，嵌套关系为从左往右，简单来说WeakCache就是一个带有自动生成任意对象为键值对的缓存（虚引用）

整个过程简单来说就是通过在valuesMap中查找到合适的supplier,然后不断地在supplier中获取Class类型的值（此处为泛型V）。此处重点讲在没有缓存情况下的加载过程。

第一次加载接口类，使用keySub获取到的supplier中是肯定找不到对于的代理类缓存的，这时候factory也为空，于是就需要创建一个新的Factory类，用于作为下一次查找的supplier。Factory同样也是一个Supplier类型的，着重看一下它的get方法实现

private final class Factory implements Supplier<V> {

    private final K key;
    private final P parameter;
    private final Object subKey;
    private final ConcurrentMap<Object, Supplier<V>> valuesMap;

    Factory(K key, P parameter, Object subKey,
            ConcurrentMap<Object, Supplier<V>> valuesMap) {
        this.key = key;
        this.parameter = parameter;
        this.subKey = subKey;
        this.valuesMap = valuesMap;
    }

    @Override
    public synchronized V get() { // serialize access
        // re-check
        Supplier<V> supplier = valuesMap.get(subKey);
        if (supplier != this) {
            // something changed while we were waiting:
            // might be that we were replaced by a CacheValue
            // or were removed because of failure ->
            // return null to signal WeakCache.get() to retry
            // the loop
            return null;
        }
        // else still us (supplier == this)

        // create new value
        V value = null;
        try {
            value = Objects.requireNonNull(valueFactory.apply(key, parameter));
        } finally {
            if (value == null) { // remove us on failure
                valuesMap.remove(subKey, this);
            }
        }
        // the only path to reach here is with non-null value
        assert value != null;

        // wrap value with CacheValue (WeakReference)
        CacheValue<V> cacheValue = new CacheValue<>(value);

        // try replacing us with CacheValue (this should always succeed)
        if (valuesMap.replace(subKey, this, cacheValue)) {
            // put also in reverseMap
            reverseMap.put(cacheValue, Boolean.TRUE);
        } else {
            throw new AssertionError("Should not reach here");
        }

        // successfully replaced us with new CacheValue -> return the value
        // wrapped by it
        return value;
    }
}

前面都是一些检查之类的，关键就在于//create new value的地方，假如说现在要加载的代理类没有缓存，那么就需要通过valueFactory.apply(key,parameter)来创建，其中valueFactory就是proxyClassCache时创建的ProxyClassFactory类对象。查看ProxyClassFactory对象的apply实现，如下

public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {

    Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);

    // 检查接口是否可见，是否有重复实现问题
    for (Class<?> intf : interfaces) {
        /*
         * Verify that the class loader resolves the name of this
         * interface to the same Class object.
         */
        Class<?> interfaceClass = null;
        try {
            interfaceClass = Class.forName(intf.getName(), false, loader);
        } catch (ClassNotFoundException e) {
        }
        if (interfaceClass != intf) {
            throw new IllegalArgumentException(
                intf + " is not visible from class loader");
        }
        /*
         * Verify that the Class object actually represents an
         * interface.
         */
        if (!interfaceClass.isInterface()) {
            throw new IllegalArgumentException(
                interfaceClass.getName() + " is not an interface");
        }
        /*
         * Verify that this interface is not a duplicate.
         */
        if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
            throw new IllegalArgumentException(
                "repeated interface: " + interfaceClass.getName());
        }
    }

    String proxyPkg = null;     // package to define proxy class in

    //如果接口是非公开的（类内部定义的），那么就可以定义代理类在同一个包名下了
    //如内部定义的接口为cn.demonk.proxy.Main$Flyable,则代理类包名为cn.demonk.proxy.
    for (Class<?> intf : interfaces) {
        int flags = intf.getModifiers();
        if (!Modifier.isPublic(flags)) {
            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) {
        // if no non-public proxy interfaces, use com.sun.proxy package
        proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
    }

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

    /*
     * 开始创建一个代理类
     */
    byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
        proxyName, interfaces);
    try {
        return defineClass0(loader, proxyName,
                            proxyClassFile, 0, proxyClassFile.length);
    } catch (ClassFormatError e) {
        /*
         * A ClassFormatError here means that (barring bugs in the
         * proxy class generation code) there was some other
         * invalid aspect of the arguments supplied to the proxy
         * class creation (such as virtual machine limitations
         * exceeded).
         */
        throw new IllegalArgumentException(e.toString());
    }

流程图如下：

假如接口类是私有的受保护的，那么如果直接在生成的类中使用别的包里的接口的话会失败的，所以才会有这么一个区分。

部分解释在上述注释上体现，检查之类的不细说，对于一个代理类来说，它的生成规则如下（假定原接口公开）:

1 2	1\. 包名为ReflectUtil.PROXY_PACKAGE = "com.sun.proxy" 2\. 文件名为$Proxy+自增数字，如$Proxy0,$Proxy1

如上述例子中，本次运行生成的全限定名为com.sun.proxy.$Proxy0,然后再根据这个代理类的类名去加载，加载的过程是在ProxyGenerator中执行的，也是这次动态代理中最重要的一部分，ProxyGenreator对象通过方法生成了一串byte，先看源码

private byte[] generateClassFile() {

    /* ============================================================
     * Step 1: Assemble ProxyMethod objects for all methods to
     * generate proxy dispatching code for.
     */

    /*
     * Record that proxy methods are needed for the hashCode, equals,
     * and toString methods of java.lang.Object.  This is done before
     * the methods from the proxy interfaces so that the methods from
     * java.lang.Object take precedence over duplicate methods in the
     * proxy interfaces.
     */
    addProxyMethod(hashCodeMethod, Object.class);
    addProxyMethod(equalsMethod, Object.class);
    addProxyMethod(toStringMethod, Object.class);

    /*
     * Now record all of the methods from the proxy interfaces, giving
     * earlier interfaces precedence over later ones with duplicate
     * methods.
     */
    for (int i = 0; i < interfaces.length; i++) {
        Method[] methods = interfaces[i].getMethods();
        for (int j = 0; j < methods.length; j++) {
            addProxyMethod(methods[j], interfaces[i]);
        }
    }

    /*
     * For each set of proxy methods with the same signature,
     * verify that the methods' return types are compatible.
     */
    for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
        checkReturnTypes(sigmethods);
    }

    /* ============================================================
     * Step 2: Assemble FieldInfo and MethodInfo structs for all of
     * fields and methods in the class we are generating.
     */
    try {
        methods.add(generateConstructor());

        for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
            for (ProxyMethod pm : sigmethods) {

                // add static field for method's Method object
                fields.add(new FieldInfo(pm.methodFieldName,
                    "Ljava/lang/reflect/Method;",
                     ACC_PRIVATE | ACC_STATIC));

                // generate code for proxy method and add it
                methods.add(pm.generateMethod());
            }
        }

        methods.add(generateStaticInitializer());

    } catch (IOException e) {
        throw new InternalError("unexpected I/O Exception");
    }

    if (methods.size() > 65535) {
        throw new IllegalArgumentException("method limit exceeded");
    }
    if (fields.size() > 65535) {
        throw new IllegalArgumentException("field limit exceeded");
    }

    /* ============================================================
     * Step 3: Write the final class file.
     */

    /*
     * Make sure that constant pool indexes are reserved for the
     * following items before starting to write the final class file.
     */
    cp.getClass(dotToSlash(className));
    cp.getClass(superclassName);
    for (int i = 0; i < interfaces.length; i++) {
        cp.getClass(dotToSlash(interfaces[i].getName()));
    }

    /*
     * Disallow new constant pool additions beyond this point, since
     * we are about to write the final constant pool table.
     */
    cp.setReadOnly();

    ByteArrayOutputStream bout = new ByteArrayOutputStream();
    DataOutputStream dout = new DataOutputStream(bout);

    try {
        /*
         * Write all the items of the "ClassFile" structure.
         * See JVMS section 4.1.
         */
                                    // u4 magic;
        dout.writeInt(0xCAFEBABE);
                                    // u2 minor_version;
        dout.writeShort(CLASSFILE_MINOR_VERSION);
                                    // u2 major_version;
        dout.writeShort(CLASSFILE_MAJOR_VERSION);

        cp.write(dout);             // (write constant pool)

                                    // u2 access_flags;
        dout.writeShort(ACC_PUBLIC | ACC_FINAL | ACC_SUPER);
                                    // u2 this_class;
        dout.writeShort(cp.getClass(dotToSlash(className)));
                                    // u2 super_class;
        dout.writeShort(cp.getClass(superclassName));

                                    // u2 interfaces_count;
        dout.writeShort(interfaces.length);
                                    // u2 interfaces[interfaces_count];
        for (int i = 0; i < interfaces.length; i++) {
            dout.writeShort(cp.getClass(
                dotToSlash(interfaces[i].getName())));
        }

                                    // u2 fields_count;
        dout.writeShort(fields.size());
                                    // field_info fields[fields_count];
        for (FieldInfo f : fields) {
            f.write(dout);
        }

                                    // u2 methods_count;
        dout.writeShort(methods.size());
                                    // method_info methods[methods_count];
        for (MethodInfo m : methods) {
            m.write(dout);
        }

                                     // u2 attributes_count;
        dout.writeShort(0); // (no ClassFile attributes for proxy classes)

    } catch (IOException e) {
        throw new InternalError("unexpected I/O Exception");
    }

    return bout.toByteArray();
}

以上就是生成一个class文件的二进制数据，具体是什么东西呢，我中断了它把byte[]的内容输出到了一个文件，实际上这就是一个类编译后的二进制文件。接着使用jd-gui打开（此处有一个技巧，需要把文件把到去项目工程下的bin的目录下，否则容易打不开），显示以下内容

package com.sun.proxy;

import cn.itrunner.proxy.Flyable;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy
  implements Flyable
{
  private static Method m1;
  private static Method m3;
  private static Method m0;
  private static Method m2;

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

  public final boolean equals(Object paramObject)
    throws 
  {
    try
    {
      return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
    }
    catch (Error localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }

  public final void fly()
    throws 
  {
    try
    {
      this.h.invoke(this, m3, null);
      return;
    }
    catch (Error localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }

  public final int hashCode()
    throws 
  {
    try
    {
      return ((Integer)this.h.invoke(this, m0, null)).intValue();
    }
    catch (Error localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }

  public final String toString()
    throws 
  {
    try
    {
      return (String)this.h.invoke(this, m2, null);
    }
    catch (Error localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }

  static
  {
    try
    {
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
      m3 = Class.forName("cn.itrunner.proxy.Flyable").getMethod("fly", new Class[0]);
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
      return;
    }
    catch (NoSuchMethodException localNoSuchMethodException)
    {
      throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
    }
    catch (ClassNotFoundException localClassNotFoundException)
    {
    }
    throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
  }
}

可以看到，这个$Proxy0.class其实就是一个继承Proxy，实现Flyable接口的类。然后再调用native方法去把这个类加载起来。

1	defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);

在加载类的时候，有四个Method对象需要被赋值，。

m0 -> Object.hashCode
m1 -> Object.equals
m2 -> Object.toString
m3 -> Flyable.fly

如此，把类加载起来后，就可以回到Proxy的newProxyInstance中继续了。余下的操作就跟普通反射类似了，获取到构造方法，创建$Proxy0实例，最终返回给我们应用的就是一个创建好的$Proxy0实例，而且它是实现了Flyable接口的。这样我们才可以直接进行类型转换，并调用其实的方法的。

在$Proxy0的fly方法中，调用的是

1	this.h.invoke(this, m3, null);

此处的h就是指Proxy中的h成员变量

/**
 * the invocation handler for this proxy instance.
 * @serial
 */
protected InvocationHandler h;

它是在创建 $Proxy0实例时从构造方法中传入的，事实上就是我们在newProxyInstance时传入的FlyProxy,于是，调用fly方法的时候，FlyProxy的invoke方法就被触发了，剩下的也不需要我说了。

==============================================================

纵观整个过程，其实动态代理最重要的一点技术就是类的动态生成与加载，这一特性的出现并非有心故意弄出来的，而是基于Java本身语言的特性设立的。对于jvm而言，它认为这是不是一个类，并不是看你是不是真的创建好一个实在的文件等它去读才可以，它认识的只是编译好的二进制流，在java开发中，找类这一过程实际上是开放的，无论是从jar中，还是android的dex中，实际上都是寻找class的二进制数据，喂给它规范的二进制数据，它才不管你从哪里来。通过临时创建一个实际上并不存在的类，用来桥接我们的调用，这就是代理的作用，说明白了，其实也就那么点事。

ProxyTest.tar
WeakCache
proxy