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);

}

}