自己的理解：生成代理類的時候，根據傳的Invocationhandler引數  會在代理類的實現介面的方法裡面實現InvocationHandler的invoke（）方法，也就是呼叫InvocationHandler實現類的invoke方法，然後在InvocationHandler實現類的InvocationHandler方法里加入業務邏輯，而且中間在再通過invoke方法呼叫被代理類的方法

在客戶類（即以下程式碼的Client類），語句Manager managerProxy =

  (Manager) Proxy.newProxyInstance(managerImpl.getClass().getClassLoader(), managerImpl.getClass().getInterfaces(), securityHandler)；

  可以看到，Proxy（庫類）中的newProxyInstance方法被呼叫，該方法返回一個被代理物件的例項，然後向上轉型為其對應的介面。

  問題是該方法在返回之前已經做了什麼？我們看看其引數的第三個：securityHandler，它就是InvocationHandler介面實現類的一個例項：securityHandler。因為InvocationHandler介面中原本有個invoke的方法，所以其實現類當然需要實現這個方法，即其實現類（在此是BusinessHandler類）中有invoke方法，而如果invoke方法要被呼叫，只能通過BusinessHandler類物件來呼叫。

  而在下面的原始碼類$Proxy0 中，有三個地方已經用BusinessHandler類物件來呼叫invoke方法，他們分別在這些方法的程式碼中：public final boolean equals(Object obj) ；public final int hashCode() ；public final String toString()。也許你會有疑問，這個方法也沒有看到在哪裡被

$Proxy0 物件呼叫過，怎麼能執行invoke方法呢？但是請看$Proxy0中的static程式碼塊，這個模組是特殊的，因為當newProxyInstance建立$Proxy0 時，它就被初始化。而這個static模組中的getMethod方法載入了這個三個方法，因而它們裡面的程式碼（h.invoke())被執行。

  另外我們還可以看到，invoke方法中的第一個引數代表什麼。在原始碼中我們看到return ((Boolean) super.h.invoke(this, m1, new Object[] { obj })) .booleanValue(); 那麼this就是$Proxy0 物件。這裡需要注意的是，它並非是被代理物件（ManagerImpl）。其第二個引數傳遞的是$Proxy0 類中資料域，其型別是Method，是被封裝過的被代理物件（ManagerImpl）的方法。

  小結：invoke方法的呼叫過程，就是先新建其類物件（例項），然後把它傳入newProxyInstance方法中，在裡面解析並用它來呼叫invoke方法。

一.相關類及其方法:

Java.lang.reflect.Proxy類的newProxyInstance()，是用於建立動態代理類和例項的靜態方法.返回一個指定介面的代理類例項，該介面可以將方法呼叫指派到指定的呼叫處理程式。

java.lang.reflect.InvocationHandler介面中的invoke()，在代理例項上處理方法呼叫並返回結果。當與方法關聯的代理例項上呼叫方法時，將在呼叫處理程式上呼叫此方法。

二.探討的原始碼:

被代理物件的介面及實現類:

public interface Manager {
public void modify();
}

public class ManagerImpl implements Manager {
  public void modify() {
     System.out.println("*******modify()方法被呼叫");
  }
}

動態代理類:

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class BusinessHandler implements InvocationHandler {

private Object object = null;

public BusinessHandler(Object object) {
   this.object = object;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
    System.out.println("do something before method");
    Object ret = method.invoke(this.object, args);
    System.out.println("do something after method");
    return ret;

   ｝
}

客戶端類:
import java.lang.reflect.Proxy;

public class Client {

public static void main(String[] args) {
   // 元物件(被代理物件)
   ManagerImpl managerImpl = new ManagerImpl();

   // 業務代理類
   BusinessHandler securityHandler = new BusinessHandler(managerImpl);

   // 獲得代理類($Proxy0 extends Proxy implements Manager)的例項.
   Manager managerProxy =

  (Manager) Proxy.newProxyInstance(managerImpl.getClass().getClassLoader(), managerImpl.getClass()
     .getInterfaces(), securityHandler);

   managerProxy.modify();
  }
}

三.執行結果:
do something before method
*******modify()方法被呼叫
do something after method

四.機制分析:

Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)做了以下幾件事.
(1)根據引數loader和interfaces呼叫方法 getProxyClass(loader, interfaces)建立代理類$Proxy.$Proxy0類 實現了interfaces的介面,並繼承了Proxy類.
(2)例項化$Proxy0並在構造方法中把BusinessHandler傳過去,接著$Proxy0呼叫父類Proxy的構造器,為h賦值,如下:
class Proxy{
   InvocationHandler h=null;
   protected Proxy(InvocationHandler h) {
    this.h = h;
   }
   ...
}



下面是本例的$Proxy0類的原始碼(好不容易才把它提出來):

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements Manager {

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("com.ml.test.Manager").getMethod("modify",
      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 modify() {
   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);
       }
 }
}

   接著把得到的$Proxy0例項強制轉換成Manager.當執行managerProxy.modify()方法時（managerProxy是Manager的一個已經向上轉型的例項）,就呼叫了$Proxy0類中的modify()方法.

   在modify方法中,呼叫父類Proxy中的h的invoke()方法.即InvocationHandler.invoke();