深度解析JDK动态代理
动态代理模式，就是在内存中动态生成$Proxy0对象，该对象实现了要被代理对象的接口。
如下图，$Proxy0就是在内存中生成的。
1. 首先需要写一个class，实现InvocationHandler接口。重写invoke方法。
invoke方法有3个参数：
1.第一个参数是Proxy的一个动态实例。只有Proxy实例在InvocationHandler实现类里加载才可以产生第二个参数method，所以$Proxy实例需要把自己传给invoke方法。在InvocationHandler源码中对proxy的描述：proxy the proxy instance that the method was invoked on。
2.第二个参数method是真实对象要实现的业务方法，由$Proxy0实例的静态代码段得到。
3.第三参数args是method的参数。
主要起作用是method.invoke，将要被代理对象的接口传进去。
public class MyHandler implements InvocationHandler{
private People people;
public MyHandler(People people){
this.people=people;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
before();
//obj是要被代理的类
method.invoke(people, args);
after();
return null;
}
private void before(){
System.out.println("吃之前做一些准备工作");
}
private void after(){
System.out.println("吃之后做一些整理工作");
}
}在使用的过程中，普通调用一般是
People people=new Damon();动态代理则不同，
People proxyPeople=(People) Proxy.newProxyInstance(proxyTest.class.getClassLoader(),
new Class[] {People.class},
new MyHandler(new Damon())); proxyPeople.eat();首先需要使用Proxy类的newProxyInstance方法。需要3个参数，其中前两个参数用来生成$Proxy的构造器，在以involcationHandler为参数生成$Proxy实例。
1.第一个参数是类加载器。不一定要指定具体class，用this.getClass().getClassLoader()也可以。
2. 第二个参数接口数组。需要实现的接口。这个会体现在$Proxy中。
3.第三个参数调用处理器，指派involcationHandler去实际执行增强业务。
当执行的时候，会自动在内存中生成$Proxy0对象。该对象实现了People接口。所以这是为什么JDK动态代理只能代理有接口的类。
其重写了接口的eat方法，调用了h.invoke()；
查看$Proxy，可以使用ProxyGenerator生成byte数组，然后在用outputStream生成.class文件，进行反编译，查看java代码。
ProxyGenerator.generateProxyClass自己重写Proxy类。主要实现其newProxyInstance静态方法。
public static Object newProxyInstance(ClassLoader loader,
Class[] interfaces, Handler myHandler) {
String fileName = "D:/Java_space_sum/0413/Proxy/src/invoke/myproxy/$Proxy0.java"; 1.指定java文件存放地址。
String fileName = "D:/Java_space_sum/0413/Proxy/src/invoke/myproxy/$Proxy0.java";其实JDK支持读取当前文件所在路径，不需要hadcode.
InputStream resourceStream=MyProxy.class.getResourceAsStream("/"); 2.创建一个类结构
private static String getJavaStr(Class[] interfaces) {
Method[] methods = interfaces[0].getMethods();
String proxyClass = "package baoming" + rt + "import " + rt
+ "public class $Proxy0 implements" + interfaces[0].getName()
+ "{" + rt + "MyInvocaltionHandler h;" + rt + "public ";
return proxyClass;
}3.生成java文件
private static void createJavaFile(String javaClassStr,String fileName) {
File f = new File(fileName);
FileWriter fw;
try {
fw = new FileWriter(f);
fw.write(javaClassStr);
fw.flush();
fw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}4.编译java文件，生成.class文件
private static void compilerJava(String fileName){
JavaCompiler systemJavaComplier=ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager standardJavaFileManager=systemJavaComplier.getStandardFileManager
(null, null, null);
Iterable javaFileObject=standardJavaFileManager.getJavaFileObjects(fileName);
systemJavaComplier.getTask(null, standardJavaFileManager,
null, null, null, javaFileObject);
}5.自定义一个类加载器，把对应的.class文件加载到内存中。生成代理对象
private static Object LoadClass(Handler h){
MyClassLoader myClassLoader=new MyClassLoader("D:/Java_space_sum/0413/Spring0414/src/invoke/MyProxy");
Object newInstance = null;
try {
Class findClass = myClassLoader.findClass("$Proxy0");
//内存里面的代理对象的反射对象
Constructor constructor=findClass.getConstructor(Handler.class);
//拿到反射对象的构造器
newInstance=constructor.newInstance(h);
//这个newInstance就是我们需要的代理实例
return newInstance;
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return newInstance;
}cglib实现原理跟JDK动态代理不一样。cglib支持无接口实现的类。但是不支持使用final修饰的类。其底层使用到了ASM字节码包，所以又叫字节码代理。