动态代理可以模拟实现一个接口指向一个未实现这个接口的类:
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