java动态代理与反射
引言：
java的代理分为静态代理与动态代理，静态代理有其固有缺点，即代码量大，缺乏灵活性。故我们主要关注的还是动态代理。而动态代理是基于java反射机制实现的一种代理模式。
动态代理的用处：动态代理的用处很广。比如，我们常用的spring的AOP，即是通过动态代理技术来实现的。
要理解动态代理，首先需要了解java反射的基本概念及API方法。在这里假设你已经知道java反射的基础知识，在这个前提下，我们通过一个例子程序，即可说明动态代理的实现原理：
interface Manager {
public void modify1();
public void modify2();
}
class ManagerImpl implements Manager {
public void modify1() {
System.out.println("*******ManagerImpl 的 modify()1方法被调用*******");
}
public void modify2() {
System.out.println("*******ManagerImpl 的 modify()2方法被调用*******");
}
}
class ManagerImpl2 implements Manager {
public void modify1() {
System.out.println("*******ManagerImpl2 的 modify()1方法被调用*******");
}
public void modify2() {
System.out.println("*******ManagerImpl2 的 modify()2方法被调用*******");
}
}
class BusinessHandler implements InvocationHandler {
private Object object = null;
public BusinessHandler(Object object) {
this.object = object;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("do something before method");
Object ret = method.invoke(this.object, args);
System.out.println("do something after method");
return ret;
}
}
public class Client {
public static void main(String[] args) {
// 元对象(被代理对象)
ManagerImpl managerImpl = new ManagerImpl();
ManagerImpl2 managerImpl2 = new ManagerImpl2();
// 业务代理类
BusinessHandler securityHandler = new BusinessHandler(managerImpl);
// 获得代理类($Proxy0 extends Proxy implements Manager)的实例.
Manager managerProxy = (Manager) Proxy.newProxyInstance(managerImpl
.getClass().getClassLoader(), managerImpl.getClass()
.getInterfaces(), securityHandler);
System.out.println("——————");
//通过反射，可以知晓，在内存中实际生成了一个$Proxy0的类，亦可通过反射看出这个类的代码组成
//这里可以通过运行结果证明managerProxy是Proxy的一个实例，这个实例实现了Manager接口
System.out.println(managerProxy instanceof Proxy);
//这里可以看出managerProxy的Class类是$Proxy0,这个$Proxy0类继承了Proxy，实现了Manager接口
System.out.println("managerProxy的Class类是："+managerProxy.getClass().toString());
System.out.print("managerProxy中的属性有：");
Field[] field=managerProxy.getClass().getDeclaredFields();
for(Field f:field){
System.out.print(f.getName()+", ");
}
System.out.print("\n"+"managerProxy中的方法有：");
Method[] method=managerProxy.getClass().getDeclaredMethods();
for(Method m:method){
System.out.print(m.getName()+", ");
}
System.out.println("\n"+"managerProxy的父类是："+managerProxy.getClass().getSuperclass());
System.out.print("\n"+"managerProxy实现的接口是：");
Class<?>[] interfaces=managerProxy.getClass().getInterfaces();
for(Class<?> i:interfaces){
System.out.print(i.getName()+", ");
}
System.out.println();
System.out.println("——————");
managerProxy.modify1();
managerProxy.modify2();
System.out.println("——————");
// 业务代理类，用以演示动态代理的优势：不用增加格外代码，只需增加另一个代理处理类，然后绑定到一个新的InvocationHandler实例上，即可实现扩充
securityHandler = new BusinessHandler(managerImpl2);
// 获得代理类($Proxy0 extends Proxy implements Manager)的实例.
managerProxy = (Manager) Proxy.newProxyInstance(managerImpl2
.getClass().getClassLoader(), managerImpl2.getClass()
.getInterfaces(), securityHandler);
managerProxy.modify1();
managerProxy.modify2();
}
}
执行结果：
—————— true managerProxy的Class类是：class testReflect_10.$Proxy0 managerProxy中的属性有：m4, m1, m0, m3, m2, managerProxy中的方法有：equals, toString, hashCode, modify1, modify2, managerProxy的父类是：class java.lang.reflect.Proxy managerProxy实现的接口是：testReflect_10.Manager, —————— do something before method *******ManagerImpl 的 modify()1方法被调用******* do something after method do something before method *******ManagerImpl 的 modify()2方法被调用******* do something after method —————— do something before method *******ManagerImpl2 的 modify()1方法被调用******* do something after method do something before method *******ManagerImpl2 的 modify()2方法被调用******* do something after method
说明：
1、InvocationHandler是个代理处理类的父类（接口），只定义了一个invoke方法。BusinessHandler继承了该接口，并实现了invoke方法；
2、securityHandler = new BusinessHandler(managerImpl)：实例化一个代理处理类，并传入一个要代理的真实“对象”：managerImpl。
3、(Manager) Proxy.newProxyInstance(managerImpl
.getClass().getClassLoader(), managerImpl.getClass()
.getInterfaces(), securityHandler) 方法：创建了一个$Proxy0类的实例（不要问我是怎么知道的，代码里已经很清楚的看到，是可以通过反射打印出来的），这个实例继承了Proxy类，也实现了要代理的那个Manager接口，同时，还传入一个BusinessHandler的实例。
4、重点来了，managerProxy.modify1()，这句代码执行的时候，为什么会调用BusinessHandler的 invoke()方法？答案：也是通过反射，让我看到了那个$Proxy0类的代码（你可以通过反射的各种方法去将这个类的所有信息都可以打印出来）。其实网上也有很多同学已经帮我们去辛辛苦苦扣下来了$Proxy0类的代码，如是：
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class $Proxy0 extends Proxy implements Manager{
private static Method m4;
private static Method m1;
private static Method m0;
private static Method m3;
private static Method m2;
static {
try {
m4 =Class.forName("java.lang.Object").getMethod("equals",
new Class[] { Class.forName("java.lang.Object") });
m1 =Class.forName("java.lang.Object").getMethod("toString",
new Class[0]);
m0 =Class.forName("java.lang.Object").getMethod("hashCode",
new Class[0]);
m3 =Class.forName("com.ml.test.Manager").getMethod("modify1",
new Class[0]);
m2 =Class.forName("com.ml.test.Manager").getMethod("modify2",
new Class[0]);
} catch (NoSuchMethodExceptionnosuchmethodexception) {
throw newNoSuchMethodError(nosuchmethodexception.getMessage());
} catch(ClassNotFoundException classnotfoundexception) {
throw newNoClassDefFoundError(classnotfoundexception.getMessage());
}
} //static
public $Proxy0(InvocationHandler invocationhandler) {
super(invocationhandler);
}
@Override
public final boolean equals(Object obj) {
try {
return ((Boolean) super.h.invoke(this, m4, new Object[] { obj })).booleanValue();
} catch (Throwable throwable) {
throw newUndeclaredThrowableException(throwable);
}
}
@Override
public final int hashCode() {
try {
return ((Integer)super.h.invoke(this, m0, null)).intValue();
} catch (Throwable throwable) {
throw newUndeclaredThrowableException(throwable);
}
}
public final void modify1() {
try {
super.h.invoke(this, m3, null);
return;
} catch (Error e) {
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
public final void modify2() {
try {
super.h.invoke(this, m2, null);
return;
} catch (Error e) {
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
@Override
public final String toString() {
try {
return (String) super.h.invoke(this, m1,null);
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
}
看到关键代码没？这个：
public final void modify1() {
try {
super.h.invoke(this, m3, null);
return;
明白了吧？代理类每次执行方法时，实际就是通过BusinessHandler这个真正的代理处理类的invoke方法来执行的。invoke方法的：method.invoke(this.object, args)这个方法，是java的反射技术，通过这个方法其实真正执行了managerImpl的modify1()这些方法。
——————这下明白了吧，动态代理的实现步骤：
1、继承并实现InvocationHandler接口及其invoke方法，这个方法体的实现其实也比较固定，就如例子程序那样；
2、通过Proxy的newProxyInstance方法创建一个代理实例，这个创建方法也会把真正处理方法执行的InvocationHandler绑定在一块。
3、再用第二步的proxy实例执行方法时，实际是调用了InvocationHandler的invoke方法，最终执行了真实的managerImpl的modify1()方法。
最后，我再画一个图吧：
希望对大家理解动态代理有所帮助！谢谢。