public Object invoke(Object proxy, Method method, Object[] args) throws Throwable 
  {
	method.invoke(obj, args);
	return null;
}

A method invocation on a proxy instance through one of its proxy interfaces will be dispatched to the invoke method of the instance's invocation handler, passing the proxy instance,a java.lang.reflect.Method object identifying the method that was invoked, and an array of type Object containing the arguments. 

//抽象角色（動(dòng)態(tài)代理只能代理接口） 
public interface Subject { 
   
  public void request(); 
} 

//真實(shí)角色：實(shí)現(xiàn)了Subject的request()方法 
public class RealSubject implements Subject{ 
   
  public void request(){ 
    System.out.println("From real subject."); 
  } 
} 

//實(shí)現(xiàn)了InvocationHandler 
public class DynamicSubject implements InvocationHandler 
{ 
  private Object obj;//這是動(dòng)態(tài)代理的好處，被封裝的對(duì)象是Object類型，接受任意類型的對(duì)象 
 
  public DynamicSubject() 
  { 
  } 
 
  public DynamicSubject(Object obj) 
  { 
    this.obj = obj; 
  } 
 
  //這個(gè)方法不是我們顯示的去調(diào)用 
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable 
  { 
    System.out.println("before calling " + method); 
 
    method.invoke(obj, args); 
 
    System.out.println("after calling " + method); 
 
    return null; 
  } 
 
} 

//客戶端：生成代理實(shí)例，并調(diào)用了request()方法 
public class Client { 
 
  public static void main(String[] args) throws Throwable{ 
    // TODO Auto-generated method stub 
 
    Subject rs=new RealSubject();//這里指定被代理類 
    InvocationHandler ds=new DynamicSubject(rs); 
    Class<?> cls=rs.getClass(); 
     
    //以下是一次性生成代理 
     
    Subject subject=(Subject) Proxy.newProxyInstance( 
        cls.getClassLoader(),cls.getInterfaces(), ds); 
     
    //這里可以通過(guò)運(yùn)行結(jié)果證明subject是Proxy的一個(gè)實(shí)例，這個(gè)實(shí)例實(shí)現(xiàn)了Subject接口 
    System.out.println(subject instanceof Proxy); 
     
    //這里可以看出subject的Class類是$Proxy0,這個(gè)$Proxy0類繼承了Proxy，實(shí)現(xiàn)了Subject接口 
    System.out.println("subject的Class類是："+subject.getClass().toString()); 
     
    System.out.print("subject中的屬性有："); 
     
    Field[] field=subject.getClass().getDeclaredFields(); 
    for(Field f:field){ 
      System.out.print(f.getName()+", "); 
    } 
     
    System.out.print("\n"+"subject中的方法有："); 
     
    Method[] method=subject.getClass().getDeclaredMethods(); 
     
    for(Method m:method){ 
      System.out.print(m.getName()+", "); 
    } 
     
    System.out.println("\n"+"subject的父類是："+subject.getClass().getSuperclass()); 
     
    System.out.print("\n"+"subject實(shí)現(xiàn)的接口是："); 
     
    Class<?>[] interfaces=subject.getClass().getInterfaces(); 
     
    for(Class<?> i:interfaces){ 
      System.out.print(i.getName()+", "); 
    } 
 
    System.out.println("\n\n"+"運(yùn)行結(jié)果為："); 
    subject.request(); 
  } 
} 

public static Object newProxyInstance(ClassLoader loader, 
    Class<?>[] interfaces, 
    InvocationHandler h) 
throws IllegalArgumentException 
{ 
  if (h == null) { 
    throw new NullPointerException(); 
  } 
 
  /* 
   * Look up or generate the designated proxy class. 
   */ 
  Class cl = getProxyClass(loader, interfaces); 
 
  /* 
   * Invoke its constructor with the designated invocation handler. 
   */ 
  try { 
      /* 
      * Proxy源碼開始有這樣的定義： 
      * private final static Class[] constructorParams = { InvocationHandler.class }; 
      * cons即是形參為InvocationHandler類型的構(gòu)造方法 
      */ 
    Constructor cons = cl.getConstructor(constructorParams); 
    return (Object) cons.newInstance(new Object[] { h }); 
  } catch (NoSuchMethodException e) { 
    throw new InternalError(e.toString()); 
  } catch (IllegalAccessException e) { 
    throw new InternalError(e.toString()); 
  } catch (InstantiationException e) { 
    throw new InternalError(e.toString()); 
  } catch (InvocationTargetException e) { 
    throw new InternalError(e.toString()); 
  } 
} 

class Proxy{ 
  InvocationHandler h=null; 
  protected Proxy(InvocationHandler h) { 
    this.h = h; 
  } 
  ... 
} 

public final class $Proxy0 extends Proxy implements Subject { 
  private static Method m1; 
  private static Method m0; 
  private static Method m3; 
  private static Method m2; 
 
  static { 
    try { 
      m1 = Class.forName("java.lang.Object").getMethod("equals", 
          new Class[] { Class.forName("java.lang.Object") }); 
 
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", 
          new Class[0]); 
 
      m3 = Class.forName("***.RealSubject").getMethod("request", 
          new Class[0]); 
 
      m2 = Class.forName("java.lang.Object").getMethod("toString", 
          new Class[0]); 
 
    } catch (NoSuchMethodException nosuchmethodexception) { 
      throw new NoSuchMethodError(nosuchmethodexception.getMessage()); 
    } catch (ClassNotFoundException classnotfoundexception) { 
      throw new NoClassDefFoundError(classnotfoundexception.getMessage()); 
    } 
  } //static 
 
  public $Proxy0(InvocationHandler invocationhandler) { 
    super(invocationhandler); 
  } 
 
  @Override 
  public final boolean equals(Object obj) { 
    try { 
      return ((Boolean) super.h.invoke(this, m1, new Object[] { obj })) .booleanValue(); 
    } catch (Throwable throwable) { 
      throw new UndeclaredThrowableException(throwable); 
    } 
  } 
 
  @Override 
  public final int hashCode() { 
    try { 
      return ((Integer) super.h.invoke(this, m0, null)).intValue(); 
    } catch (Throwable throwable) { 
      throw new UndeclaredThrowableException(throwable); 
    } 
  } 
 
  public final void request() { 
    try { 
      super.h.invoke(this, m3, null); 
      return; 
    } catch (Error e) { 
    } catch (Throwable throwable) { 
      throw new UndeclaredThrowableException(throwable); 
    } 
  } 
 
  @Override 
  public final String toString() { 
    try { 
      return (String) super.h.invoke(this, m2, null); 
    } catch (Throwable throwable) { 
      throw new UndeclaredThrowableException(throwable); 
    } 
  } 
}