1. package test;
   
2. 
   
3. import java.lang.reflect.InvocationHandler;
   
4. import java.lang.reflect.Method;
   
5. import java.lang.reflect.Proxy;
   
6. 
   
7. /**
   
8. * @author Xing,Ming
   
9. * @version 2013年12月27日 下午4:52:08
   
10. */
    
11. public class Client {
    
12.         public static void main(String[] args) {
    
13.                
    
14.                 RealSubject realSubject = new RealSubject();
    
15.                
    
16.                 InvocationHandler handler = new DynamicSubject(realSubject);
    
17.                
    
18.                 Class<?> classType = handler.getClass();
    
19.                
    
20.                 /**
    
21.                  * 这行代码返回的到底是个什么？就是Subject类型？还是强制转换了？
    
22.                  * 为什么执行pro.request();
    
23.                  * 之后会调用DynamicSubject类里面的那个method.invoke方法
    
24.                  */
    
25.                 Subject pro = (Subject) Proxy.newProxyInstance(classType
    
26.                                 .getClassLoader(), realSubject.getClass().getInterfaces(),
    
27.                                 handler);
    
28.                
    
29.                 pro.request();
    
30.         }
    
31. }
    
32. 
    
33. interface Subject {
    
34.         public void request();
    
35. }
    
36. 
    
37. class RealSubject implements Subject {
    
38.         public void request() {
    
39.                 System.out.println("From real subject");
    
40.         }
    
41. }
    
42. 
    
43. class DynamicSubject implements InvocationHandler {
    
44.         private Object sub;
    
45. 
    
46.         public DynamicSubject(Object sub) {
    
47.                 this.sub = sub;
    
48.         }
    
49. 
    
50.         @Override
    
51.         public Object invoke(Object proxy, Method method, Object[] args)
    
52.                         throws Throwable {
    
53.                 // TODO Auto-generated method stub
    
54.                 method.invoke(sub, args);
    
55.                 return null;
    
56.         }
    
57. }
    

复制代码

为什么会调用invoke方法，这个方法到底是做什么的啊？

动态代理机制：其实动态代理机制最核心的就是InvocationHandler这个接口(调用处理器)。InvocationHandler是代理实例的调用处理程序实现的接口。每个代理实例都有 一个关联的调用处理程序。对代理实例调用方法时，将对方法调用进行编码并将其指派到它的调用处理程序的invoke方法。
method.invoke(sub, args);的sub对象映射了new DynamicSubject(realSubject);的realSubject，而该对象是RealSubject的一个实例，并实现了interface Subject,
Subject pro = (Subject) Proxy.newProxyInstance(classType
                                .getClassLoader(), realSubject.getClass().getInterfaces(),
                                handler);
就是创建一个代理类的实例pro,并加载关联的调用处理器类,关联的目标接口和目标类。
pro.request();
就是调用关联目标类的request()方法，即用代理实例对象pro调用目标类RealSubject中的request().

InvocationHandler 是一个接口。接口就是一种规则。
newProxyInstance 的参数中有InvocationHandler 类型的参数。说明这个方法要实现这种规则。
这个接口只有一个方法  invoke   
看invoke的参数。。三个参数     代理实例   方法    object[ ]
分别对应     你代理对象代理的是谁         你代理的谁要执行的方法            要执行方法的参数。
可以看出  这个方法  是代理实现的核心。   代理时要替别人做事情。  
invoke方法正好明确了   你要替谁做    做什么     怎样做。。