JAVA 动态代理

在目前的Java开发包中包含了对动态代理的支持，但是其实现只支持对接口的的实现，即只能对实现了接口的类进行动态代理，对于没有实现任何借口的类不能进行动态代理。其实现主要通过是java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。



Proxy 类主要用来获取动态代理对象，即动态代理类，主要包括：

    Protected Proxy(InvocationHandler h)：构造函数，估计用于给内部的h赋值。
Static Class getProxyClass (ClassLoader loader, Class[] interfaces)：获得一个代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。
Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)：返回代理类的一个实例，返回后的代理类可以当作被代理类使用(可使用被代理类的在Subject接口中声明过的方法)。

InvocationHandler 接口用来约束调用者实现：

    该接口中仅定义了一个方法 Object: invoke(Object obj,Method method,Object[] args)。在实际使用时，第一个参数obj一般指代理类，method是被代理的方法，args为该方法的参数数组。这个抽象方法在代理类中动态实现。



    所谓Dynamic Proxy是这样一种class:它是在运行时生成的class，在生成它时你必须提供一组interface给它，然后该class就宣称它实现了这些interface。你当然可以把该class的实例当作这些interface中的任何一个来用。 当然啦，这个Dynamic Proxy其实就是一个Proxy，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。--这两段摘自网络。



    我做了个小例子，HelloWorld是业务接口，HelloWorldImpl是业务接口的实现类，HelloWorldHandler是动态代理类。这个动态代理类与 HelloWorld 或者 HelloWorldImpl 或者 HelloKitty 没有任何直接的联系，在调用这个代理类时传过来哪个业务接口的实现对象，他就生成哪个对象的代理类。

Java代码
package com.why.DynamicProxy;  
 
/** 
* 业务接口 
* @author why 
* 
*/ 
public interface HelloWorld {  
 
    public void sayHello();  
      
    public String sayHelloWithReturnValue();  
} 

package com.why.DynamicProxy;

/**
* 业务接口
* @author why
*
*/
public interface HelloWorld {

public void sayHello();

public String sayHelloWithReturnValue();
}


Java代码
package com.why.DynamicProxy;  
 
/** 
* 业务接口实现类 
* @author why 
* 
*/ 
public class HelloWorldImpl implements HelloWorld {  
 
    public void sayHello() {  
        System.out.println("执行了 sayHello()");  
 
    }  
 
    public String sayHelloWithReturnValue() {  
        String str = "HelloWorld!";  
        System.out.println("执行了 sayHelloWithReturnValue()");  
        return str;  
    }  
} 

package com.why.DynamicProxy;

/**
* 业务接口实现类
* @author why
*
*/
public class HelloWorldImpl implements HelloWorld {

public void sayHello() {
System.out.println("执行了 sayHello()");

}

public String sayHelloWithReturnValue() {
String str = "HelloWorld!";
System.out.println("执行了 sayHelloWithReturnValue()");
return str;
}
}
   

    假如业务接口和实现类有很多，我不能为每一个目标对象都设置一个代理，于是写了一个对每一个目标对象都使用的代理类。这个类的名字可能跟上面那两个家伙比较像，但跟他们真的没有什么亲戚关系，如果有一个类是 HelloKitty 的话，来了也同样欢迎。



Java代码
package com.why.DynamicProxy;  
import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Method;  
import java.lang.reflect.Proxy;  
 
/** 
* 动态代理类 
* @author why 
* 
*/ 
public class HelloWorldHandler implements InvocationHandler {  
 
    //要代理的原始对象  
    private Object objOriginal;  
      
    /** 
    * 构造函数 (test1 使用) 
    * @param obj 要代理的原始对象 
    */ 
    public HelloWorldHandler(Object obj) {  
        this.objOriginal = obj ;  
    }  
      
    /** 
     * 无参数构造函数 (test2 使用) 
     * 
     */ 
    public HelloWorldHandler() {  
          
    }  
      
    /** 
     *  返回此代理对象的实例 (test2 使用) 
     * @param obj 要代理的原始对象 
     * @return 
     */ 
    public Object newProxy(Object obj) {  
        this.objOriginal = obj ;  
        return Proxy.newProxyInstance(objOriginal.getClass().getClassLoader(), objOriginal.getClass().getInterfaces(), this);  
    }  
 
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
        Object result;  
        //方法调用之前  
        doBefore();  
 
        //调用原始对象的方法  
        result = method.invoke(this.objOriginal ,args);  
 
        //方法调用之后  
        doAfter();  
        return result;  
    }  
      
    private void doBefore() {  
        System.out.println("before method invoke!");  
    }  
 
    private void doAfter() {  
        System.out.println("after method invoke!");  
    }  
 
} 

package com.why.DynamicProxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
* 动态代理类
* @author why
*
*/
public class HelloWorldHandler implements InvocationHandler {

//要代理的原始对象
private Object objOriginal;

/**
* 构造函数 (test1 使用)
* @param obj 要代理的原始对象
*/
public HelloWorldHandler(Object obj) {
this.objOriginal = obj ;
}

/**
* 无参数构造函数 (test2 使用)
*
*/
public HelloWorldHandler() {

}

/**
*  返回此代理对象的实例 (test2 使用)
* @param obj 要代理的原始对象
* @return
*/
public Object newProxy(Object obj) {
this.objOriginal = obj ;
return Proxy.newProxyInstance(objOriginal.getClass().getClassLoader(), objOriginal.getClass().getInterfaces(), this);
}

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result;
//方法调用之前
doBefore();

//调用原始对象的方法
result = method.invoke(this.objOriginal ,args);

//方法调用之后
doAfter();
return result;
}

private void doBefore() {
System.out.println("before method invoke!");
}

private void doAfter() {
System.out.println("after method invoke!");
}

}


    我写了两种获取动态代理对象实例的方法，一种实在测试类中创建（test1），一种是通过代理类返回（test2），以下是测试代码：



Java代码
package com.why.DynamicProxy;  
 
import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Proxy;  
 
public class Test {  
 
    /** 
     * JAVA 动态代理 
     * @param args 
     */ 
    public static void main(String[] args) {  
          
        /* 
         * test1:在测试类中创建动态代理对象 
         *  
         * 首先获取一个业务接口的实现对象； 
         * 获取一个InvocationHandler实现，此处是HelloWorldHandler对象； 
         * 创建动态代理对象； 
         * 通过动态代理对象调用sayHello()和sayHelloWithReturnValue()方法，此时会在原始对象HelloWorldImpl. sayHello()和sayHelloWithReturnValue()方法前后输出两句字符串。 
         */ 
        HelloWorld hw = new HelloWorldImpl();  
        InvocationHandler handler1 = new HelloWorldHandler(hw);  
        HelloWorld proxy1 = (HelloWorld) Proxy.newProxyInstance(hw.getClass().getClassLoader(),hw.getClass().getInterfaces(),handler1);  
        proxy1.sayHello();  
        String str1 = proxy1.sayHelloWithReturnValue();  
        System.out.println("str1 = " + str1);  
          
        System.out.println("\n---------------------------------\n");  
          
        /* 
         * test2:从代理类中获取动态代理对象 
         */ 
        HelloWorldHandler handler2 = new HelloWorldHandler();  
        HelloWorld proxy2 = (HelloWorld)handler2.newProxy(new HelloWorldImpl());  
        proxy2.sayHello();  
        String str2 = proxy2.sayHelloWithReturnValue();  
        System.out.println("str2 = " + str2);  
 
    }  
 
}