请教各位同学，关于代理的知识。

代理其实就是一个中介，本来你想买电脑要去北京的联想总部，但现在你只需要通过你们县城的代理商就可以买到了，一句话，方便。这里我写一个死的代理，也就是一个没有扩展的代理，哪么代码的代理实现如下：
Collection c=(Collection)Proxy.newProxyInstance(
                                Collection.class.getClassLoader(),
                                new Class []{Collection.class},
                                new InvocationHandler()
                                {
                                        ArrayList<String> al=new ArrayList<String>();//目标
                                        @Override
                                        public Object invoke(Object proxy, Method method, Object [] args)throws Throwable
                                        {
                                                long start=System.currentTimeMillis();//系统功能
                                               
                                                Object retVal=method.invoke(al,args);//代理去调用目标的方法
                                               
                                                long end=System.currentTimeMillis();//系统功能
                                               
                                                System.out.println(end-start);
                                               
                                                return retVal;
                                        }
                                });
               
               
                c.add("abcd");
                c.add("absd");
                c.add("abdd");
                c.add("abfd");
                System.out.println(c);

楼上已经把概念讲的很清楚了,我就来个封装好的代理类吧,可能具体的代码能帮助你更好的理解什么是"动态代理类"

1. package ProxyClass;
   
2. 
   
3. import java.lang.reflect.InvocationHandler;
   
4. import java.lang.reflect.Method;
   
5. import java.lang.reflect.Proxy;
   
6. import java.util.ArrayList;
   
7. import java.util.Collection;
   
8. 
   
9. /*
   
10. * 代理类练习
    
11. * */
    
12. public class ProxyTest {
    
13. 
    
14.         public static void main(String[] args) {
    
15.                 // TODO Auto-generated method stub
    
16.                 pro pro = new clspro();
    
17.                 Test3Proxy T3P = new Test3Proxy();
    
18.                 ArrayList al = new ArrayList();
    
19.                 Collection coll = (Collection)T3P.proxy(al, pro);
    
20.                 //随便添加点东西试试我的代理类
    
21. coll.add(123);
    
22.                 coll.add(123);
    
23.                 coll.add(123);
    
24.                 coll.add(123);
    
25.                 coll.add(123);
    
26.                
    
27.         }
    
28. }
    
29. //一个封装好的代理类,直接往里传你自己想要的代理的类,增加的功能即可,前提是你的类必须实现pro接口
    
30. class Test3Proxy{
    
31.         public Object proxy(final Object targent,final pro pro){
    
32.                 Object tar = Proxy.newProxyInstance(
    
33.                                 targent.getClass().getClassLoader(),
    
34.                                 targent.getClass().getInterfaces(),
    
35.                                 new InvocationHandler() {
    
36.                                        
    
37.                                         @Override
    
38.                                         public Object invoke(Object proxy, Method method, Object[] args)
    
39.                                                         throws Throwable {
    
40.                                                 // TODO Auto-generated method stub
    
41.                                                 pro.before();
    
42.                                                 Object obj = method.invoke(targent, args);
    
43.                                                 pro.after();
    
44.                                                 return obj;
    
45.                                         }
    
46.                                 });
    
47.                 return tar;
    
48.         }
    
49. }
    
50. //接口,用于声明要添加的功能
    
51. interface pro{
    
52.         void before();
    
53.         void after();
    
54. }
    
55. //随便写一个实现pro接口的类,随便添加点功能
    
56. class clspro implements pro{
    
57.         long start;
    
58.         long end;
    
59.         @Override
    
60.         public void before() {
    
61.                 // TODO Auto-generated method stub
    
62.                 start = System.currentTimeMillis();
    
63.         }
    
64. 
    
65.         @Override
    
66.         public void after() {
    
67.                 // TODO Auto-generated method stub
    
68.                 end =System.currentTimeMillis();
    
69.                 System.out.println(end-start);
    
70.         }
    
71.         
    
72. }

复制代码

刚开始的时候，我也听晕了。

现在我是这么理解的：
所谓“动态代理类”的“动态”，是指代理类是动态生成的

1. 
   
2. //创建动态代理类(通过Proxy的静态方法getProxyClass)
   
3. public static void main(String[] args) {
   
4.   //获取Collection接口的代理类
   
5.   Class proxyClass = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
   
6.   System.out.println("class name : "+ proxyClass.getName());
   
7.   //对同一接口重复创建动态代理类，会返回先前已经创建好的代理类的类对象
   
8.   proxyClass = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
   
9.   System.out.println("class name : "+ proxyClass.getName());
   
10.   //获取Map接口的代理类
    
11.   Class proxyClass1 = Proxy.getProxyClass(Map.class.getClassLoader(), Map.class);
    
12.   System.out.println("class name : "+ proxyClass1.getName());
    
13.   
    
14.   //获取Comparator接口的代理类
    
15.   Class proxyClass2 = Proxy.getProxyClass(Comparator.class.getClassLoader(), Comparator.class);
    
16.   System.out.println("class name : "+ proxyClass2.getName());
    
17. }

复制代码

接下来是“动态代理类”中的“代理类”。上一步动态生成的代理类是要用来实现、调用被代理的接口(委托类)中的方法的。
这是通过实现InvocationHandler接口中的invoke()，来分派转发委托类的方法，并可在此增加原委托类中没有的方法。

1. 
   
2.         //创建动态代理类对象并调用委托类中的方法
   
3.         public static void main(String[] args) throws Exception {
   
4.                 //获取Collection接口的动态代理类
   
5.                 Class proxyClass = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
   
6.                 System.out.println("class name : "+ proxyClass.getName());
   
7.                
   
8.                 //通过反射机制获取动态代理类的构造方法
   
9.                 Constructor constructor = proxyClass.getConstructors()[0];
   
10.                
    
11.                 //通过构造方法创建动态代理类的实例
    
12.                 Collection proxy = (Collection)constructor.newInstance(
    
13.                         //InvocationHandler接口作为参数被传入
    
14.                         new InvocationHandler() {
    
15.                                 //因为这里是委托类是Collection接口，可用ArrayList()对象来代替
    
16.                                 ArrayList al = new ArrayList();
    
17.                                 Object obj = null;
    
18.                                 
    
19.                                 @Override
    
20.                                 public Object invoke(Object proxy, Method method, Object[] args) {
    
21.                                         System.out.println("委托类方法运行前……");
    
22.                                        
    
23.                                         //委托类的方法运行
    
24.                                         try {
    
25.                                                 System.out.println("正在运行"+ method.getName() +"()...");
    
26.                                                 obj = (Object) method.invoke(al, args);
    
27.                                         } catch (Exception e) {
    
28.                                                 e.printStackTrace();
    
29.                                         }
    
30.                                        
    
31.                                         System.out.println("委托类方法运行后。");
    
32.                                         return obj;
    
33.                                 }
    
34.                         });
    
35.                
    
36.                 //通过动态代理类对象来调用委托类的方法
    
37.                 System.out.println("proxy.toString() = "+ proxy.toString());
    
38.                 proxy.add("haha");
    
39.                 proxy.add("hehe");
    
40.                 System.out.println("proxy.size() = "+ proxy.size());
    
41.                 System.out.println("proxy.toString() = "+ proxy.toString());
    
42.         }

复制代码