在学习反射时就对反射的应用地方很费解，在学习代里设计模式时终于用到了反射，也算用反射小试牛刀。
学习过程中忽略了论坛技术分，有点郁闷，没想到技术分会成为一个问题。
所以有了打算分享自己学习笔记的想法，作为技术人员还是应该有点“共享”、“开源”、精神的，当然了，醉翁之意还是赚点技术分。

代理设计模式简介：

代理设计就是指由一个代理主题来操作真是主题，真实主题操作具体的业务，而代理主题负责相关业务，代理à真实à具体业务。

       Windows系统提供的快捷方式，可以使任何一个对象同时出现在多个地方而不必修改原始对象。对快捷方式的调用与对原始对象的调用是一样的，快捷方式对于客户端是完全透明的。快捷方式被删除了，不会影响原始对象，但原始对象被删除后，快捷方式将不能使用，这就是一种代理模式的体现。

代理模式的结构：抽象主题：声明真实主题和代理主题的共同接口，这样任何可以使用真是主题的地方都可以使用代理主题。
代理主题：代理主题内含有对真是主题对象的引用，从而使代理主题操作真是主题。代理主题提供一个与真实主题相同的接口，这样就可以在任何时候替代真实主题。
真实主题：代理主题所引用的真实主题。静态代理：

定义代理与真实主题的共同接口：ISubject

1. public interface ISubject {
   
2.         public String print() throws Exception;
   
3. }
   

复制代码

定义真实主题，真实主题实现抽象主题接口，并且会被代理主题所引用：实现ISubject接口

1. public class ReaSubjectImpl implements ISubject {
   
2.         @Override
   
3.         public String print() throws Exception {
   
4.                 return "This is print() in RealSubject.class!!!";
   
5.         }
   
6. }
   

复制代码

定义代理主题：代里类中通过构造接收ISubject接口的子类对象

1. public class ProxySubjectImpl implements ISubject {
   
2.         private ISubject subject;
   
3.         public ProxySubjectImpl(ISubject subject) {
   
4.                 this.subject = subject;
   
5.         }
   
6.         @Override
   
7.         public String print() throws Exception {
   
8.                 System.out.println(this.before()); // 调用代理类中的主题
   
9.                 System.out.println(subject.print()); // 调用真实类主题
   
10.                 System.out.println(this.after()); // 调用代理类中的主题
    
11.                 return "Proxy is ending!!!";
    
12.         }
    
13.         public String before() {
    
14.                 return "This is before() in ProxySubject.class!!!";
    
15.         }
    
16.         public String after() {
    
17.                 return "This is after() in ProxySubject.class!!!";
    
18.         }
    
19. }
    

复制代码

测试：

1. public class TestStaticProxy {
   
2.         public static void main(String[] args) throws Exception {
   
3.                 ISubject subject = null;
   
4.                 //像代理主题传入真是主题的引用
   
5.                 subject = new ProxySubjectImpl((ISubject) new ReaSubjectImpl());
   
6.                 System.out.println(subject.print());
   
7.         }
   
8. }
   

复制代码

Sequence图：

动态代理：

静态代理的缺点是每一个代理类只能为一个接口提供服务，很多个接口就需要有很多个代理类，最好是能有一个类可完成任意接口的代理。java.lang.reflect包中提供了三个直接支持代理模式的类：Proxy、InvocationHandler、Method。Proxy类提供了一个创建代理对象的方法：

1. Public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) throws IllegalArgumentException

复制代码

newProxyInstance()可以直接创建动态代理对象，该代理对象实现了参数中interfaces指定的所有接口，执行代理对象的每个方法时都会被替换为InvocationHandler接口的invoke()，newProxyInstance()也被要求传入一个InvocationHandler的实例对象。程序每生成一个代理类对象都有一个与之关联的InvocationHandler对象。

InvocationHandler中的invoke()：

1. Object invoke(Object proxy,Method method,Object[] args)throws Throwable

复制代码

proxy：被动态代理的对象   method：正在调用的方法   args：调用被代里对象时传入的参数Proxy类能能够在程序运行时自动创建真实对象的代理对象，当有代理对象后，对真实对象的方法进行调用时会首先分派给InvocationHandler接口，在接口的invoke()方法中截获对真实对象方法的调用，加入额外的操作，就实现了动态代理的功能。调用真实类中的方法时就会调用invoke()。

范例1：为一个Vector类提供一个代理对象，当Vector类调用任何方法之前、之后打印两条信息，表明当调用Vector中的方法时，可以被InvocationHandler接口中的invoke()截获，并实现代理功能。

1. public class VectorProxy implements InvocationHandler {
   
2.         private Object proxyObj;
   
3.         public VectorProxy(Object proxyObj) {
   
4.                 this.proxyObj = proxyObj;
   
5.         }
   
6.         /**
   
7.          * 定义静态工厂方法，接收被代理的对象
   
8.          *  @param obj
   
9.          * @return
   
10.          */
    
11.         public static Object factory(Object obj) {
    
12.                 Class<?> cls = obj.getClass();
    
13.         /* 第三个参数无法使用this，因为在静态工厂方法中，static与this冲突 */
    
14.                 return Proxy.newProxyInstance(cls.getClassLoader(),
    
15.                                 cls.getInterfaces(), new VectorProxy(obj));
    
16.         }
    
17.         @Override
    
18.         public Object invoke(Object proxy, Method method, Object[] args)
    
19.                         throws Throwable {
    
20.                 System.out.println("befroe overried invoke()-->" + method);
    
21.                 if (args != null) {
    
22.                         for (Object o : args)
    
23.                                 System.out.println(o + "\t");
    
24.                 }else {
    
25.                         System.out.println("args is null in overried invoke()");
    
26.                 }
    
27.                 Object obj = method.invoke(proxyObj, args);
    
28.                 System.out.println("after overried invoke()-->" + method);
    
29.                 return obj;
    
30.         }
    
31. 
    
32.         public static void main(String[] args) {
    
33.                 @SuppressWarnings({ "unchecked", "rawtypes" })
    
34.                 List<String> list = (List<String>) VectorProxy.factory(new Vector());
    
35.                 list.add("New");
    
36.                 System.out.println();
    
37.                 list.add("York");
    
38.                 System.out.println(list);
    
39.         }
    
40. }
    

复制代码

数出结果： befroe overried invoke()-->public abstract booleanjava.util.List.add(java.lang.Object) New      after overried invoke()-->public abstract booleanjava.util.List.add(java.lang.Object) befroe overried invoke()-->public abstract booleanjava.util.List.add(java.lang.Object) York      after overried invoke()-->public abstract booleanjava.util.List.add(java.lang.Object) befroe overried invoke()-->public java.lang.Stringjava.lang.Object.toString() args is null in overried invoke() after overried invoke()-->public java.lang.Stringjava.lang.Object.toString() [New, York]

数出结果显示了在调用Vector类中add()的方法时打印了befroe、after两条信息，在直接打印集合时，因为没有参数，agrs为空的信息也打印了。代理对象截获了Vector对象的所有应用。

Sequece图：

例2：把之前的静态代理，改成动态代理，实现代理功能

定义代理与真实类的共同接口：

1. public interface ISubject {
   
2.         public String print() throws Exception;
   
3. }
   

复制代码

定义动态代理类，实现InvocationHandler接口，与之前的静态代理类完全不一样

1. public class DynamicProxy implements InvocationHandler {
   
2.         private Object targetObject; // 被代理的对象
   
3.         public Object createProxyInstance(Object targetObject) {
   
4.                 this.targetObject = targetObject;
   
5.                 // Proxy为专门完成代理的操作类
   
6.                 return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
   
7.                                 targetObject.getClass().getInterfaces(), this);
   
8.                 // newProxyInstance(加载接口的实现类(类的加载器),真实类实现的接口, 得到InvocationHandler接口的子类(也就是本类DynamicProxy))
   
9.         }
   
10.         @Override
    
11.         public Object invoke(Object proxy, Method method, Object[] args)
    
12.                         throws Throwable {
    
13.                 System.out.println(proxyer()); // 调用真实类前所执行的方法
    
14. // 调用真实类中的方法
    
15.                 Object obj = method.invoke(targetObject, args);
    
16.                 return obj;
    
17.         }
    
18.         private String proxyer() {
    
19.                 return "This is proxyer in invode()!!!";
    
20.         }
    
21. }
    

复制代码

测试类：

1. public class DynamicProxyTest {
   
2.         public static void main(String[] args) throws Exception {
   
3.                 DynamicProxy dProxy = new DynamicProxy();
   
4.                 ISubject subject = (ISubject) dProxy.createProxyInstance(new RealSubjectImpl());
   
5.                 System.out.println(subject.print());
   
6.         }
   
7. }
   
8. 打印结果：
   
9. This is proxyer in invode()!!!
   
10. This is RealSubject!!!
    

复制代码

例3：采用匿名内部类的方式代理Collection接口

1. public class DynamicProxyTest{
   
2.         public static void main(String[] args) throws Exception {
   
3.                 Class<?> clazzProxy = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
   
4.                 Collection c = (Collection) Proxy.newProxyInstance(
   
5.                                 Collection.class.getClassLoader(),
   
6.                                 new Class[]{Collection.class},
   
7.                                 new InvocationHandler(){
   
8.                                         List list = null;
   
9.                                         @SuppressWarnings("rawtypes")
   
10.                                         @Override
    
11.                                         public Object invoke(Object proxy, Method method,
    
12.                                                         Object[] args) throws Throwable {
    
13.                                                 if(list==null)
    
14.                                                  list = new ArrayList();
    
15.                                                 return method.invoke(list, args);
    
16.                                         }
    
17.                                 });
    
18.                 c.add("A");
    
19.                 c.add("B");
    
20.                 c.add("C");
    
21.                 System.out.println(c.size());
    
22.                 System.out.println(c);
    
23.                 System.out.println(c.getClass());
    
24.         }
    
25. }
    

复制代码

以上就是我学习动态代里的笔记，参考了毕向东老师的视屏、张孝祥老师的视频、阎宏《Java与模式》、李刚《疯狂Java讲义》。
对于逻辑上理解InvocationHandler中的invoke()，squence图起了不小的帮助。

ProxyDemo.rar (11.09 KB, 下载次数: 28)

2013-6-11 12:04 上传

点击文件名下载附件

版主，小手一抖，
俺的技术分到手。

很用功  加油

袁梦希 发表于 2013-6-11 12:38
很用功  加油

谢谢版主，太感动了！:'(:'(