非完全原创,但也非完全转载,仅仅是学习笔记,不作他用...
代理模式的特征:代理类与委托类有同样的接口,代理类与委托类之间通常会存在关联关系,一个代理类对象与一个委托类对象关联,代理类对象本身并不真正实现服务,而是通过调用委托类对象的相关方法,来提供特定的服务。正是如此,代理类可以在调用委托类服务方法的前后运行一些其它逻辑,以增强委托类的功能。
按照代理的创建时期,代理类可以分为两种。:
静态代理:由程序员创建或特定工具自动生成源代码,再对其编译。在程序运行前,代理类的.class文件就已经存在了。
动态代理:在程序运行时,运用反射机制动态创建而成。
Proxy 提供用于创建动态代理类和实例的静态方法:
static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)
返回代理类的一个实例,返回后的代理类可以当作被代理类使用(二者实现了共同的接口,因此可以替代被代理使用)。
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方法执行流程进行分析。
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); }
在客户端代码的第四我们调用了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方法的源码可以看到该方法在被调用后主要做了以下几件事:
首先根据方法被调用时传进来的参数(类加载器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");
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); } } }
在获取创建动态代理类后,程序就通过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); }
代码在获取到代理类$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类实现了该接口,如果是我们业务类实现了多个接口,此处可以将代理对象转换为任意接口类型)。
客户端代码执行完第四行后我们获得了代理对象并将其转为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方法,也就完成了对目标方法的拦截。