Proxy.newProxyInstance()返回的只能是接口，即代理对象所实现的接口

1. package demo.proxy;
   
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.List;
   
8. 
   
9. public class ProxyOfArrayListDemo {
   
10. 
    
11.         /**
    
12.          * 23、 写一个 ArrayList 类的代理，实现和 ArrayList 类中完全相同的功能，
    
13.          * 并可以计算 每个方法运行的时间。
    
14.          */
    
15.         public static void main(String[] args) {
    
16.                 ArrayList<String> al = new ArrayList<String>();
    
17.                 List proxy = (List)Proxy.newProxyInstance(al.getClass().getClassLoader(),
    
18.                                 al.getClass().getInterfaces(),new MyInvocationHandler1(al));
    
19.                 proxy.add("Hello java");
    
20.                 proxy.remove(0);
    
21.         }
    
22. 
    
23. }
    
24. class MyInvocationHandler1 implements InvocationHandler{
    
25.         private Object obj;
    
26.        
    
27.         public MyInvocationHandler1(Object obj) {
    
28.                 super();
    
29.                 this.obj = obj;
    
30.         }
    
31. 
    
32.         @Override
    
33.         public Object invoke(Object proxy, Method method, Object[] args)
    
34.                         throws Throwable {
    
35.                 Long l1 = System.currentTimeMillis();
    
36.                 System.out.println("size of args : "+args.length +"..args[0] = "+args[0]);
    
37.                 System.out.println("method : "+method);
    
38.                 System.out.println("obj = "+obj);
    
39.                 Object result = method.invoke(obj, args);
    
40.                 System.out.println("result = "+result);
    
41.                 Long l2 = System.currentTimeMillis();
    
42.                 System.out.println(l2-l1);
    
43.                 return result;
    
44.         }
    
45.        
    
46. }

复制代码

1. size of args : 1..args[0] = Hello java
   
2. method : public abstract boolean java.util.List.add(java.lang.Object)
   
3. obj = []
   
4. result = true
   
5. 1
   
6. size of args : 1..args[0] = 0
   
7. method : public abstract java.lang.Object java.util.List.remove(int)
   
8. obj = [Hello java]
   
9. result = Hello java
   
10. 0
    

复制代码

1. 一个典型的动态代理创建对象过程可分为以下四个步骤：
   
2. 1、通过实现InvocationHandler接口创建自己的调用处理器 IvocationHandler handler = new InvocationHandlerImpl(...);
   
3. 2、通过为Proxy类指定ClassLoader对象和一组interface创建动态代理类
   
4. Class clazz = Proxy.getProxyClass(classLoader,new Class[]{...});
   
5. 3、通过反射机制获取动态代理类的构造函数，其参数类型是调用处理器接口类型
   
6. Constructor constructor = clazz.getConstructor(new Class[]{InvocationHandler.class});
   
7. 4、通过构造函数创建代理类实例，此时需将调用处理器对象作为参数被传入
   
8. Interface Proxy = (Interface)constructor.newInstance(new Object[] (handler));
   
9. 为了简化对象创建过程，Proxy类中的newInstance方法封装了2~4，只需两步即可完成代理对象的创建。
   
10. 生成的ProxySubject继承Proxy类实现Subject接口，实现的Subject的方法实际调用处理器的invoke方法，而invoke方法利用反射调用的是被代理对象的的方法（Object result=method.invoke(proxied,args)）

复制代码