Java反射的应用：动态代理

代理设计模式的原理

使用一个代理将对象包装起来, 然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。

对于静态代理，特征是代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。同时，每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。最好可以通过一个代理类完成全部的代理功能。

动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。

动态代理使用场合：调试、远程方法调用。

动态代理相比于静态代理的优点：抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法。

动态代理相关API

Proxy：专门完成代理的操作类，是所有动态代理类的父类。通过此类为一个或多个接口动态地生成实现类。

提供用于创建动态代理类和动态代理对象的静态方法。

static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces)	创建一个动态代理类所对应的Class对象；
static Object newProxyInstance(         ClassLoader loader,         Class<?>[] interfaces,         InvocationHandler h)	直接创建一个动态代理对象； loader：类加载器 interfaces：得到被代理类实现的全部接口 h：得到InvocationHandler接口的实现类实例

动态代理步骤

1.创建一个实现接口InvocationHandler的类，它必须实现invoke方法，以完成代理的具体操作。

/**
 * @Param theProxy 代理类的对象
 * @Param method 要调用的方法
 * @Param params 方法调用时所需要的参数
 */
public Object invoke(Object theProxy, Method method, Object[] params) throws Throwable{
    try{
        Object retval = method.invoke(targetObj, params);
        // Print out the result
        System.out.println(retval);
        return retval;
    }catch (Exception exc){
    }
}

2.创建被代理的类以及接口

 3.通过Proxy的静态方法newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) 创建一个Subject接口代理。

RealSubject target = new RealSubject();
// Create a proxy to wrap the original implementation
DebugProxy proxy = new DebugProxy(target);
// Get a reference to the proxy through the Subject interface
Subject sub = (Subject) Proxy.newProxyInstance(Subject.class.getClassLoader(),new Class[] { Subject.class }, proxy);

4.通过 Subject代理调用RealSubject实现类的方法

String info = sub.say("zhangsan", 24);
System.out.println(info);

动态代理与AOP（Aspect Orient Programming)

前面介绍的Proxy和InvocationHandler，很难看出这种动态代理的优势，下面介绍一种更实用的动态代理机制。

改进后的说明：代码段1、代码段2、代码段3和深色代码段分离开了，但代码段1、2、3又和一个特定的方法A耦合了！最理想的效果是：代码块1、2、3既可以执行方法A，又无须在程序中以硬编码的方式直接调用深色代码的方法。

1.创建一个实现接口InvocationHandler的类

public class MyInvocationHandler implements InvocationHandler{
    // 需要被代理的对象
    private Object target;
    public void setTarget(Object target){
        this.target = target;
    }
    // 执行动态代理对象的所有方法时，都会被替换成执行如下的invoke方法
    public Object invoke(Object proxy, Method method, Object[] args) throws Exception{
        DogUtil du = new DogUtil();
        // 执行DogUtil对象中的method1。
        du.method1();
        // 以target作为主调来执行method方法
        Object result = method.invoke(target , args);
        // 执行DogUtil对象中的method2。
        du.method2();
        return result;
    }
}
public class DogUtil{
    public void method1(){
        System.out.println("=====模拟通用方法一=====");
    }
    public void method2(){
        System.out.println("=====模拟通用方法二=====");
    }
}

2.创建被代理的类以及接口

public interface Dog{
    void info();
    void run();
}
public class HuntingDog implements Dog{
    public void info(){
        System.out.println("一只猎狗");
    }
    public void run(){
        System.out.println("可以奔跑");
    }
}

3.为指定target生成动态代理对象。

public class MyProxyFactory{
    // 为指定target生成动态代理对象
    public static Object getProxy(Object target) throws Exception{
        // 创建一个MyInvokationHandler对象
        MyInvokationHandler handler = new MyInvokationHandler();
        // 为MyInvokationHandler设置target对象
        handler.setTarget(target);
        // 创建、并返回一个动态代理对象
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces() , handler);
    }
}

4.通过代理调用实现类的方法

public class Test{
    public static void main(String[] args) throws Exception{
        // 创建一个原始的HuntingDog对象，作为target
        Dog target = new HuntingDog();
        // 以指定的target来创建动态代理
        Dog dog = (Dog)MyProxyFactory.getProxy(target);
        dog.info();
        dog.run();
    }
}

使用Proxy生成一个动态代理时，往往并不会凭空产生一个动态代理，这样没有太大的意义。通常都是为指定的目标对象生成动态代理。

这种动态代理在AOP中被称为AOP代理，AOP代理可代替目标对象，AOP代理包含了目标对象的全部方法。但AOP代理中的方法与目标对象的方法存在差异：AOP代理里的方法可以在执行目标方法之前、之后插入一些通用处理。