Java动态代理模式

 

动态代理可以模拟实现一个接口指向一个未实现这个接口的类：

 

package pp.DynamicProxy;
/**
 * 用于指向存根对象（动态生成的class）。用于引用其它对象。相当于EJB里的EJBObject。
 * @author Administrator
 *
 */
public interface IPeople {
	public String  say(String msg);
}

 

 

package pp.DynamicProxy;
/**
 * 远程业务实现对象，相当于EJB里的sessionbean
 * @author Administrator
 *
 */
public class Man {
	/**
	 * 和IPeople中方法同名同参数
	 * @param msg
	 * @return
	 */
	public String  say(String msg){
		String s="I am Man, "+msg;
		System.out.println(s);
		return s;
	}
}

 

 

 

package pp.DynamicProxy;

/**
 * 动态代理辅助类，获取代理操作类。
 * @author Administrator
 *
 */
public class PeopleDynamicProxy{
	/**
	 * 根据类名加载类，并产生代理操作类
	 * @param className
	 * @return
	 * @throws ClassNotFoundException
	 * @throws InstantiationException
	 * @throws IllegalAccessException
	 */
	public static Handler getHandler(String className) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
		Class<?> c;
		Object o;
		c=Class.forName(className);
		o = (c.getClassLoader().loadClass(className)).newInstance();
		Handler h=new Handler(o);
		
		return h;
	}

}

 

 

package pp.DynamicProxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
 * 动态代理代理操作类，实现动态代理和代理业务实现。
 * @author Administrator
 *
 */
public class Handler implements InvocationHandler {
	private Object targetO;//要被调用的对象

	public Handler(Object o) {
		targetO = o;
	}

	/**
	 * 根据代理被调用的方法，找到真正要调用的另一个类的同名方法，并进行调用返回结果
	 * @return 调用真正的对象返回的结果
	 */
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		// System.out.println(proxy instanceof IPeople);
		// System.out.println(proxy);
		// System.out.println("method: " + method);
		String name = method.getName();
		Class<?>[] ptypes = method.getParameterTypes();
		// Class rtype=method.getReturnType();

		Class<?> targetClass = targetO.getClass();
		Method targetM = targetClass.getMethod(name, ptypes);
		// System.out.println("targetClass: " + targetClass);
		// System.out.println("targetM: " + targetM);
		return targetM.invoke(targetO, args);
	}

	/**
	 * 动态生成代理类,既是一个存根。
	 * @return 实现了给定接口的代理类
	 * @throws ClassNotFoundException 
	 */
	public Object getObjectHome(String interfaceName) throws ClassNotFoundException {
		Class<?>[] interfaces = new Class[] { Class.forName(interfaceName) };
		Object proxy = Proxy.newProxyInstance(
				PeopleDynamicProxy.class.getClassLoader(), interfaces, this);
//		System.out.println("proxy.getClass(): " + proxy.getClass());
//		System.out.println("proxy instanceof IPeople: "
//				+ (proxy instanceof IPeople));
		return proxy;
	}
}

 

 

package pp.DynamicProxy;

public class TestClient {
	public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
		IPeople p;
		Handler handler=PeopleDynamicProxy.getHandler("pp.DynamicProxy.Man");
		Object o= handler.getObjectHome("pp.DynamicProxy.IPeople");
		System.out.println(o);
		p=(IPeople)o;
		System.out.println(p.say("Hi."));
	}
}

 

 

 

输入：

 

pp.DynamicProxy.Man@61de33
I am Man, Hi.
I am Man, Hi.

 

其中输出结果的第一行你可能非常疑惑，刚刚我也非常惊讶：怎么会输出这个pp.DynamicProxy.Man类？我明明是传入的pp.DynamicProxy.IPeople。仔细分析后发现，原来这个输出只是个幻象。因为输出语句调用的是toString()方法得到的字符串。而当代理类的方法被调用是就会调用Handler 的invoke方法，经过我写的invoke方法处理后，toString()实际上调用的是pp.DynamicProxy.Man的toString()方法。所以看到了一个神奇的结果。就好像java真的可以出现一个接口指向一个未实现这个接口的类的情形，事实上这只是模拟实现，真正意义上是不可能的。当然这个模拟实现具有非凡的意义，因为可以真的这么用，没有什么副作用，甚至可以假装java支持这个特性。

 

 

 

参考：

http://it.chinawin.net/softwaredev/article-197fd.html