JAVA 动态代理

    java中代理模式的作用是，为一个对象提供一种代理，以控制对这个对象的访问。即在客户端和目标对象之间起到中介的作用。

    比如，客户端要调用某个业务实现类的insert()方法，但在执行insert()方法之前需要进行一下权限验证，在执行insert()方法之后要记录日志，而权限验证和记录日志都只需调用一个公用方法就可以了，用不着修改所有的业务实现类中的业务代码。这时，可以为每个业务实现类设置一个代理，代理类必须与实际的实现类继承相同的接口，客户端在使用时调用代理类中的方法，这样，就可以将权限验证和记录日志的内容在代理类中实现，不需要更改业务代码了。这就是传说中的静态代理。

    静态代理的麻烦之处就在于必须为每个业务实现类分别设置代理，肯定有人觉得，与其这样还不如在业务实现类中直接Ctrl+C、Ctrl+V呢，于是乎，就出现了动态代理--Dynamic Proxy（瞎掰的啊，动态代理是怎么来的我也不知道）。

 

动态代理开始：

   

     在目前的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 没有任何直接的联系，在调用这个代理类时传过来哪个业务接口的实现对象，他就生成哪个对象的代理类。

package com.why.DynamicProxy;

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

	public void sayHello();
	
	public String sayHelloWithReturnValue();
}

 

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 的话，来了也同样欢迎。

 

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），以下是测试代码：

 

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

	}

}