为什么JDK代理需要用接口取接收(详解JDK代理底层机制)

首先写一个解答的JDK代理例子

目标对象及接口

代理工厂实现

测试类（注意只能用接口接收）

这是为什么要用接口接收呢？下面我们取进入代理工厂的Proxy.newProxyInstance（？，？，？）方法

可以通过下面的源码清楚的看到

1. public static Class<?> getProxyClass(ClassLoader loader,   
2.                                          Class<?>... interfaces)  
3.     throws IllegalArgumentException  
4.     {  
5.     // 如果目标类实现的接口数大于65535个则抛出异常（我XX，谁会写这么NB的代码啊？）  
6.     if (interfaces.length > 65535) {  
7.         throw new IllegalArgumentException("interface limit exceeded");  
8.     }  
9.   
10.     // 声明代理对象所代表的Class对象（有点拗口）  
11.     Class proxyClass = null;  
12.   
13.     String[] interfaceNames = new String[interfaces.length];  
14.   
15.     Set interfaceSet = new HashSet();   // for detecting duplicates  
16.   
17.     // 遍历目标类所实现的接口  
18.     for (int i = 0; i < interfaces.length; i++) {  
19.           
20.         // 拿到目标类实现的接口的名称  
21.         String interfaceName = interfaces[i].getName();  
22.         Class interfaceClass = null;  
23.         try {  
24.         // 加载目标类实现的接口到内存中  
25.         interfaceClass = Class.forName(interfaceName, false, loader);  
26.         } catch (ClassNotFoundException e) {  
27.         }  
28.         if (interfaceClass != interfaces[i]) {  
29.         throw new IllegalArgumentException(  
30.             interfaces[i] + " is not visible from class loader");  
31.         }  
32.   
33.         // 中间省略了一些无关紧要的代码 .......  
34.           
35.         // 把目标类实现的接口代表的Class对象放到Set中  
36.         interfaceSet.add(interfaceClass);  
37.   
38.         interfaceNames[i] = interfaceName;  
39.     }  
40.   
41.     // 把目标类实现的接口名称作为缓存（Map）中的key  
42.     Object key = Arrays.asList(interfaceNames);  
43.   
44.     Map cache;  
45.       
46.     synchronized (loaderToCache) {  
47.         // 从缓存中获取cache  
48.         cache = (Map) loaderToCache.get(loader);  
49.         if (cache == null) {  
50.         // 如果获取不到，则新建地个HashMap实例  
51.         cache = new HashMap();  
52.         // 把HashMap实例和当前加载器放到缓存中  
53.         loaderToCache.put(loader, cache);  
54.         }  
55.   
56.     }  
57.   
58.     synchronized (cache) {  
59.   
60.         do {  
61.         // 根据接口的名称从缓存中获取对象  
62.         Object value = cache.get(key);  
63.         if (value instanceof Reference) {  
64.             proxyClass = (Class) ((Reference) value).get();  
65.         }  
66.         if (proxyClass != null) {  
67.             // 如果代理对象的Class实例已经存在，则直接返回  
68.             return proxyClass;  
69.         } else if (value == pendingGenerationMarker) {  
70.             try {  
71.             cache.wait();  
72.             } catch (InterruptedException e) {  
73.             }  
74.             continue;  
75.         } else {  
76.             cache.put(key, pendingGenerationMarker);  
77.             break;  
78.         }  
79.         } while (true);  
80.     }  
81.   
82.     try {  
83.         // 中间省略了一些代码 .......  
84.           
85.         // 这里就是动态生成代理对象的最关键的地方  
86.         byte[] proxyClassFile = ProxyGenerator.generateProxyClass(  
87.             proxyName, interfaces);  
88.         try {  
89.             // 根据代理类的字节码生成代理类的实例  
90.             proxyClass = defineClass0(loader, proxyName,  
91.             proxyClassFile, 0, proxyClassFile.length);  
92.         } catch (ClassFormatError e) {  
93.             throw new IllegalArgumentException(e.toString());  
94.         }  
95.         }  
96.         // add to set of all generated proxy classes, for isProxyClass  
97.         proxyClasses.put(proxyClass, null);  
98.   
99.     }   
100.     // 中间省略了一些代码 .......  
101.       
102.     return proxyClass;  
103.     }  

     ---

     核心：代码的目的就是将目标对象的接口实现的字节码并存放再内存中，再根据字节码生成代理类的实现（实现了接口）

104. 下面看看生成字节码的地方
105. 

106. 创建对象的时候调用InvocationHandler的invoke方法生成实现接口的代理类即可，注意实现类是继$Proxy implemnts 所有接口，所以只能用接口去接收，而不能实现类（这才是真正的原因）

107.