java 代理模式及动态代理机制深入分析

// 方法 1: 该方法用于获取指定代理对象所关联的调用处理器 
static InvocationHandler getInvocationHandler(Object proxy)  
// 方法 2：该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象 
static Class getProxyClass(ClassLoader loader, Class[] interfaces)  
// 方法 3：该方法用于判断指定类对象是否是一个动态代理类 
static boolean isProxyClass(Class cl)  
// 方法 4：该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例 
static Object newProxyInstance(ClassLoader loader, Class[] interfaces,  
  InvocationHandler h)  

// 该方法负责集中处理动态代理类上的所有方法调用。第一个参数既是代理类实例，第二个参数是被调用的方法对象 
// 第三个方法是调用参数。调用处理器根据这三个参数进行预处理或分派到委托类实例上发射执行 
Object invoke(Object proxy, Method method, Object[] args)  

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发 
// 其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用 
InvocationHandler handler = new InvocationHandlerImpl(..);  
// 通过 Proxy 为包括 Interface 接口在内的一组接口动态创建代理类的类对象 
Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface.class, ... });  
// 通过反射从生成的类对象获得构造函数对象 
Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class });  
// 通过构造函数对象创建动态代理类实例 
Interface Proxy = (Interface)constructor.newInstance(new Object[] { handler });  

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发 
InvocationHandler handler = new InvocationHandlerImpl(..);  
// 通过 Proxy 直接创建动态代理类实例 
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 内部从不直接调用构造函数，所以 private 类型意味着禁止任何调用 
private Proxy() {}  
// 由于 Proxy 内部从不直接调用构造函数，所以 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);  
  // 通过反射获取构造函数对象并生成代理类实例 
  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());  
  }  
}