代理是基本的设计模式之一,设计模式的关键就是封装修改,Java的动态代理可以动态的创建代理,
并动态的处理对所代理方法的调用。
package lu.typeinfo;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/*
* 动态代理:动态的创建代理,并且动态地处理对所代理方法的调用。
* 通过静态方法Procy.newProxyInstance()可以创建动态代理,
* 这个方法需要得到一个类加载器(通常可以从已经加载的对象中获取其加载器,然后传递给它),
* 一个你希望代理实现的接口类表(不是类或抽象类),以及InvocationHandler接口的一个实现。
* 动态代理可以将所有调用重定向到调用处理器,因此通常会向调用处理器的构造器传递给一个“实际”对象的引用,
* 从而使得调用处理器在执行其中介任务时,可以将请求转发。
* invoke()方法中传递进来了代理对象,以防你需要区分请求的来源。
* 然而,在invoke()内部,在代理上调用方法时需要格外当心,因为接口的调用将被重定向为代理的调用。*/
import static lu.utils.Print.*;
class DynamicProxyHandler implements InvocationHandler{
private Object proxied;
public DynamicProxyHandler(Object proxied){this.proxied=proxied;}
public Object invoke(Object proxy,Method method,Object[] args) throws Throwable{
print("****proxy: "+proxy.getClass()+",method: "+method+",args: "+args);
if(args!=null)
for(Object arg:args)
print(" "+arg);
return method.invoke(proxied, args);
}
}
public class SimpleDynamicProxy {
public static void consumer(Interface iface){
iface.doSomething();
iface.somethingElse("bonobo");
}
public static void main(String[] args){
RealObject real=new RealObject();
consumer(real);
Interface proxy=(Interface)Proxy.newProxyInstance(Interface.class.getClassLoader(),
new Class[]{Interface.class}, new DynamicProxyHandler(real));
consumer(proxy);
}
}
Output:
doSomething
somethingElse bonobo
****proxy: class lu.typeinfo.$Proxy0,method: public abstract void lu.typeinfo.Interface.doSomething(),args: null
doSomething
****proxy: class lu.typeinfo.$Proxy0,method: public abstract void lu.typeinfo.Interface.somethingElse(java.lang.String),args: [Ljava.lang.Object;@43fee2db
bonobo
somethingElse bonobo