对于代理我一直很迷糊 求某个大侠教在下一条思路，并写上一个例子，本人将感激不尽

1. import java.lang.reflect.InvocationHandler;
   
2. import java.lang.reflect.Method;
   
3. import java.lang.reflect.Proxy;
   
4. import java.util.ArrayList;
   
5. import java.util.Collection;
   
6. 
   
7. public class ProxyDemo {
   
8.         public static void main(String[] args) {
   
9.                 /*
   
10.                  * static Object-->newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
    
11.                  * 返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。
    
12.                  * loader - 定义代理类的类加载器
    
13.                  * interfaces - 代理类要实现的接口列表
    
14.                  * h - 指派方法调用的调用处理程序
    
15.                  */
    
16.                 Collection proxy3 = (Collection)Proxy.newProxyInstance(
    
17.                                 Collection.class.getClassLoader(),
    
18.                                 new Class[]{Collection.class},
    
19.                                 new InvocationHandler(){
    
20.                                         @Override
    
21.                                         public Object invoke(Object proxy, Method method, Object[] args)
    
22.                                                         throws Throwable {
    
23.                                                
    
24.                                                 //指定一个目标
    
25.                                                 ArrayList target = new ArrayList();
    
26.                                                
    
27.                                                 long beginTime = System.currentTimeMillis();
    
28.                                                 Object retVal = method.invoke(target,args);
    
29.                                                 Thread.sleep(10);
    
30.                                                 long endTime = System.currentTimeMillis();
    
31.                                                 System.out.println(method.getName()+"...running time:"+(endTime-beginTime));
    
32.                                                
    
33.                                                 return retVal;
    
34.                                         }
    
35.                                 }
    
36.                                 );
    
37.                
    
38.                 proxy3.add("zxx");
    
39.                 proxy3.add("lhm");
    
40.                 proxy3.add("bxd");
    
41.                
    
42.                 System.out.println(proxy3.size());
    
43.         }
    
44. }
    

复制代码

用newProxyInstance()一步搞定。

代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。
按照代理的创建时期，代理类可以分为两种。
静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。
动态代理：在程序运行时，运用反射机制动态创建而成。  

/**
* 动态代理
*/
package com.ccsu.xie.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Collection;

public class DynamicProxy {
        
        public static void main(String[] args) {
                Collection<String> coll = (Collection<String>)getProxy(new ArrayList(),new MyAdvice());
                coll.add("a");
                System.out.println(coll.size());
               
        }
        
        
        public static Object getProxy(final Object target,final Advice advice){
                                 //Proxy 提供用于创建动态代理类和实例的静态方法
                Object obj = Proxy.newProxyInstance(target.getClass().getClassLoader(),
                                target.getClass().getInterfaces(),
                                new InvocationHandler(){
                                        @Override
                                        public Object invoke(Object proxy, Method method,
                                                        Object[] args) throws Throwable {
                                                advice.beforeMethod(method);
                                                Object obj = method.invoke(target, args);
                                                advice.afterMethod(method);
                                                return obj;
                                        }
                        
                });
                return obj;
        }

}

//Advice.java
public interface Advice {
        public void beforeMethod(Method method);
        public void afterMethod(Method method);


}

//MyAdvice.java
package com.ccsu.xie.proxy;

import java.lang.reflect.Method;

public class MyAdvice  implements Advice{
        private long sTime,eTime;

        @Override
        public void afterMethod(Method method) {
                System.out.println("exit method...");
                eTime = System.currentTimeMillis();
                System.out.println("all of  time  : "+(eTime-sTime));
        }

        @Override
        public void beforeMethod(Method method) {
                System.out.println("come in method...");
                sTime = System.currentTimeMillis();
               
               
        }

        

}