Java的动态代理

        代理是基本的设计模式之一，设计模式的关键就是封装修改，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