利用反射生成JDK动态代理
利用反射生成JDK动态代理
在Java的java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过使用这个类和接口可以生成JDK动态代理类和动态代理对象
1.使用Proxy和InvocationHandler创建动态代理
Proxy提供了用于创建动态代理类和代理对象的静态方法，也是所有动态代理类的父亲。如果在程序中为一个或多个接口动态的生成实现类，就可以用proxy来创建动态代理类；如果需要为一或多个接口动态的创建实例，也可以使用Proxy来创建动态代理实例
Proxy提供了如下两个方法用于创建动态代理类和代理对象。
- static Class<?> getProxyClass(ClassLoader loader,Class<?>... interfaces):创建一个动态代理类的所对应的Class对象，该代理类将实现interface所制定的多个接口。loader参数指定生成动态代理类的类加载器。
- static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)：直接创建一个动态代理对象。该对象的实现类实现了interfaces指定的系列接口，执行代理对象的每个方法时都会被替换执行InvocationHandler对象的invoke方法。
实际上，第一种方法生成动态代理之后，如果程序需要通过该代理类来创建对象，依然需要传入一个InvocationHandler对象。也就是说，系统生成的每个代理对象都有一个与之关联的InvocationHandler对象。
创建动态代理对象时需要实现一个或多个接口定义的方法，而InvocationHandler对象的作用是—当执行动态代理对象里的方法时，实际上会替换成调用InvocationHandler对象的invoke方法。
程序中可以采用先生成一个动态代理类，然后通过动态代理类来创建代理对象的方式生成一个动态代理对象，代码如下
package com.gdut.test0516; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; class MyInvocationHandler implements InvocationHandler{ @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { return null; } } interface Foo{ } public class ProxyTest1 { public static void main(String[] args) throws Exception{ InvocationHandler handler = new MyInvocationHandler(); Class proxyClass = Proxy.getProxyClass(Foo.class.getClassLoader(),new Class[]{Foo.class}); //获取ProxyClass中带一个InvocationHandler参数的实例 Constructor ctor = proxyClass.getConstructor(new Class[]{InvocationHandler.class}); //调用ctor的newInstance方法创建实例 Foo f = (Foo)ctor.newInstance(new Object[]{handler}); } }
也可以简化成
package com.gdut.test0516; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; class MyInvocationHandler implements InvocationHandler{ @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { return null; } } interface Foo{ } public class ProxyTest1 { public static void main(String[] args) throws Exception{ Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),new Class[]{Foo.class},new MyInvocationHandler()); } }
下面程序示范了使用Proxy和InvocationHandler来生成动态代理对象
package com.gdut.test0516; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; interface Person{ void walk(); void sayHello(String name); } class MyInvocationHandler2 implements InvocationHandler{ /** * 执行动态代理对象的所有方法时，都会被替换成执行如下的invoke方法 * @param proxy 代表动态代理对象 * @param method 代表正在执行的方法 * @param args 代表调用目标方法时传入的实参 * @return * @throws Throwable */ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("-----正在执行的方法："+method); if(args != null){ System.out.println("下面执行该方法时传入的实参为："); for (Object val:args) { System.out.println(val); } }else{ System.out.println("调用该方法没有实参！"); } return null; } } public class ProxyTest2 { public static void main(String[] args) throws Exception { InvocationHandler handler = new MyInvocationHandler(); Person p = (Person)Proxy.newProxyInstance(Person.class.getClassLoader(),new Class[]{Person.class},new MyInvocationHandler2()); p.walk(); p.sayHello("孙悟空"); } }
2. 动态代理和AOP
开发实际应用的软件系统时，通常会存在相同代码段重复出现的情况
我们大多数会将深色代码定义成一个方法，然后让另外三段代码段直接调用该方法即可。
但采用这种方式来实现代码复用仍存在一个重要问题，虽然代码段1，代码段2，代码段三和深色代码分开了，但是又和一个特定的方法耦合了！最理想的状态是代码块1，代码块2，代码块3能执行深色代码块部分，又无需以硬代码的方式直接调用深色代码的方法，这时可以通过动态代理达到这种效果。
由于JDK动态代理只能为接口创建代理，下面先提供一个Dog接口
interface Dog{ void info(); void run(); }
实际情况通常时，软件系统会为该接口提供一个或多个实现类，例如：GunDog
public class GunDog implements Dog{ @Override public void info() { System.out.println("我是一只猎狗"); } @Override public void run() { System.out.println("我迅速奔跑"); } }
此处假设info()，run()两个方法分别代表代码段1，代码段2，那么要求：程序执行info()、run()方法时能调用某个通用方法，但又不想以硬代码方式调用该方法。下面提供一个DogUtil类，该类里包含两个通用方法。
public class DogUtil { public void method1(){ System.out.println("=====模拟第一个通用方法====="); } public void method2(){ System.out.println("=====模拟第一个通用方法====="); } }
借助动态代理，将method1(),method2()两个通用方法分别插入info(),run()方法中执行
这个程序的关键在于下面的MyInvocationHandler3类，该类是InvocationHandler实现类，该实现类的invoke()方法将会作为代理对象的方法实现
package com.gdut.test0516; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; public class MyInvocationHandler3 implements InvocationHandler { private Object target; public void setTarget(Object target){ this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Exception { DogUtil du = new DogUtil(); du.method1(); Object result = method.invoke(target,args); du.method2(); return result; } }
下面再提供MyProxyFactory类，该对象专为指定的target生成动态代理实例
public class MyProxyFactory { public static Object getProxy(Object target)throws Exception{ MyInvocationHandler3 handler3 = new MyInvocationHandler3(); handler3.setTarget(target); return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),handler3); } }
上面的动态代理工厂类提供了一个getProxy()方法，该方法为target对象生成一个动态代理对象，这个动态代理对象与target实现了相同接口，所以具有相同的public方法——从这个意义上看，动态代理对象可以当成target对象使用。当程序调用动态代理对象的指定方法时，实际上将变为执行MyInvocationHandler3对象的invoke方法。
下面是测试效果
