委托设计模式

Bertha 。 2022-06-15 04:08 128阅读 0赞

### 首先区别下代理模式和委托模式的区别： ###

proxy :译为代理， 被代理方（B）与代理方（A）的接口完全一致。 主要使用场景（语义）应该是：为简化编程（或无法操作B），不直接把请求交给被代理方（B），而把请求交给代理方（A），由代理方与被代理方进行通信，以完成请求。

delegete : 译为委托，主要语义是：一件事情（或一个请求）对象本身不知道怎样处理，对象把请求交给其它对象来做。

### **代理模式 顾名思义就是委托别人去做事情。** ###

其实结合例子更好，那么我就用一个小例子来引出这种设计模式。

一个班级，有两类学生，A类：不学习，玩，但是玩的东西不一样，有的是做游戏，与的是看电视（有点不合理）

B类：放哨的学生，专门看老师的动向，如果老师进班了就立即通知大家。

如此就形成了一个需求，放哨的学生要通知所有玩的学生：老师来了，而不同的学生有不同的反应，有的马上把电视关闭，有的停止玩游戏。

设计的要求如下，让A类学生和B类学生完全解耦，即A类完全不知道B类的学生，却可以通知B类的学生。

代码及说明如下:

Event 类，定义了一个事件类:

Code:

1.  **package** lnurd.test;   
2.    
3.  **import** java.lang.reflect.Method;   
4.  **import** java.util.Date;   
5.    
6.  **public** **class** Event \{   
7.      //要执行方法的对象   
8.      **private** Object object;   
9.      //要执行的方法名称   
10.     **private** String methodName;   
11.     //要执行方法的参数   
12.     **private** Object\[\] params;   
13.     //要执行方法的参数类型   
14.     **private** Class\[\] paramTypes;   
15.        
16.     **public** Event()\{   
17.            
18.     \}   
19.     **public** Event(Object object,String methodName,Object...args)\{   
20.         **this**.object=object;   
21.         **this**.methodName=methodName;   
22.         **this**.params=args;   
23.         contractParamTypes(**this**.params);   
24.     \}   
25.     //根据参数数组生成参数类型数组   
26.     **private** **void** contractParamTypes(Object\[\] params)\{   
27.         **this**.paramTypes=**new** Class\[params.length\];   
28.         **for**(**int** i=0;i<params.length;i++)\{   
29.             **this**.paramTypes\[i\]=params\[i\].getClass();   
30.         \}   
31.     \}   
32.        
33.     **public** Object getObject() \{   
34.         **return** object;   
35.     \}   
36.                      //若干setter getter省略   
37.     **public** **void** setParamTypes(Class\[\] paramTypes) \{   
38.         **this**.paramTypes = paramTypes;   
39.     \}   
40.     //执行该 对象的该方法   
41.     **public** **void** invoke() **throws** Exception\{   
42.         Method method=object.getClass().getMethod(**this**.getMethodName(), **this**.getParamTypes());   
43.         **if**(**null**==method)\{   
44.             **return**;   
45.         \}   
46.         method.invoke(**this**.getObject(), **this**.getParams());   
47.     \}   
48. \}

EventHandler类，若干Event类的载体，同时提供一个执行所有Event的方法

Code:

1.  **package** lnurd.test;   
2.    
3.  **import** java.util.ArrayList;   
4.  **import** java.util.List;   
5.    
6.  **public** **class** EventHandler \{   
7.      //是用一个List   
8.      **private** List<Event> objects;   
9.         
10.     **public** EventHandler()\{   
11.         objects=**new** ArrayList<Event>();   
12.     \}   
13.     //添加某个对象要执行的事件，及需要的参数   
14.     **public** **void** addEvent(Object object,String methodName,Object...args)\{   
15.         objects.add(**new** Event(object,methodName,args));   
16.     \}   
17.     //通知所有的对象执行指定的事件   
18.     **public** **void** notifyX() **throws** Exception\{   
19.         **for**(Event e : objects)\{   
20.             e.invoke();   
21.         \}   
22.     \}   
23. \}

放哨的学生：这里先抽象出一个抽象类，因为放哨的人有尽职尽责的，也有马马虎虎的，

但是他们有功能的方法1。增加需要帮忙放哨的学生  2。通知所有需要放哨的学生：老师来了

Code:

1.  **package** lnurd.test;   
2.    
3.  **public** **abstract** **class** Notifier \{   
4.      **private** EventHandler eventHandler=**new** EventHandler();   
5.         
6.      **public** EventHandler getEventHandler() \{   
7.          **return** eventHandler;   
8.      \}   
9.      **public** **void** setEventHandler(EventHandler eventHandler) \{   
10.         **this**.eventHandler = eventHandler;   
11.     \}   
12.     //增加需要帮忙放哨的学生   
13.     **public** **abstract** **void** addListener(Object object,String methodName,Object...args);   
14.     //告诉所有要帮忙放哨的学生：老师来了   
15.     **public** **abstract** **void** notifyX();   
16. \}

接着是放哨人的具体实现了，这里仅实现两个

1尽职尽责的放哨人GoodNotifier

2马马虎虎的放哨人BadNotifier

Code:

1.  **package** lnurd.test;   
2.    
3.  **public** **class** GoodNotifier **extends** Notifier \{   
4.    
5.      @Override  
6.      **public** **void** addListener(Object object, String methodName, Object... args) \{   
7.          System.out.println("有新的同学委托尽职尽责的放哨人!");   
8.          **this**.getEventHandler().addEvent(object, methodName, args);   
9.      \}   
10.   
11.     @Override  
12.     **public** **void** notifyX() \{   
13.         System.out.println("尽职尽责的放哨人告诉所有需要帮忙的同学：老师来了");   
14.         **try**\{   
15.             **this**.getEventHandler().notifyX();   
16.         \}**catch**(Exception e)\{   
17.             e.printStackTrace();   
18.         \}   
19.     \}   
20.   
21. \}   
22.   
23. //对于BadNotifier代码类似，不再复述.

接下来是玩游戏的学生：PlayingGameListener

Code:

1.  **package** lnurd.test;   
2.    
3.  **import** java.util.Date;   
4.    
5.  **public** **class** PlayingGameListener \{   
6.      **public** PlayingGameListener()\{   
7.          System.out.println("我正在玩游戏 开始时间"\+**new** Date());   
8.      \}   
9.      **public** **void** stopPlayingGame(Date date)\{   
10.         System.out.println("老师来了，快回到座位上，结束时间"\+date);   
11.     \}   
12. \}

在接下来是看电视的学生WatchingTVListener

Code:

1.  **package** lnurd.test;   
2.    
3.  **import** java.util.Date;   
4.    
5.  **public** **class** WatchingTVListener \{   
6.      **public** WatchingTVListener()\{   
7.          System.out.println("我正在看电视 "\+**new** Date());   
8.      \}   
9.      **public** **void** stopWatchingTV(Date date)\{   
10.         System.out.println("老师来了，快关闭电视 。 结束时间"\+date);   
11.     \}   
12. \}

[测试][Link 1]代码：

Code:

1.  //创建一个尽职尽责的放哨者   
2.  Notifier goodNotifier=**new** GoodNotifier();   
3.    
4.  //创建一个玩游戏的同学，开始玩游戏   
5.  PlayingGameListener playingGameListener=**new** PlayingGameListener();   
6.  //创建一个看电视的同学，开始看电视   
7.  WatchingTVListener watchingTVListener=**new** WatchingTVListener();   
8.  //玩游戏的同学告诉放哨的同学，老师来了告诉一下   
9.  goodNotifier.addListener(playingGameListener, "stopPlayingGame",**new** Date());   
10. //看电视的同学告诉放哨的同学，老师来了告诉一下   
11. goodNotifier.addListener(watchingTVListener, "stopWatchingTV",**new** Date());   
12. **try**\{   
13.     //一点时间后   
14.     Thread.sleep(1000);   
15. \}**catch**(Exception e)\{   
16.     e.printStackTrace();   
17. \}   
18. //老师出现，放哨的人通知所有要帮忙的同学:老师来了   
19. goodNotifier.notifyX();

点评：

1。放哨者完全不知道做游戏者的存在，完全解耦。（当然，功劳归功于Event和EventHandler，且这两个类具有通用性）

2。老师来了后游戏者停止游戏回到座位，看电视着关闭电视。（一次通知，执行了不同类的不同方法）

3。扩展性很高，再来一个打篮球的学生就先写个打篮球学生类，并在测试代码中告诉放哨者一下就好，放哨者完全没有变。重用性好

引用资料：http://blog.csdn.net/yanshujun/article/details/6494447

http://blog.csdn.net/jince007/article/details/40179339

[Link 1]: http://lib.csdn.net/base/softwaretest