java动态代理详解
很久很久以前，我曾经听过一个网络课，老师手动实现了jdk底层的动态代理，当时不太理解，只手动抄写了一些源码。碰巧今天和别人讨论动态代理的东西，就翻出了以前的老笔记，整理整理写个博客，希望能对初学者有些帮助，也算是加深自己的理解。好了，废话不多说，首先说下最基础的代理模式是啥吧，先上代码：
package com.sunsy.proxy;
public interface Animal {
void eat();
}package com.sunsy.proxy;
public class Cat implements Animal {
@Override
public void eat() {
System.out.println("cat eat fish!");
}
}package com.sunsy.proxy;
public class CatTimeProxy implements Animal {
Animal a;
public CatTimeProxy(Animal a) {
super();
this.a = a;
}
@Override
public void eat() {
long start = System.currentTimeMillis();
System.out.println("start time:" + start);
a.eat();
long end = System.currentTimeMillis();
System.out.println("end time:" + end);
}
}package com.sunsy.proxy;
public class MainTest {
public static void main(String[] args) {
Cat t = new Cat();
CatTimeProxy catTimeProxy = new CatTimeProxy(t);
catTimeProxy.eat();
}
}以上的Animal接口、Cat类、CatTimeProxy类就构成了一个很简单的代理模式，Cat类是被代理对象，CatTImeProxy是代理类，和被代理对象实现了同样的接口，但是这个类里有个属性就是被代理对象，然后实现接口的方法时要在方法中调用被代理类的接口实现方法。。。说的可能比较绕，但是相信看下代码很容易就理解了。
好了，最基础的东西说完了，接下来我们就要开始实现自己的动态代理了。首先，我们先创建一个自己的Proxy类，这个类里有个newProxyInstance方法，我们把整个CatTimeProxy类作为一个字符串放到这个方法里，然后我们将这个字符串编译成类放到内存里，这样用户使用的时候只要掉newProxyInstance方法就能拿到代理类了，虽然现在这个字符串现在是写死的，也就是说拿到的代理类是固定的，不过如何去解决这个问题是下一步的工作了，我们还是一步一步来吧。。
package com.sunsy.proxy;
public class Proxy {
public static Object newProxyInstance() {
String src =
"package com.sunsy.proxy;" +
"public class CatTimeProxy implements Animal {"+
"Animal a;"+
"public CatTimeProxy(Animal a) {"+
"super();"+
"this.a = a;"+
"}"+
"@Override"+
"public void eat() {"+
"long start = System.currentTimeMillis();"+
"System.out.println(\"start time:\" + start);"+
"a.eat();"+
"long end = System.currentTimeMillis();"+
"System.out.println(\"end time:\" + end);"+
"}"+
"}";
return null;
}
}
现在我只在这个类里写了一个字符串，显然，如果我们把这个字符串编译一下，生成class文件，然后把生成的类读到内存里，我们就又向前进了一步，接下来，我们来实现一下：
package com.sunsy.proxy;
import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.net.URL;
import java.net.URLClassLoader;
import javax.tools.JavaCompiler;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import javax.tools.JavaCompiler.CompilationTask;
public class Proxy {
public static Object newProxyInstance() throws Exception {
String rt = "\r\n";
String src =
"package com.sunsy.proxy;" + rt+
"public class CatTimeProxy1 implements Animal {"+rt+
"Animal a;"+rt+
"public CatTimeProxy1(Animal a) {"+rt+
"super();"+rt+
"this.a = a;"+rt+
"}"+rt+
"@Override"+rt+
"public void eat() {"+rt+
"long start = System.currentTimeMillis();"+rt+
"System.out.println(\"start time:\" + start);"+rt+
"a.eat();"+rt+
"long end = System.currentTimeMillis();"+rt+
"System.out.println(\"end time:\" + end);"+rt+
"}"+rt+
"}";
System.out.println(System.getProperty("user.dir"));
String fileName = System.getProperty("user.dir") + "\\src\\com\\sunsy\\proxy\\CatTimeProxy1.java";
File f = new File(fileName);
FileWriter fw = new FileWriter(f);
fw.write(src);
fw.flush();
fw.close();
//编译生成class文件
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
Iterable iterator = fileManager.getJavaFileObjects(fileName);
CompilationTask t = compiler.getTask(null, fileManager, null, null, null, iterator);
t.call();
fileManager.close();
//把class读到内存中
URL[] urls = new URL[] {new URL("file:/" + System.getProperty("user.dir") + "/src")};
URLClassLoader uLoader = new URLClassLoader(urls);
Class c = uLoader.loadClass("com.sunsy.proxy.CatTimeProxy1");
System.out.println(c);
//创建对象
Constructor constructor = c.getConstructor(Animal.class);
Animal animal = (Animal)constructor.newInstance(new Cat());
return animal;
}
}
然后我们在main方法里调用Animal animal = (Animal) Proxy.newProxyInstance();animal.eat();可以看到初步效果已经出来了。但是我们现在写的这个代理只能生成一个实现Animal的代理，那么怎么才能和jdk一样可以生成实现任意接口的代理呢？很简单，最容易想到的方法就是把想要实现哪种接口也作为参数传入到newProxyInstance方法中。如下，Proxy里的newProxyInstance变成了下面这样：
public static Object newProxyInstance(Class interf) throws Exception {
String rt = "\r\n";
String src =
"package com.sunsy.proxy;" + rt+
"public class CatTimeProxy1 implements " + interf.getName() + " {"+rt+调用的时候需要传入接口类型，像这样：Animal animal = (Animal) Proxy.newProxyInstance(Animal.class);。
但是这样还是有问题的，因为我们的字符串里实现的方法（eat方法）是写死的，这显然不合理，别人传了个别的接口，这个接口里没有eat，那不是GG了？所以我们还要获取传入的接口的方法然后做一些处理，newProxyInstance方法就变成了下边这样：
public static Object newProxyInstance(Class interf) throws Exception {
String rt = "\r\n";
String methodStr = "";
Method[] methods = interf.getMethods();
for(Method m : methods) {
methodStr += "@Override" + rt +
"public void " + m.getName() + "() {" + rt +
"long start = System.currentTimeMillis();"+rt+
"System.out.println(\"start time:\" + start);"+rt+
"a." + m.getName() + "();" +rt+
"long end = System.currentTimeMillis();"+rt+
"System.out.println(\"end time:\" + end);"+rt+
"}";
}
String src =
"package com.sunsy.proxy;" + rt+
"public class CatTimeProxy1 implements " + interf.getName() + " {"+rt+
"Animal a;"+rt+
"public CatTimeProxy1(Animal a) {"+rt+
"super();"+rt+
"this.a = a;"+rt+
"}"+rt+
methodStr +
"}";
System.out.println(System.getProperty("user.dir"));
String fileName = System.getProperty("user.dir") + "\\src\\com\\sunsy\\proxy\\CatTimeProxy1.java";
File f = new File(fileName);
FileWriter fw = new FileWriter(f);
fw.write(src);
fw.flush();
fw.close();
//编译生成class文件
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
Iterable iterator = fileManager.getJavaFileObjects(fileName);
CompilationTask t = compiler.getTask(null, fileManager, null, null, null, iterator);
t.call();
fileManager.close();
//把class读到内存中
URL[] urls = new URL[] {new URL("file:/" + System.getProperty("user.dir") + "/src")};
URLClassLoader uLoader = new URLClassLoader(urls);
Class c = uLoader.loadClass("com.sunsy.proxy.CatTimeProxy1");
System.out.println(c);
//创建对象
Constructor constructor = c.getConstructor(interf);
Object o = constructor.newInstance(new Cat());
return o;
}好了，这时候我们不管传入啥接口，只要这个接口里有实现方法，那么我们的代理都会给这个方法的前边加上开始时间，后边加上结束时间。但是问题又出现了，我们这个代理加的逻辑是写死的，也就是只能显示开始时间和结束时间，如果我们想变个功能，比如加点日志加点权限控制这种操作，就需要改代码，而且是改我们的那个长长的字符串，这显然顶不住，所以我们要再进行一些操作，我们需要搞个新的类，这个类可以动态的指定代理里要实现的逻辑，这个类就是InvocationHandler接口，如下：
package com.sunsy.proxy;
import java.lang.reflect.Method;
public interface InvocationHandler {
public void invoke(Object object, Method method);
}这个接口的invoke有两个参数，method是想要修饰的方法，由于实现类里需要反射去调用方法，所以必须有个对象（只有静态方法不需要先创建对象），所以必须有个Object参数，接下来我们写一个InvocationHandler的实现类——TimeHandler，如下：
package com.sunsy.proxy;
import java.lang.reflect.Method;
public class TimeHandler implements InvocationHandler {
private Object target;
public TimeHandler(Object target) {
super();
this.target = target;
}
@Override
public void invoke(Object o, Method m) { //这里边传入的这个Object是我们自己生成的哪个类的对象
long start = System.currentTimeMillis();
System.out.println("start time:" + start);
//要想调用一个方法，必须得有个对象才行（又不是静态方法）,所以我们要在传入的参数上加个Object
try {
m.invoke(target, new Object[] {});
} catch (Exception e) {
e.printStackTrace();
}
long end = System.currentTimeMillis();
System.out.println("end time:" + end);
}
public Object getTarget() {
return target;
}
public void setTarget(Object o) {
this.target = o;
}
}
然后我们需要修改一下Proxy类，在字符串里动态的生成method并调用，最后创建返回对象的时候改为传入InvocationHandler类型的参数，如下：
package com.sunsy.proxy;
import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import javax.tools.JavaCompiler;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import javax.tools.JavaCompiler.CompilationTask;
public class Proxy {
public static Object newProxyInstance(Class interf, InvocationHandler h) throws Exception {
String rt = "\r\n";
String methodStr = "";
Method[] methods = interf.getMethods();
// for(Method m : methods) {
// methodStr += "@Override" + rt +
// "public void " + m.getName() + "() {" + rt +
// "long start = System.currentTimeMillis();"+rt+
// "System.out.println(\"start time:\" + start);"+rt+
// "a." + m.getName() + "();" +rt+
// "long end = System.currentTimeMillis();"+rt+
// "System.out.println(\"end time:\" + end);"+rt+
//
// "}";
// }
for(Method m : methods) {
methodStr += "@Override" + rt +
"public void " + m.getName() + "() {" + rt +
"try{" + rt +
"java.lang.reflect.Method md = " + interf.getName() + ".class.getMethod(\"" + m.getName() + "\");" + rt +
"h.invoke(this, md);" + rt +
"}catch(Exception e){e.printStackTrace();}" + rt +
"}";
}
String src =
"package com.sunsy.proxy;" + rt+
"public class CatTimeProxy1 implements " + interf.getName() + " {"+rt+
"com.sunsy.proxy.InvocationHandler h;" + rt +
"public CatTimeProxy1(com.sunsy.proxy.InvocationHandler h) {"+rt+
"this.h = h;"+rt+
"}"+rt+
methodStr +
"}";
System.out.println(System.getProperty("user.dir"));
String fileName = System.getProperty("user.dir") + "\\src\\com\\sunsy\\proxy\\CatTimeProxy1.java";
File f = new File(fileName);
FileWriter fw = new FileWriter(f);
fw.write(src);
fw.flush();
fw.close();
//编译生成class文件
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
Iterable iterator = fileManager.getJavaFileObjects(fileName);
CompilationTask t = compiler.getTask(null, fileManager, null, null, null, iterator);
t.call();
fileManager.close();
//把class读到内存中
URL[] urls = new URL[] {new URL("file:/" + System.getProperty("user.dir") + "/src")};
URLClassLoader uLoader = new URLClassLoader(urls);
Class c = uLoader.loadClass("com.sunsy.proxy.CatTimeProxy1");
System.out.println(c);
//创建对象
Constructor constructor = c.getConstructor(InvocationHandler.class);
Object o = constructor.newInstance(h);
return o;
}
}
然后我们调用一下main方法：
package com.sunsy.proxy;
public class MainTest {
public static void main(String[] args) throws Exception {
Cat cat = new Cat();
InvocationHandler h = new TimeHandler(cat);
Animal animal = (Animal) Proxy.newProxyInstance(Animal.class, h);
animal.eat();
}
}
调用之后会生成一个CatTimeProxy1类，看一看生成的结果是啥，再看看控制台输出的信息，是不是实现了大爷想要添加的逻辑（注意，这时候是不是感觉基本已经大功告成了，如果不是自己写的代码，调用的人完全不知道会有CatTimeProxy1这个类生成，已经很接近jdk底层的动态代理实现了）：
package com.sunsy.proxy;
public class CatTimeProxy1 implements com.sunsy.proxy.Animal {
com.sunsy.proxy.InvocationHandler h;
public CatTimeProxy1(com.sunsy.proxy.InvocationHandler h) {
this.h = h;
}
@Override
public void eat() {
try{
java.lang.reflect.Method md = com.sunsy.proxy.Animal.class.getMethod("eat");
h.invoke(this, md);
}catch(Exception e){e.printStackTrace();}
}}至此，我们自己手写动态代理就结束了，下面我们来看看正牌的动态代理是咋用的吧，很简单，就几行代码，我就直接贴出来了。以下是华丽的分割线
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
package com.sunsy.jdkproxy;
public interface Animal {
void eat();
}
package com.sunsy.jdkproxy;
public class Cat implements Animal {
@Override
public void eat() {
System.out.println("cat eat fish");
}
}
package com.sunsy.jdkproxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class TimeHandler implements InvocationHandler {
private Object obj;
public TimeHandler(Object obj) {
this.obj = obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("start!");
Object result = method.invoke(obj, args);
System.out.println("end!");
return result;
}
}
package com.sunsy.jdkproxy;
import java.lang.reflect.Proxy;
public class MainTest {
public static void main(String[] args) {
Animal animal = new Cat();
TimeHandler h = new TimeHandler(animal);
Animal proxy = (Animal) Proxy.newProxyInstance(animal.getClass().getClassLoader(), animal.getClass().getInterfaces(), h);
proxy.eat();
}
}