java代理模式及動態(tài)代理機制深入分析

// 方法 1: 該方法用于獲取指定代理對象所關聯(lián)的調用處理器 
 
static InvocationHandler getInvocationHandler(Object proxy)  
 
// 方法 2：該方法用于獲取關聯(lián)于指定類裝載器和一組接口的動態(tài)代理類的類對象 
 
static Class getProxyClass(ClassLoader loader, Class[] interfaces)  
 
// 方法 3：該方法用于判斷指定類對象是否是一個動態(tài)代理類 
 
static boolean isProxyClass(Class cl)  
 
// 方法 4：該方法用于為指定類裝載器、一組接口及調用處理器生成動態(tài)代理類實例 
 
static Object newProxyInstance(ClassLoader loader, Class[] interfaces,  
 
  InvocationHandler h)  

// 該方法負責集中處理動態(tài)代理類上的所有方法調用。第一個參數(shù)既是代理類實例，第二個參數(shù)是被調用的方法對象 
 
// 第三個方法是調用參數(shù)。調用處理器根據(jù)這三個參數(shù)進行預處理或分派到委托類實例上發(fā)射執(zhí)行 
 
Object invoke(Object proxy, Method method, Object[] args)  

// InvocationHandlerImpl 實現(xiàn)了 InvocationHandler 接口，并能實現(xiàn)方法調用從代理類到委托類的分派轉發(fā) 
 
// 其內部通常包含指向委托類實例的引用，用于真正執(zhí)行分派轉發(fā)過來的方法調用 
 
InvocationHandler handler = new InvocationHandlerImpl(..);  
 
 
// 通過 Proxy 為包括 Interface 接口在內的一組接口動態(tài)創(chuàng)建代理類的類對象 
 
Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface.class, ... });  
 
 
// 通過反射從生成的類對象獲得構造函數(shù)對象 
 
Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class });  
 
 
// 通過構造函數(shù)對象創(chuàng)建動態(tài)代理類實例 
 
Interface Proxy = (Interface)constructor.newInstance(new Object[] { handler });  

// InvocationHandlerImpl 實現(xiàn)了 InvocationHandler 接口，并能實現(xiàn)方法調用從代理類到委托類的分派轉發(fā) 
 
InvocationHandler handler = new InvocationHandlerImpl(..);  
 
// 通過 Proxy 直接創(chuàng)建動態(tài)代理類實例 
 
Interface proxy = (Interface)Proxy.newProxyInstance( classLoader,  
 
 new Class[] { Interface.class },  
 
 handler );  

public interface Subject 
 
{ 
 
public void request(); 
 
} 

public class RealSubject implements Subject 
 
{ 
 
public void request() 
 
{ 
 
System.out.println("From real subject!"); 
 
}} 

import java.lang.reflect.InvocationHandler; 
 
import java.lang.reflect.Method; 
 
public class DynamicSubject implements InvocationHandler 
 
{ 
 
private Object sub; 
 
public DynamicSubject(Object obj) 
 
{ 
 
this.sub = obj; 
 
} 
 
public Object invoke(Object proxy, Method method, Object[] args) 
 
throws Throwable 
 
{ 
 
System.out.println("before calling: " + method); 
 
method.invoke(sub, args);  
 
System.out.println(args == null);  
 
System.out.println("after calling: " + method); 
 
return null; 
 
} 

import java.lang.reflect.InvocationHandler; 
 
import java.lang.reflect.Proxy; 
 
public class Client 
 
{ 
 
public static void main(String[] args) 
 
{ 
 
RealSubject realSubject = new RealSubject(); 
 
InvocationHandler handler = new DynamicSubject(realSubject); 
 
Class<?> classType = handler.getClass(); 
 
// 下面的代碼一次性生成代理 
 
Subject subject = (Subject) Proxy.newProxyInstance(classType 
 
.getClassLoader(), realSubject.getClass().getInterfaces(), 
 
handler); 
 
subject.request(); 
 
System.out.println(subject.getClass()); 
 
} 
 
} 

// 由于 Proxy 內部從不直接調用構造函數(shù)，所以 private 類型意味著禁止任何調用 
 
private Proxy() {}  
 
 
// 由于 Proxy 內部從不直接調用構造函數(shù)，所以 protected 意味著只有子類可以調用 
 
protected Proxy(InvocationHandler h) {this.h = h;}  

public static Object newProxyInstance(ClassLoader loader,  
 
      Class<?>[] interfaces,  
 
      InvocationHandler h)  
 
      throws IllegalArgumentException {  
 
   
 
  // 檢查 h 不為空，否則拋異常 
 
  if (h == null) {  
 
    throw new NullPointerException();  
 
  }  
 
  // 獲得與制定類裝載器和一組接口相關的代理類類型對象 
 
  Class cl = getProxyClass(loader, interfaces);  
 
 
  // 通過反射獲取構造函數(shù)對象并生成代理類實例 
 
  try {  
 
    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());  
 
  }  
}