非完全原创，但也非完全转载，仅仅是学习笔记，不作他用...
代理模式
代理模式的特征：代理类与委托类有同样的接口，代理类与委托类之间通常会存在关联关系，一个代理类对象与一个委托类对象关联，代理类对象本身并不真正实现服务，而是通过调用委托类对象的相关方法，来提供特定的服务。正是如此，代理类可以在调用委托类服务方法的前后运行一些其它逻辑，以增强委托类的功能。
按照代理的创建时期，代理类可以分为两种。：
静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。
动态代理：在程序运行时，运用反射机制动态创建而成。
JDK动态代理
一、主要涉及类及其主要方法
1、java.lang.reflect.Proxy
Proxy 提供用于创建动态代理类和实例的静态方法：
static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)返回代理类的一个实例，返回后的代理类可以当作被代理类使用（二者实现了共同的接口，因此可以替代被代理使用）。
2、java.lang.reflect.InvocationHandler
InvocationHandler 是代理实例的调用处理程序实现的接口，该接口中仅定义了一个方法：
Object invoke(Object obj,Method method, Object[] args)在实际使用时，第一个参数obj实际就是动态代理类代理类$Proxy0的实例，method是被代理的方法，args为该方法的参数数组。
需要注意的是obj参数，如果将其强制转换为业务接口并调用其中的业务方法，这样会又会调用super.h.invoke(this, m3, null)方法，也就是又进到本方法来，引起死循环。
二、一个简单的例子
被代理对象的接口及实现类：
public interface Manager {
public void modify();
}
public class ManagerImpl implements Manager {
public void modify() {
System.out.println("*******modify()方法被调用");
}
}public class BusinessHandler implements InvocationHandler {
private Object object = null;
public BusinessHandler(Object object) {
this.object = object;
}
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();
BusinessHandler securityHandler = new BusinessHandler(managerImpl);
Class clazz = managerImpl.getClass();
Manager managerProxy = (Manager) Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(), securityHandler);
managerProxy.modify();
}
}do something before method
*******modify()方法被调用
do something after method三、示例运行原理分析
现在将上面的例子运行机制分析一下，按照客户端main方法执行流程进行分析。
1、Proxy类源码
main方法中的前三行代码都是为创建代理对象作准备，没有什么可说的，重点在第四行创建代理对象。那么首先来看一下JDK动态代理核心类Proxy的主要源码：
package java.lang.reflect;
// 导入部分省略
public class Proxy implements java.io.Serializable {
private final static String proxyClassNamePrefix = "$Proxy";
private final static Class[] constructorParams = { InvocationHandler.class };
protected InvocationHandler h;
private Proxy() {
}
protected Proxy(InvocationHandler h) {
this.h = h;
}
public static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces) throws IllegalArgumentException {
// 省略一些代码
return proxyClass;
}
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
throws IllegalArgumentException {
if (h == null) {
throw new NullPointerException();
}
Class cl = getProxyClass(loader, interfaces);
try {
Constructor cons = cl.getConstructor(constructorParams);
return (Object) cons.newInstance(new Object[] { h });
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString());
} catch (IllegalAccessException e) {
throw new InternalError(e.toString());
} catch (InstantiationException e) {
throw new InternalError(e.toString());
} catch (InvocationTargetException e) {
throw new InternalError(e.toString());
}
}
public static boolean isProxyClass(Class<?> cl) { }
public static InvocationHandler getInvocationHandler(Object proxy) throws IllegalArgumentException { }
private static native Class defineClass0(ClassLoader loader, String name, byte[] b, int off, int len);
}2、获取代理对象
在客户端代码的第四我们调用了Proxy类的静态方法newProxyInstance来创建代理对象，那么就让我们进入newProxyInstance方法来看看程序究竟做了哪些操作：
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException {
if (h == null) {
throw new NullPointerException();
}
Class cl = getProxyClass(loader, interfaces);
try {
Constructor cons = cl.getConstructor(constructorParams);
return (Object) cons.newInstance(new Object[] { h });
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString());
} catch (IllegalAccessException e) {
throw new InternalError(e.toString());
} catch (InstantiationException e) {
throw new InternalError(e.toString());
} catch (InvocationTargetException e) {
throw new InternalError(e.toString());
}
}由newProxyInstance方法的源码可以看到该方法在被调用后主要做了以下几件事：
A、创建动态代理类
首先根据方法被调用时传进来的参数（类加载器loader和业务类实现的所有接口组成的数组interfaces）去调用getProxyClass(loader, interfaces)方法，该方法用于创建代理类$Proxy0，也就是动态生成$Proxy0类的Class对象，认真分析getProxyClass方法的实现源码后可以发现该方法创建的$Proxy0类实现了参数interfaces数组中的所有接口并继承了Proxy类。
Class cl = getProxyClass(loader, interfaces);其实在getProxyClass方法中调用了sun.misc.ProxyGenerator.generateProxyClass方法来完成生成字节码的动作，该方法可以在运行时产生一个描述代理类的字节码byte[]数组。如果我们想看一下这个方法在运行时产生的代理类是什么样子，我们需要在main方法中加入一条代码：
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");加入上面这句代码后，在前面的示例中会创建一个名为“$Proxy0.class”的代码类Class文件，反编译后类的代码如下（其它动态代理类类似）：
public final class $Proxy0 extends Proxy implements Manager {
private static Method m1;
private static Method m0;
private static Method m3;
private static Method m2;
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals",new Class[] { Class.forName("java.lang.Object") });
m0 = Class.forName("java.lang.Object").getMethod("hashCode",new Class[0]);
m3 = Class.forName("com.ml.test.Manager").getMethod("modify",new Class[0]);
m2 = Class.forName("java.lang.Object").getMethod("toString",new Class[0]);
} catch (NoSuchMethodException nosuchmethodexception) {
throw new NoSuchMethodError(nosuchmethodexception.getMessage());
} catch (ClassNotFoundException classnotfoundexception) {
throw new NoClassDefFoundError(classnotfoundexception.getMessage());
}
}
// 构造方法直接调用父类的构造方法，将invocationhandler传入，Proxy接受后存入实例变量h中
public $Proxy0(InvocationHandler invocationhandler) {
super(invocationhandler);
}
public final boolean equals(Object obj) {
try {
return ((Boolean) super.h.invoke(this, m1, new Object[] { obj })).booleanValue();
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
public final int hashCode() {
try {
return ((Integer) super.h.invoke(this, m0, null)).intValue();
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
public final void modify() {
try {
super.h.invoke(this, m3, null);
return;
} catch (Error e) {
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
public final String toString() {
try {
return (String) super.h.invoke(this, m2, null);
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
}B、获取代理类构造方法
在获取创建动态代理类后，程序就通过Java反射机制获取代理类$Proxy0类的构造方法：
Constructor cons = cl.getConstructor(constructorParams);
其中getConstructor方法的参数constructorParams定义在Proxy类的变量声明区域：
private final static Class[] constructorParams = { InvocationHandler.class };由此可见getConstructor方法获取的构造方法只有一个类型为InvocationHandler的参数，其实也就是$Proxy0类中的：
public $Proxy0(InvocationHandler invocationhandler) {
super(invocationhandler);
}C、创建代理对象
代码在获取到代理类$Proxy0类的构造方法后随即以InvocationHandler为参数利用Java反射机制创建了该类的实例并返回，这样我们在客户端中就获得了代理对象的引用：
return (Object) cons.newInstance(new Object[] { h });接合$Proxy0类的构造方法的定义可以看出$Proxy0的构造方法中直接调用了父类的构造器并传入invocationhandler作为参数：
public $Proxy0(InvocationHandler invocationhandler) {
super(invocationhandler);
}由于其继承的是Proxy类，因此也就是调用了Proxy类的构造方法：
protected Proxy(InvocationHandler h) {
this.h = h;
}Proxy构造方法仅为实例变量h赋值，至此代理对象已经被建立出来，然后将该对象返回，我们得到该对象后将其强制转换为Manager类型（$Proxy0类实现了该接口，如果是我们业务类实现了多个接口，此处可以将代理对象转换为任意接口类型）。
3、业务代理
客户端代码执行完第四行后我们获得了代理对象并将其转为Manager类型，然后在第五行时我们调用了代理对象的业务方法，由于该代理对象实际是$Proxy0类的实例，因此此时进入的是$Proxy0类中的modify()方法：
public final void modify() {
try {
super.h.invoke(this, m3, null);
return;
} catch (Error e) {
} catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}由代码可见在代理对象的业务方法modify中调用的是父对象中InvocationHandler类型的实例变量h的invoke()方法并传入了三个参数：第一个是代理对象自身；第二个就是代理的方法对象；第三个为调用方法的参数，此处为null。
至此，程序进入到InvocationHandler的invoke()函数执行，也就我们实现的InvocationHandler中的invoke方法，也就完成了对目标方法的拦截。
扫一扫
23万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
