定义

动态代理类的源码是在程序运行期间由JVM根据反射等机制动态的生成，所以不存在代理类的字节码文件。
代理类和委托类的关系是在程序运行时确定。

实现方式

在java的动态代理机制中，有两个重要的类或接口
一个是 InvocationHandler(Interface)、另一个则是 Proxy(Class)，这一个类和接口是实现我们动态代理所必须用到的。

每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个handler，当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。

java.lang.reflect.InvocationHandler#invoke

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable 
//proxy:代理类对象
//method:调用的方法
//args:传入方法的参数

可以看出，现在还不知道代理类对象是什么，这用到了另一个类:java.lang.reflect.Proxy
Proxy类的作用就是用来动态创建一个代理对象的类，它提供了许多的方法，但是我们用的最多的就是 newProxyInstance 这个方法

//返回 动态的代理对象
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,  InvocationHandler h)  throws IllegalArgumentException

loader: 加载代理对象的ClassLoader
interfaces:一个Interface对象的数组，代理类实现的这些接口列表
h:关联到的InvocationHandler对象

demo

package proxy;

import sun.misc.ProxyGenerator;

import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class Main {
    //定义两个subject以及realSubject
    interface UserManager {
        void query();
    }
    static class UserManagerImpl implements UserManager {
        @Override
        public void query() {
            System.out.println("query user");
        }
    }
    interface InfManager {
        void del();
        void add();
    }
    static class InfManagerImpl implements InfManager {
        @Override
        public void add() {
            System.out.println("query add");
        }
        @Override
        public void del() {
            System.out.println("query del");
        }
    }
    //实现InvocationHandler接口
    static class MyProxy implements InvocationHandler {
        Object realSubject;
        //引入实现类
        Object getProxy(Object obj) {
            this.realSubject = obj;
            return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
        }

        //复写invoke方法,进行AOP，完成转发
        @Override
        public Object invoke(Object proxy, Method method, Object[] args)
                throws Throwable {
            //filter();
            //pre();
            //通过反射，把proxy的代理类 转交给 实现类上
            Object res = method.invoke(realSubject, args);
            //after();
            return res;
        }
    }

    public static void main(String[] args) {
        MyProxy myProxy = new MyProxy();
        Object proxy = myProxy.getProxy(new UserManagerImpl());
        System.out.println(proxy + " " + proxy.getClass());
        ((UserManager)proxy).query();

        proxy = myProxy.getProxy(new InfManagerImpl());
        System.out.println(proxy + " " + proxy.getClass());
        ((InfManager)proxy).del();
        ((InfManager)proxy).add();
    }

输出:

proxy.Main$UserManagerImpl@30f39991 class proxy.$Proxy0
query user
proxy.Main$InfManagerImpl@f6f4d33 class proxy.$Proxy1
query del
query add

动态代理优点：

可以看出
1.上面只有一个proxy类，却代理了多个服务UserManager以及InfManager，而静态代理需要n个proxy类
2.通过invoke方法，在所有被代理的类的某些函数调用时触发，一口气完成所有对应代理的AOP
(静态代理需要在每个代理上进行AOP)

调用原理

从上面代码看，有几个问题需要思考一下
1.proxy的class文件是如何生成的
2.proxy的class文件内容是什么
3.proxy类对象是怎么生成的
4.invoke方法是如何触发的

1.proxy的class文件是如何生成的

java.lang.reflect.Proxy#newProxyInstance

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

进入java.lang.reflect.WeakCache#get

//之前利用缓存，设置了supplier（实际是Factory类型）
V value = supplier.get();

进入java.lang.reflect.WeakCache.Factory#get

//valueFactory是ProxyClassFactory类型
value = Objects.requireNonNull(valueFactory.apply(key, parameter));

进入java.lang.reflect.Proxy.ProxyClassFactory#apply

/*
* Generate the specified proxy class.
*/
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);

这里面就是得到class文件byte内容的逻辑

public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
        ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
        //动态生成代理类的字节码,非常复杂
        final byte[] var4 = var3.generateClassFile();
        //根据配置，判断class文件是否存储在本地
        if(saveGeneratedFiles) {
            AccessController.doPrivileged(new PrivilegedAction() {
                public Void run() {
                    try {
                        int var1 = var0.lastIndexOf(46);
                        Path var2;
                        if(var1 > 0) {
                            Path var3 = Paths.get(var0.substring(0, var1).replace('.', File.separatorChar), new String[0]);
                            Files.createDirectories(var3, new FileAttribute[0]);
                            var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");
                        } else {
                            var2 = Paths.get(var0 + ".class", new String[0]);
                        }

                        Files.write(var2, var4, new OpenOption[0]);
                        return null;
                    } catch (IOException var4x) {
                        throw new InternalError("I/O exception saving generated file: " + var4x);
                    }
                }
            });
        }
        //返回代理类的字节码 
        return var4;
    }

2.proxy的class文件内容是什么

可以自定义存储硬盘位置
调用sun.misc.ProxyGenerator#generateProxyClass(java.lang.String, java.lang.Class<?>[])函数即可

public static void showProxyClass() {
        String path = "./$Proxy0.class";
        byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0",
                InfManagerImpl.class.getInterfaces());
        FileOutputStream out = null;
        try {
            out = new FileOutputStream(path);
            out.write(classFile);
            out.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

打开$Proxy0文件如下

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import proxy.Main.InfManager;

public final class $Proxy0 extends Proxy implements InfManager {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m4;
    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 add() 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 del() throws  {
        try {
            super.h.invoke(this, m4, (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("proxy.Main$InfManager").getMethod("add", new Class[0]);
            m4 = Class.forName("proxy.Main$InfManager").getMethod("del", 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());
        }
    }
}

3.proxy类对象是怎么生成的

java.lang.reflect.Proxy#newProxyInstance中
生成了代理对象的字节码文件后,根据构造函数生成对象

//生成字节码，获取类文件
Class<?> cl = getProxyClass0(loader, intfs);
//省略
//反射，根据构造函数，生成对象，构造参数为InvocationHandler h
return cons.newInstance(new Object[]{h});

对应的构造函数为

protected Proxy(InvocationHandler h) {
        Objects.requireNonNull(h);
        this.h = h;
    }

4.invoke方法是如何触发的

可以看到在生成的$Proxy0文件中，代理类实现了委托类的方法

public final void add() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

其中，h就是在生成代理对象时传入的InvocationHandler
也就是说 代理对象触发add方法时，调用InvocationHandler的m3方法

m3方法是什么，在下面有

 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("proxy.Main$InfManager").getMethod("add", new Class[0]);
            m4 = Class.forName("proxy.Main$InfManager").getMethod("del", 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());
        }
    }

m3就是InfManager的add方法
然后看我们自定义的实现proxy.Main.MyProxy#invoke

        @Override
        public Object invoke(Object proxy, Method method, Object[] args)
                throws Throwable {
            //filter();
            //pre();
            //通过反射，把proxy的代理类 转交给 实现类上
            Object res = method.invoke(realSubject, args);
            //after();
            return res;
        }

也就是说代理类调用add方法
实际是利用父类Proxy类的InvocationHandler属性，传入add这个method
在自定义的InvocationHandler中，再利用反射，利用实现类完成add操作
完成了代理类 到 实现类的调用

缺点

由Proxy创建的动态代理 不支持 对 实现类的代理
动态代理类都 extend Proxy类，implements了代理的interface。
由于java不能多继承，这里已经继承了Proxy类了，不能再继承其他的类.
所以JDK的动态代理不支持对实现类的代理，只支持接口的代理。

动态代理不支持对实现类的代理

所以之前生成的class文件是

public final class $Proxy0 extends Proxy implements InfManager

思考

1.Proxy生成的动态代理类只能implements接口，不能extend实现类
这样是动态代理的缺点

2.需要给代理类提供InvocationHandler的实现类类，实现invoke方法。
该invoke方法就是调用被代理接口的所有方法时需要调用的
通过反射让对应的实现类完成响应操作。

3.动态代理是如何生成class文件(以及自定义保存到某路径)，代理对象以及如何调用
生成字节码文件是在sun.misc.ProxyGenerator#generateProxyClass(java.lang.String, java.lang.Class<?>[], int)
不过这个class文件我打开显示是

public static byte[] generateProxyClass(java.lang.String s, java.lang.Class<?>[] classes, int i) { /* compiled code */ }

确定的是jdk动态代理 和 asm没有关系

4.动态代理实现demo步骤

1.定义interface和impl
2.实现InvocationHandler类，在构造函数(或者某函数)传入实现类的对象，在invoke方法里进行AOP，利用反射将调用从代理类转发给实现类

5.有些文章说

Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));

直接进入了
java.lang.reflect.Proxy.ProxyClassFactory#apply
生成class文件
这个是错的，subKeyFactory是KeyFactory类型的

问题

为什么一定要继承Proxy类
目的主要是需要一个类似于InvocationHandler的成员变量，完成从代理转发给实现类
如果动态代理的class文件直接有InvocationHandler变量不就行了么，不继承Proxy类用Proxy的InvocationHandler
代理类的super.h.invoke变成this.h.invoke不就行了???

refer

实现，以及api介绍,与静态代理的比较
http://www.importnew.com/20732.html
http://layznet.iteye.com/blog/1182924
http://www.cnblogs.com/fingerboy/p/5335328.html
http://blog.csdn.net/hejingyuan6/article/details/36203505
https://my.oschina.net/hosee/blog/656945

（动态代理原理）
http://rejoy.iteye.com/blog/1627405
http://blog.csdn.net/zhangerqing/article/details/42504281/
http://blog.csdn.net/scplove/article/details/52451899
http://blog.csdn.net/mhmyqn/article/details/48474815