定义
动态代理类的源码是在程序运行期间由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