1. import java.lang.reflect.Constructor;
   
2. import java.lang.reflect.InvocationHandler;
   
3. import java.lang.reflect.InvocationTargetException;
   
4. import java.lang.reflect.Method;
   
5. import java.lang.reflect.Proxy;
   
6. import java.util.ArrayList;
   
7. import java.util.Collection;
   
8. import java.util.List;
   
9. 
   
10. interface Advice {
    
11.         void beforeMethod(Method method);
    
12.         void afterMethod(Method method);
    
13. }
    
14. class MyAdvice implements Advice {
    
15.         long startTime=0;
    
16.         @Override
    
17.         public void beforeMethod(Method method) {               
    
18.                  System.out.println("方法开始啦");
    
19.                  startTime = System.currentTimeMillis();
    
20.         }
    
21. 
    
22.         @Override
    
23.         public void afterMethod(Method method) {               
    
24.                 System.out.println("方法结束啦");
    
25.                 long endTime = System.currentTimeMillis();
    
26.                 System.out.println(method.getName()+"  running time:"+(endTime - startTime));
    
27.         }
    
28. }
    
29. 
    
30. public class ProxyTest {        
    
31.         public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
    
32. 
    
33.                 final ArrayList target = new ArrayList();
    
34.                 Collection proxy =(Collection) getProxy(target,new MyAdvice());
    
35. //                ArrayList it =(ArrayList) getProxy(target,new MyAdvice());        这句报错
    
36.                 List proxy1 =(List) getProxy(new ArrayList(),new MyAdvice());
    
37.                 Iterable it = (Iterable)getProxy(new ArrayList(),new MyAdvice());
    
38.                 /*
    
39.                  我的问题：1.这里的getProxy()方法传递的参数是final类型的，但为什么我传入new  ArrayList()没有定义成final，没有定义成final也通过编译而且运行正常？
    
40.                        2.这里的代理设计模式，跟装饰设计模式很类似，都是传入一个类，然后返回一个新类，同时多了一些功能，这两个设计模式有什么区别？
    
41.                        3.Collection 能指向这个代理类，说明这个代理类是Collection的一个实现类，但也没有标记implement怎么就实现了？
    
42.                          将其强转为ArrayList编译失败，说明它是不是ArrayList或者其子类，它跟ArrayList的最大公约数是什么?
    
43.                  */
    
44. 
    
45. //                System.out.println("iterable:"+it.iterator());
    
46.                 proxy1.add("lisi");
    
47.                 proxy.add("wangwu");
    
48.                 System.out.println(proxy.size());
    
49.                
    
50.         }
    
51. 
    
52.         public static Object getProxy(final Object target,final Advice advice) {
    
53.                 Object proxy3 =Proxy.newProxyInstance(
    
54.                                 target.getClass().getClassLoader(),
    
55.                                 target.getClass().getInterfaces(),
    
56.                                 new InvocationHandler() {                                
    
57.                                 @Override
    
58.                                 public Object invoke(Object proxy, Method method, Object[] args)
    
59.                                                 throws Throwable {
    
60.                                         advice.beforeMethod(method);
    
61.                                         Object retVal = method.invoke(target, args);
    
62.                                         advice.afterMethod(method);
    
63.                                         return retVal;
    
64.                                 }
    
65.                 });
    
66.                 return proxy3;
    
67.         }               
    
68. }

复制代码

内部类调用外部类变量才需要final

问题1、你传进去的是具体的对象，不需要类型修饰控制，所以不需要final Object object的啥东西了。
问题2、装饰设计模式与代理模式，看起来的确很相似，都有实现一个接口，都有添加功能的作用。但装饰设计模式主要关注于添加某些方法。代理模式，主要用于控制，你完全可以更改从目标（target）到客户端（client）的数据，这就是代理。
问题3、static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
          返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。
这里是一个接口数组！返回：一个指定接口的代理类实例。（我只能这么理解。。。。）