Class clazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
                System.out.println(clazzProxy1.getName());
上面的Proxy是什么意思，它是个类还是一个对象啊，如果是一个类获取字节码class不应该是类名.class么？
张老师在视频中用到proxy是随意找的一个类还是，这个类就是专门用在动态代理上的。如果是用在动态代理上的。它是怎么使用的呢？

是一个专门用于生成动态代理类的字节码的类，这个方法不是返回Proxy类的字节码，而是根据传人参数返回一个动态类的字节码，当然就不能用.class这种形式来获取字节码了

所谓Dynamic Proxy是这样一种class：
它是在运行时生成的class，在生成它时你必须提供一组interface给它，然后该class就宣称它实现了这些interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然啦，这个Dynamic Proxy其实就是一个Proxy，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。

看了之后，知道了一點

Proxy
Proxy 代理,提供1种代理的方式去访问对象,
相关类
java.lang.reflect.Proxy;

java.lang.reflect.InvocationHandler;
原理
Proxy 调用 vm,根据给定的接口,创建 1个 Class 对象(给 Class 类型 实现给定的接口)
创建 InvocationHandler 的实现类,添加 1个属性 符合上面 指定的接口类型,该属性是真正的想操作的对象,
在 invoke() 方法用,使用该对象来调用方法,而不是传入的对象,
然后创建 1个 InvocationHandler 实现类 的对象,
调用 Proxy 创建的 Class 对象,用代理构造函数,借助 上面 InvocationHandler 实现类 的 1个对象,创建 1个 接口类型的 代理对象,
该 代理对象 将代理了上面 InvocationHandler 实现类中用做数据的对象,
当调用这个 对象时,实际上是调用了 InvocationHandler 中的数据对象,
从而实现了代理----
代理实现
2种格式实现代理,分别使用了 Proxy 的2个不同方法,配合 InvocationHandler 实现,
* 前提:
实现 InvocateHandler 类:

                创建1个 InvocationHandler 实现类,其中包含1个属性是真正要操作的对象,提供1个构造函数,用于从外部传入该属性,



* Proxy.getProxyClass() 方式

        步骤:

                用 Proxy.getProxyClass() 创建 代理 Class 对象,

                然后创建 代理 Constructor,

                然后创建 代理 对象,

                这样 操作 代理对象时,实际是 InvocationHandler 对象 从操作其中的 属性 完成方法调用,

* Proxy.newProxyInstance() 方式

        步骤:
用 Proxy.newProxyInstance 直接创建 代理对象,
创建过程中,同样 需要 1个 InvocationHandler 类型的 对象,

*例子

1. package eric.j2se.reflect.proxy;
   
2. 
   
3. import java.lang.reflect.Constructor;
   
4. import java.lang.reflect.InvocationHandler;
   
5. import java.lang.reflect.InvocationTargetException;
   
6. import java.lang.reflect.Method;
   
7. import java.lang.reflect.Proxy;
   
8. import java.util.ArrayList;
   
9. import java.util.Arrays;
   
10. import java.util.List;
    
11. 
    
12. /**
    
13. * Proxy test
    
14. *
    
15. * @author eric
    
16. * @date 2011-2-24 下午06:05:09
    
17. */
    
18. public class ProxyTest {
    
19.         public static void main(String[] args) {
    
20.                 testProxyOne();
    
21.                 testProxyTwo();
    
22.         }
    
23. 
    
24.         /**
    
25.          * Proxy.getProxyClass() 方式,步骤: 1 创建 代理 Class 对象,2 然后创建 代理 Constructor,3 然后创建 代理对象,
    
26.          */
    
27.         @SuppressWarnings("unchecked")
    
28.         public static void testProxyOne() {
    
29.                 try {
    
30.                         // create a Class object,with Proxy.getProxyClass()
    
31.                         Class proxyClazz = Proxy.getProxyClass(List.class.getClassLoader(), List.class);
    
32.                         System.out.println(Proxy.isProxyClass(proxyClazz));
    
33. 
    
34.                         // 真正 要操作的 对象
    
35.                         List data = new ArrayList();
    
36.                         // create InvocationHandler instance
    
37.                         InvocationHandler ih = new MyInvocateHandler(data);
    
38. 
    
39.                         // 创建 构造函数,用 InvocationHandler 作为参数,可以用于创建 代理对象
    
40.                         Constructor cst = proxyClazz.getConstructor(InvocationHandler.class);
    
41.                         // 创建 代理对象
    
42.                         List<Integer> list = (List<Integer>) cst.newInstance(ih);
    
43.                         // 调用方法
    
44.                         list.add(1);
    
45.                         list.add(2);
    
46.                 } catch (SecurityException e) {
    
47.                         e.printStackTrace();
    
48.                 } catch (NoSuchMethodException e) {
    
49.                         e.printStackTrace();
    
50.                 } catch (IllegalArgumentException e) {
    
51.                         e.printStackTrace();
    
52.                 } catch (InstantiationException e) {
    
53.                         e.printStackTrace();
    
54.                 } catch (IllegalAccessException e) {
    
55.                         e.printStackTrace();
    
56.                 } catch (InvocationTargetException e) {
    
57.                         e.printStackTrace();
    
58.                 }
    
59.         }
    
60. 
    
61.         /**
    
62.          * Proxy.newProxyInstance 方式,直接创建 代理对象,
    
63.          */
    
64.         @SuppressWarnings("unchecked")
    
65.         public static void testProxyTwo() {
    
66.                 // 真正 要操作的 对象
    
67.                 List data = new ArrayList();
    
68.                 // 用 Proxy.newProxyInstance 直接创建 代理对象,
    
69.                 List<Integer> list = (List<Integer>) Proxy.newProxyInstance(List.class.getClassLoader(),
    
70.                                 new Class[] { List.class }, new MyInvocateHandler(data));
    
71.                 // 调用 代理对象
    
72.                 list.add(100);
    
73.                 list.add(200);
    
74.         }
    
75. 
    
76.         /**
    
77.          * 自定义 InvocationHandler 实现类,提供了传入 真正对象的 构造函数,
    
78.          *
    
79.          * @author eric
    
80.          * @date 2011-2-28 下午07:10:11
    
81.          */
    
82.         static class MyInvocateHandler implements InvocationHandler {
    
83.                 /**
    
84.                  * 该构造函数 可以设置 真正的 对象
    
85.                  *
    
86.                  * @param data 真正要操作的对象
    
87.                  */
    
88.                 public MyInvocateHandler(List<?> data) {
    
89.                         this.data = data;
    
90.                 }
    
91. 
    
92.                 // use this object to invoke method,not the one in arg list of invoke()
    
93.                 private List<?> data;
    
94. 
    
95.                 @Override
    
96.                 public Object invoke(Object obj, Method method, Object[] args) throws Throwable {
    
97.                         // before method invode
    
98.                         // 这里使用 自己创建的对象调用方法,而不是 参数中的,参数中的对象只相当于1个代理,
    
99.                         Object o = method.invoke(this.data, args);
    
100.                         System.out.println(method.getName() + "(),params:" + Arrays.asList(args));
     
101.                         // after method invode
     
102.                         return o;
     
103.                 }
     
104.         }
     
105. }
     

复制代码