動態代理模式學習

   前面初始了靜態代理，如果有新的代理，那么就右要寫上一個代理類，將真實代理作為代理的屬性，考慮到java機制1.3支持 類反射機制，因此聰明的人民，就知道了，可以動態代理  ，下面是代碼試驗
      1:首先定義公共接口，為什么要定義工作接口呢，這個問題，后面再說
**
 *
 * @author sunshine
 *  動態代理機制試驗
 */
public interface DyNamicInterFace {
 /**
  *
 * @Function: DyNamicInterFace.java
 * @Description: 動態代理請求
 *
 * @throws Exception
 * @return：返回結果描述
 * @throws：異常描述
 *
 * @version: v1.0.0
 * @author: 浪子
 * @date: 2011-8-25 下午08:29:02
 *
 * Modification History:
 * Date         Author          Version            Description
 *---------------------------------------------------------*
 * 2011-8-25     浪子           v1.0.0               修改原因
  */
 public void dyNamicRequest() throws Exception;
 
    public void dyNamicRequest(String name) throws Exception;
   
    public void dyNamicRequest(String name,int i) throws Exception;
}

 2:java動態代理，要用到java.lang.reflect.Method;java.lang.reflect.Proxy;  類，要實現動態必須實現java.lang.reflect.InvocationHandler（是代理實例的調用處理程序 實現的接口。）的接口 InvocationHandler接口中的invok方法，Proxy會執行這個要看jdk源碼 容積Constructor 構造器會構造 InvocationHandler h的實例，這就是為什么要實現InvocationHandler  接口
invok  方法第二個參數Method 是代理實現類的方法對象，第三個Method要調用的方法里面參數的值
實現動態代理，可以實現自己的接口，但是要動態代理必須要實現InvocationHandler    接口
         2：動態代理類 實現   InvocationHandler  接口
**
 * @author sunshine
 * 動態代理的動態實現類
 */
public class DyNamicInterFaceImpl implements DyNamicInterFace,InvocationHandler {
   public void dyNamicRequest(String name, int i) throws Exception {
  // TODO Auto-generated method stub 
 }
 public void dyNamicRequest() throws Exception {
  // TODO Auto-generated method stub
    System.out.println("aaaaa ");
 }
 public void dyNamicRequest(String name) throws Exception {
  // TODO Auto-generated method stub
    System.out.println("bbbb ");
 }
 private Object proxyObject;      //定義一個 Object  ，這樣在初始化的時候，或者其他方式，進行向上轉型成Object，
   public DyNamicInterFaceImpl()
   {
   
   }
   public DyNamicInterFaceImpl(Object proxyObject)
   {
    this.proxyObject=proxyObject;
   }
 public Object invoke(Object proxy, Method method, Object[] aobj)
   throws Throwable {
 
  System.out.println("開始調用 ");
 
  System.out.println("調用的MethodName="+method.getName());
 // System.out.println("調用的對象ObjectAobj="+aobj.length);
  int i=0;
  while(aobj!=null&&aobj.length>0&&aobj.length>i)
  {
  
   System.out.println("調用的對象ObjectAobj參數="+aobj[i]);
   i++;
  }
  Object o=method.invoke(proxyObject, aobj);
 
  System.out.println("invokeObject="+o);
  return o;
 }
 
 
 //客戶端測試
 public static void main(String []args) throws Exception
 {
 
 
  BusinessObject realObject=new BusinessObject();  //需要代理的業務對象
  DyNamicInterFaceImpl  dyNamic=new DyNamicInterFaceImpl(realObject); //動態代理對象
     從上面兩行代碼，可以看出是動態代理dyNamic ，代理 realObject真實對象
  Class  c=Class.forName("test.pro.Pen");
  Object o=c.newInstance();
  System.out.println("ssssss="+o);
 
      //      System.out.println("aaa="+c.getName());
           
    // Proxy.newProxyInstance(c.getClassLoader(), new Class[]{c}, dyNamic);
//DyNamicInterFace
為什么要轉型為 DyNamicInterFace   接口呢，這樣就要求 業務對象要implements 公共接口，因為在newProxyInstance中 第1個參數（類加載classLoader），第2個參數(代理類要實現的接口類)，第三個參數，調用處理器，
  DyNamicInterFace dyNamicObjec=(DyNamicInterFace)Proxy.newProxyInstance(DyNamicInterFace.class.getClassLoader(),new Class[]{DyNamicInterFace.class}, dyNamic);    
  //DyNamicInterFace dyNamicObjec=(DyNamicInterFace)Proxy.newProxyInstance(realObject.getClass().getClassLoader(), realObject.getClass().getInterfaces(), dyNamic);   
  dyNamicObjec.dyNamicRequest();
     // o.dyNamicRequest();
  dyNamicObjec.dyNamicRequest("123");
   //  System.out.println("object="+o.getClass().getName());
  dyNamicObjec.dyNamicRequest("1234", 1);
 }
 測試結果:
testPen
ssssss=test.pro.Pen@affc70
開始調用
調用的MethodName=dyNamicRequest
BusinessObject
invokeObject=null
開始調用
調用的MethodName=dyNamicRequest
調用的對象ObjectAobj參數=123
BusinessObject===123
invokeObject=null
開始調用
調用的MethodName=dyNamicRequest
調用的對象ObjectAobj參數=1234
調用的對象ObjectAobj參數=1
BusinessObject==1234
BusinessObjectI==1
invokeObject=null