利用反射生成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方法。

下面是测试效果