/** 
 * JDK 動態(tài)代理類分析(java.lang.reflect.Proxy使用) 
 * 
 * @author 張明學 
 * 
 */ 
public class ProxyStudy { 
   
  @SuppressWarnings("unchecked") 
  public static void main(String[] args) throws Exception { 
    // 動態(tài)代理類：通用指定類加載器，和接口產(chǎn)生一類 
    // getProxyClass()返回代理類的 java.lang.Class 對象，并向其提供類加載器和接口數(shù)組。 
    Class clazzProxy = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class); 
    System.out.println("動態(tài)產(chǎn)生的類名為：" + clazzProxy.getName()); 
    System.out.println("----------獲取動態(tài)產(chǎn)生的類的構造方法---------"); 
    Constructor[] constructors = clazzProxy.getConstructors(); 
    int i = 1; 
    for (Constructor constructor : constructors) { 
      System.out.println("第" + (i++) + "個構造方法名：" + constructor.getName()); 
      Class[] parameterClazz = constructor.getParameterTypes(); 
      System.out.println("第" + (i++) + "個構造方法參數(shù)：" + Arrays.asList(parameterClazz)); 
    } 
    System.out.println("----------獲取動態(tài)產(chǎn)生的類的普通方法---------"); 
    Method[] methods = clazzProxy.getDeclaredMethods(); 
    for (int j = 0; j < methods.length; j++) { 
      Method method = methods[j]; 
      System.out.println("第" + (j + 1) + "個普通方法名：" + method.getName()); 
      Class[] parameterClazz = method.getParameterTypes(); 
      System.out.println("第" + (j + 1) + "個普通方法參數(shù)：" + Arrays.asList(parameterClazz)); 
    } 
    System.out.println("---------獲取動態(tài)代理對象的構造方法---------"); 
    // 動態(tài)代理產(chǎn)生的對象的構造方法需要一個實現(xiàn)java.lang.reflect.InvocationHandler接口的對象，故不能通過 
    // clazzProxy.newInstance();產(chǎn)生一個對象，可以根據(jù)構造方法產(chǎn)生一個對象 
    // InvocationHandler 是代理實例的調(diào)用處理程序 實現(xiàn)的接口。 
    Constructor constructor = clazzProxy.getConstructor(InvocationHandler.class); 
 
    // 代理產(chǎn)生的對象 
    Collection proxyBuildCollection = (Collection) constructor 
        .newInstance(new InvocationHandler() { 
          // 為什么這里選擇ArrayList作為目標對象？ 
          // 因為這里的constructor是clazzProxy這個動態(tài)類的構造方法，clazzProxy是通過Proxy.getProxyClass()方法產(chǎn)生的， 
          // 該方法有兩個參數(shù)，一個是指定類加載器，一個是指定代理要實現(xiàn)的接口，這個接口我上面指定了Collection 
          // 而ArrayList實現(xiàn)了Collection接口，固可以為該動態(tài)類的目標對象 
          ArrayList target = new ArrayList();// 動態(tài)類的目標對象 
 
          public Object invoke(Object proxy, Method method, 
              Object[] args) throws Throwable { 
            System.out.println("執(zhí)行目標" + method.getName() + "方法之前：" 
                + System.currentTimeMillis()); 
            Object result = method.invoke(target, args);// 其實代理對象的方法調(diào)用還是目標對象的方法 
            System.out.println("執(zhí)行目標" + method.getName() + "方法之后：" 
                + System.currentTimeMillis()); 
            return result; 
          } 
 
        }); 
    proxyBuildCollection.clear(); 
    proxyBuildCollection.add("abc"); 
    proxyBuildCollection.add("dbc"); 
    System.out.println(proxyBuildCollection.size()); 
    System.out.println(proxyBuildCollection.getClass().getName()); 
     
    /** 
     * 動態(tài)代理：總結如下： 
     * 1，通過Proxy.getProxyClass(classLoader,interface)方法產(chǎn)生一個動態(tài)類的class字節(jié)碼(clazz) 
     *  該getProxyClass()方法有兩個參數(shù)：一個是指定該動態(tài)類的類加載器，一個是該動態(tài)類的要實現(xiàn)的接口（從這里可以看現(xiàn)JDK的動態(tài)代理必須要實現(xiàn)一個接口） 
     *   
     * 2，通過第一步的獲取的clazz對象可以獲取它的構造方法constructor，那么就可以通用constructor的newInstance()方法構造出一個動態(tài)實體對象 
     *  但constructor的newInstance()方法需要指定一個實現(xiàn)了InvocationHandler接口的類handler，在該類中需要一個目標對象A和實現(xiàn)invoke方法 
     *  目標對象A要求能對第一步中的接口的實現(xiàn)，因為在invoke方法中將會去調(diào)用A中的方法并返回結果。 
     *  過程如下：調(diào)用動態(tài)代理對象ProxyObject的x方法 ————> 進入構造方法傳進的handler的invoke方法 ————> invoke方法調(diào)用handler中的target對象 
     *      的x方法（所以要求target必須要實現(xiàn)構造動態(tài)代理類時指定的接口）并返回它的返回值。（其實如果我們代理P類，那么target就可以選中P類，只是要求P必需實現(xiàn)一個接口） 
     *   
     *  那么上述中x方法有哪些呢？除了從Object繼承過來的方法中除toString,hashCode,equals外的方法不交給handler外，其它的方法全部交給handler處理 
     *  如上面proxyBuildCollection.getClass().getName()就沒有調(diào)用handler的getClass方法，而是調(diào)用自己的 
     *   
     * 3，在handler的invoke方法中return method.invoke(target,args)就是將方法交給target去完成。那么在這個方法執(zhí)行之前，之后，異常時我們都可以做一些操作， 
     *  并且可以在執(zhí)行之前檢查方法的參數(shù)args，執(zhí)行之后檢查方法的結果 
     */ 
    System.out.println("-------------------下面的寫法更簡便--------------------"); 
     
    // proxyBuildColl是對ArrayList進行代理 
    Collection proxyBuildCollection2 = (Collection) Proxy.newProxyInstance( 
        Collection.class.getClassLoader(),// 指定類加載器 
        new Class[] { Collection.class },// 指定目標對象實現(xiàn)的接口 
        // 指定handler 
        new InvocationHandler() { 
          ArrayList target = new ArrayList(); 
 
          public Object invoke(Object proxy, Method method, 
              Object[] args) throws Throwable { 
            System.out.println(method.getName() + "執(zhí)行之前..."); 
            if (null != args) { 
              System.out.println("方法的參數(shù)：" + Arrays.asList(args)); 
            } else { 
              System.out.println("方法的參數(shù)：" + null); 
            } 
            Object result = method.invoke(target, args); 
            System.out.println(method.getName() + "執(zhí)行之后..."); 
            return result; 
          } 
        }); 
    proxyBuildCollection2.add("abc"); 
    proxyBuildCollection2.size(); 
    proxyBuildCollection2.clear(); 
    proxyBuildCollection2.getClass().getName(); 
     
    System.out.println("-------------------對JDK動態(tài)代理的重構--------------------"); 
    Set proxySet = (Set) buildProxy(new HashSet(), new MyAdvice()); 
    proxySet.add("abc"); 
    proxySet.size(); 
  } 
  /** 
   * 構造一個目標對象的代理對象 
   * 
   * @param target 
   *      目標對象（需要實現(xiàn)某個接口） 
   * @return 
   */ 
  public static Object buildProxy(final Object target,final AdviceInter advice) { 
    Object proxyObject = Proxy.newProxyInstance( 
        target.getClass().getClassLoader(),// 指定類加載器 
        target.getClass().getInterfaces(), // 指定目標對象實現(xiàn)的接口 
        // handler 
        new InvocationHandler() { 
           
          public Object invoke(Object proxy, Method method, 
              Object[] args) throws Throwable { 
            advice.beforeMethod(target, method, args); 
            Object result = method.invoke(target, args); 
            advice.afterMethod(target, method, args); 
            return result; 
          } 
        }); 
    return proxyObject; 
  } 
   
} 
 

/** 
 * 代理中執(zhí)行目標方法之前之后的操作的一個實例 
 * 
 * @author 張明學 
 * 
 */ 
public class MyAdvice implements AdviceInter { 
 
  public void afterMethod(Object target, Method method, Object[] args) { 
    System.out.println("目標對象為：" + target.getClass().getName()); 
    System.out.println(method.getName() + "執(zhí)行完畢！"); 
  } 
 
  public void beforeMethod(Object target, Method method, Object[] args) { 
    System.out.println(method.getName() + "開始執(zhí)行"); 
    if (null != args) { 
      System.out.println("參數(shù)為：" + Arrays.asList(args)); 
    } else { 
      System.out.println("參數(shù)為：" + null); 
    } 
  } 
} 

/** 
 * 代理中執(zhí)行目標方法之前之后的操作 
 * 
 * @author 張明學 
 * 
 */ 
public interface AdviceInter { 
  /** 
   * 目標方法執(zhí)行之前 
   * 
   */ 
  public void beforeMethod(Object target, Method method, Object[] args); 
 
  /** 
   * 目標方法執(zhí)行之后 
   * 
   * @param target 
   *      目標對象 
   * @param method 
   *      方法 
   * @param args 
   *      參數(shù) 
   */ 
  public void afterMethod(Object target, Method method, Object[] args); 
}