深入源码理解-java动态代理

动态代理

代理是基本的设计模式之一。代理是为了提供额外不同的操作。代理有静态代理和动态代理，静态代理在之前已经说过，今天来说一下动态代理。静态代理需要自己创建代理类，并实现对所有方法的代理，而java动态代理可以动态地创建代理并动态弟处理对所有方法的调用。
1. 应用
那么我们先来看一下如何创建动态代理。

//创建一个需要被代理的接口
public interface Man {
    void eat();
    void run();
}
//接口的实现类
public class ManImpl implements Man{

    public void eat(){
        System.out.println("eat");
    }

    public void run(){
        System.out.println("run");
    }

}
//动态代理调用处理器
public class ManProxy implements InvocationHandler {
    private Object proxied;
    public ManProxy(Object proxied){
        this.proxied = proxied;
    }
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("启动代理");
        return method.invoke(proxied,args);
    }
}
//实现
public class App {
    public static void main( String[] args ) {
        Man Man = (Man)Proxy.newProxyInstance(Man.class.getClassLoader(),
                            new Class[]{Man.class},
                            new ManProxy(new ManImpl()));
        Man.eat();
    }

}
//运行结果
启动代理
eat

• 结果分析
  通过结果可见是调用了调用处理器ManProxy类的的invoke方法。
  现在开始步骤分析：

  Man Man = (Man)Proxy.newProxyInstance(Man.class.getClassLoader(),
                            new Class[]{Man.class},
                            new ManProxy(new ManImpl()));

首先采用Proxy的newProxyInstance方法生成了一个代理类，这个方法需要传入接口的类加载器，接口的Class类，和一个包含实际对象的调用处理器。生成的代理对象强转成接口后，可以调用接口的所有方法，可见生成的代理类是一个实现了接口所有方法的代理对象。而且通过结果可见，这个代理类的所有方法都调用了inovke方法。当然，这只是我们的初步猜想，我们通过查看源码来一探究竟。
①进入Proxy的newProxyInstance方法

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

        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }


         //通过类加载器和接口class生成指定代理类
        Class<?> cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            if (sm != null) {
//校验权限                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
            //获取代理类的构造方法
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            //实例化代理类
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

通过查看上面的代码，我们可以知道生成代理类的步骤是先通过接口来生成该接口的代理类，然后通过反射机制获取该代理类的构造方法，通过构造方法和调用处理器实例来实例化实例化代理类。
那么我们主要要看如何生成的代理类。

②然后进入getProxyClass0()方法

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.get(loader, interfaces);方法
我们来分析主要的代码段，我们从返回值倒着看代码过程

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);
        Factory factory = null;

        while (true) {
            if (supplier != null) {
                // supplier might be a Factory or a CacheValue<V> instance
                //②这个代理类是从这个是supplier取出，从注释中可见，这个是一个工厂或者是一个缓存实例
                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);
                }
            }
        }
    }

④那么我们进入supplier.get();查看
但是这是个接口，那么如何去寻找他的实现类
⑤
我们可以从上面的代码中找到这段代码
Supplier supplier = valuesMap.get(subKey);
可见这工厂或者说缓存是在map中存着，可是在这个之前我们并没有发现有Supplier的实现类存入这个map当中。
⑥然后我们寻找这个valuesMap出现过的地方
之前代码的后面发现了这么一块代码

 if (supplier == null) {
                supplier = valuesMap.putIfAbsent(subKey, factory);
                if (supplier == null) {
                    // successfully installed Factory
                    supplier = factory;
                }
                // else retry with winning supplier
            } 

发现这个map存入了一个factory，然后跟踪这个factory，

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

发现由这个进行实例化
⑦然后进入这个类，发现这是个Supplier的子类

private final class Factory implements Supplier<V> {

然后寻找get()方法，还是应用老方法，我们通过返回值倒着看代码过程，返回值为value，这个value也就是我们需要寻找的代理类，接着找到一个代理类的创建代码value = Objects.requireNonNull(valueFactory.apply(key, parameter));接着我们进入这个apply()方法

public synchronized V get() { // serialize access
            Supplier<V> supplier = valuesMap.get(subKey);
            if (supplier != this) {
                return null;
            }
            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");
            }

            //返回值
            return value;
        }
    }

⑧进入apply()方法
但是这又是一个接口，那么我们还需要找到他的实现类，从WeakCache的构造方法中我们发现这个实现类是从面外传入的

public WeakCache(BiFunction<K, P, ?> subKeyFactory,
                     BiFunction<K, P, V> valueFactory) {
        this.subKeyFactory = Objects.requireNonNull(subKeyFactory);
        this.valueFactory = Objects.requireNonNull(valueFactory);
    }

返回Proxy，找到proxyClassCache的实例化，

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

⑨可见这个实现类叫做ProxyClassFactory，然后我们进入这个类，找到apply方法。还是老办法，通过返回值寻找值得创建过程。然后我们删去其他代码，留下这个创建返回值的代码段

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


            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);

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

        }

defineClass0是个本地方法，从参数可以看出，是ProxyGenerator.generateProxyClass()这个方法通过接口生成了代理类的字节码，然后通过defineClass返回了这个字节码的类，也就是我们需要的代理类。
⑩到这里，我们已经知道了代理类的生成过程，那么我们来瞧一瞧究竟是一个怎样的代理类，与我们预先设想的代理类大体结构是否一致。
当然，我们也用ProxyGenerator.generateProxyClass()这个方法生成字节码，然后保存到本地进行查看

//生成代理类字节码
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                "$ProxyMan", ManImpl.class.getInterfaces(), 1);
        FileOutputStream outputStream = null;
        try {
            outputStream = new FileOutputStream("f://ProxyMan.class");
            //输出到本地文件
            outputStream.write(proxyClassFile);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
              try {
                outputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

十一、找到这个class文件，然后用反编译软件或者idea打开

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

import com.creat.test.Man;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public class $ProxyMan extends Proxy implements Man {
    private static Method m1;
    private static Method m3;
    private static Method m4;
    private static Method m2;
    private static Method m0;

    public $ProxyMan(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 void run() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void eat() throws  {
        try {
            super.h.invoke(this, m4, (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)).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")});
            m3 = Class.forName("com.creat.test.Man").getMethod("run", new Class[0]);
            m4 = Class.forName("com.creat.test.Man").getMethod("eat", new Class[0]);
            m2 = Class.forName("java.lang.Object").getMethod("toString", 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());
        }
    }
}

观察上面代码，可见这个代理类实现了接口中的run和eat方法，通过反射机制，获取接口中的方法，然后将方法传入原来调用执行器的invoke方法并执行，可见和我们之前的猜想十分类似，这就是完整的动态代理的实现过程。这个是jdk的动态代理，当然java还有一种动态代理是cglib动态代理，cglib动态代理底层则是借助asm来实现的。