spring源码设计模式分析(四)-观察者模式

观察者模式

在Spring里面用的就是事件监听，用事件监听的方式来扩展了观察者模式，理解了观察者模式就理解了顺序编程和逆向编程。

在我们解决某个问题的时候：请求方法1，会依赖请求方法2的结果，同时请求方法2，会依赖请求方法3的结果，这叫做顺序依赖。写程序的时候也是从上往下调，一直返回结果。依赖：就是自己解决不了这个问题，需要依赖另一个方法来帮解决这个问题

也可以逆序依赖，方法3依赖方法2的响应结果，方法2依赖方法1的响应结果，依赖产生行为后的一个状态[消息，事件],简称回调，类似js，jq中的事件监听器的模式。

实现方式：1、事件：观察者模式：这里有目标，和观察者，观察者观察目标，再进行响应。比如：老师讲课，学生听课就是典型的观察者模式。代码如下：

提供一个接口：

1. package com.weizhaoyang.observer;
   
2. 
   
3. public interface Observer {
   
4.    /**
   
5.     * 执行动作
   
6.     */
   
7.    public void  OnAction();
   
8. }
   

提供一个目标类：

1. package com.weizhaoyang.observer;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.List;
   
5. 
   
6. /**
   
7. * 创建目标对象(老师)
   
8. */
   
9. public class Subject {
   
10.     //依赖观察者（学生)
    
11.    List<Observer> studentObservers=new ArrayList<Observer>();
    
12.    //添加观察者
    
13.    public void addObserver(Observer observer){
    
14.        studentObservers.add(observer);
    
15.    }
    
16.    //删除观察者
    
17.    public void removeObserver(Observer observer){
    
18.        studentObservers.remove(observer);
    
19.    }
    
20.    /**
    
21.     * 产生一个行为
    
22.     * 逆向
    
23.     */
    
24.    public void  action(){
    
25.        System.out.println("老师开始上课了");
    
26.        //通知所有的学生来进行响应，这种模式称之为推
    
27.        if (studentObservers != null && studentObservers.size() > 0){
    
28.            for(Observer observer:studentObservers){
    
29.                new Thread(){
    
30.                    @Override
    
31.                    public void run() {
    
32.                       observer.OnAction();
    
33.                    }
    
34.                }.start();
    
35. 
    
36.            }
    
37.        }
    
38.    }
    
39. 
    
40. }
    

提供一个观察者：

1. package com.weizhaoyang.observer;
   
2. 
   
3. public class StudentObserver implements Observer {
   
4.    @Override
   
5.    public void OnAction() {
   
6.        System.out.println("学生收到通知，要开始上课了");
   
7.    }
   
8. }
   

测试的类如下：

1. package com.weizhaoyang.observer;
   
2. 
   
3. public class ObserverTest  {
   
4.    public static void main(String[] args) {
   
5.        Observer observer=new StudentObserver();
   
6.        Subject  subject=new Subject();
   
7.        subject.addObserver(observer);
   
8.        subject.action();
   
9.    }
   
10. }
    

运行的结果如下：上面的异步通知可以称之为事件。类似消息队列。

每一个产生行为之后的就称之为消息。如果不想要去立刻发出消息的话，可以把这四个行为放到缓存里面。

1. package com.weizhaoyang.observer;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.List;
   
5. 
   
6. /**
   
7. * 创建目标对象(老师)
   
8. */
   
9. public class Subject {
   
10.     //依赖观察者（学生)
    
11.    List<Observer> studentObservers=new ArrayList<Observer>();
    
12.    //消息
    
13.    List<String>MessageList=new ArrayList<String>();
    
14.    //添加观察者
    
15.    public void addObserver(Observer observer){
    
16.        studentObservers.add(observer);
    
17.    }
    
18.    //删除观察者
    
19.    public void removeObserver(Observer observer){
    
20.        studentObservers.remove(observer);
    
21.    }
    
22.    /**
    
23.     * 产生一个行为
    
24.     * 逆向
    
25.     */
    
26.    public void  action(){
    
27.        System.out.println("老师开始上课了");
    
28.        MessageList.add("action1");
    
29.        //通知所有的学生来进行响应
    
30.        if (studentObservers != null && studentObservers.size() > 0){
    
31.            for(Observer observer:studentObservers){
    
32.                new Thread(){
    
33.                    @Override
    
34.                    public void run() {
    
35.                       observer.OnAction();
    
36.                    }
    
37.                }.start();
    
38.            }
    
39.        }
    
40.    }
    
41.    public void  action1(){
    
42.        System.out.println("老师开始上课了");
    
43.        MessageList.add("action2");
    
44.        //通知所有的学生来进行响应
    
45.        if (studentObservers != null && studentObservers.size() > 0){
    
46.            for(Observer observer:studentObservers){
    
47.                new Thread(){
    
48.                    @Override
    
49.                    public void run() {
    
50.                        observer.OnAction();
    
51.                    }
    
52.                }.start();
    
53.            }
    
54.        }
    
55.    }
    
56.    public void  action2(){
    
57.        System.out.println("老师开始上课了");
    
58.        MessageList.add("action3");
    
59.        //通知所有的学生来进行响应
    
60.        if (studentObservers != null && studentObservers.size() > 0){
    
61.            for(Observer observer:studentObservers){
    
62.                new Thread(){
    
63.                    @Override
    
64.                    public void run() {
    
65.                        observer.OnAction();
    
66.                    }
    
67.                }.start();
    
68.            }
    
69.        }
    
70.    }
    
71.    public void  action3(){
    
72.        System.out.println("老师开始上课了");
    
73.        //消息
    
74.        MessageList.add("action4");
    
75.        //通知所有的学生来进行响应
    
76.        if (studentObservers != null && studentObservers.size() > 0){
    
77.            for(Observer observer:studentObservers){
    
78.                new Thread(){
    
79.                    @Override
    
80.                    public void run() {
    
81.                        observer.OnAction();
    
82.                    }
    
83.                }.start();
    
84.            }
    
85.        }
    
86.    }
    
87. }
    

上面的代码我们可以用通知统一的通知上面的四个消息。这时不依赖动作的行为，而是依赖消息队列  MessageList。而kafka，rabbitmq这些消息队列只是封装 了暴漏出接口给我们用而已。可以把上面的代码再次的改造，把消息放入到缓存里面，不是立马产生消息，开启一个定时轮询器，用动态线程轮询的方式去消息，而这种模式称之为拉模型。如果线程很好资源的话，可以用线程池。

1. package com.weizhaoyang.observer;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.List;
   
5. 
   
6. /**
   
7. * 创建目标对象(老师)
   
8. */
   
9. public class Subject {
   
10.     //依赖观察者（学生)
    
11.    List<Observer> studentObservers=new ArrayList<Observer>();
    
12.    //消息
    
13.    List<String>MessageList=new ArrayList<String>();
    
14.    //添加观察者
    
15.    public void addObserver(Observer observer){
    
16.        studentObservers.add(observer);
    
17.    }
    
18.    //删除观察者
    
19.    public void removeObserver(Observer observer){
    
20.        studentObservers.remove(observer);
    
21.    }
    
22.    /**
    
23.     * 产生一个行为
    
24.     * 逆向
    
25.     */
    
26.    public void  action(){
    
27.        System.out.println("老师开始上课了");
    
28.        MessageList.add("action1");
    
29.        //通知所有的学生来进行响应
    
30. 
    
31.    }
    
32.    public void  action1(){
    
33.        System.out.println("老师开始上课了");
    
34.        MessageList.add("action2");
    
35.        //通知所有的学生来进行响应
    
36. 
    
37.    }
    
38.    public void  action2(){
    
39.        System.out.println("老师开始上课了");
    
40.        MessageList.add("action3");
    
41.        //通知所有的学生来进行响应
    
42. 
    
43.    }
    
44.    public void  action3(){
    
45.        System.out.println("老师开始上课了");
    
46.        MessageList.add("action4");
    
47.        //通知所有的学生来进行响应
    
48. 
    
49.    }
    
50. }
    

推消息是主动的推消息，拉是主动的从消息队列里面去拉取消息。这就是从观察者设计模式延申到消息队列一些知识点。下面的是最简单的消息队列：每产生一个动作，就发送一条消息。

如果不直接消费的话，就可以从messgeList里面去拉取感兴趣的消息，在spring中用的是事件的方式，代码改造如下：

1、首先加一个事件：

1. package com.weizhaoyang.observer;
   
2. 
   
3. /**
   
4. * 事件对象
   
5. */
   
6. public class MyEvent {
   
7.    //目标对象
   
8.    public Object target;
   
9.    //其他参数
   
10.    private String name;
    
11. 
    
12.    public MyEvent(Object target, String name) {
    
13.        this.target = target;
    
14.        this.name = name;
    
15.    }
    
16. 
    
17.    public Object getTarget() {
    
18.        return target;
    
19.    }
    
20. 
    
21.    public void setTarget(Object target) {
    
22.        this.target = target;
    
23.    }
    
24. 
    
25.    public String getName() {
    
26.        return name;
    
27.    }
    
28. 
    
29.    public void setName(String name) {
    
30.        this.name = name;
    
31.    }
    
32. }
    

2、观察者的接口如下：

1. package com.weizhaoyang.observer;
   
2. 
   
3. public interface Observer {
   
4.    /**
   
5.     * 执行动作
   
6.     */
   
7.    public void  OnAction(MyEvent  myEvent);
   
8. }
   

3、目标的代码改造如下：

1. package com.weizhaoyang.observer;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.List;
   
5. 
   
6. /**
   
7. * 创建目标对象(老师)
   
8. */
   
9. public class Subject {
   
10.     //依赖观察者（学生)
    
11.    List<Observer> studentObservers=new ArrayList<Observer>();
    
12.    //消息
    
13.    List<String>MessageList=new ArrayList<String>();
    
14.    //添加观察者
    
15.    public void addObserver(Observer observer){
    
16.        studentObservers.add(observer);
    
17.    }
    
18.    //删除观察者
    
19.    public void removeObserver(Observer observer){
    
20.        studentObservers.remove(observer);
    
21.    }
    
22.    /**
    
23.     * 产生一个行为
    
24.     * 逆向
    
25.     */
    
26.    public void  action(){
    
27.        System.out.println("老师开始上课了");
    
28.        MessageList.add("action1");
    
29.        //通知所有的学生来进行响应
    
30. 
    
31.    }
    
32.    public void  action1(){
    
33.        System.out.println("老师开始上课了");
    
34.        MessageList.add("action2");
    
35.        //通知所有的学生来进行响应
    
36. 
    
37.    }
    
38.    public void  action2(){
    
39.        System.out.println("老师开始上课了");
    
40.        MessageList.add("action3");
    
41.        //通知所有的学生来进行响应
    
42. 
    
43.    }
    
44.    public void  action3(){
    
45.        System.out.println("老师开始上课了");
    
46.        //MessageList.add("action4");
    
47.        //事件
    
48.        MyEvent  myEvent=new MyEvent(this,"weizhaoyang");
    
49.        //通知所有的学生来进行响应
    
50.        if (studentObservers != null && studentObservers.size() > 0){
    
51.            for(Observer observer:studentObservers){
    
52.                new Thread(){
    
53.                    @Override
    
54.                    public void run() {
    
55.                        observer.OnAction(myEvent);
    
56.                    }
    
57.                }.start();
    
58.            }
    
59.        }
    
60.    }
    
61. }
    

4、观察者的代码改造如下：

1. package com.weizhaoyang.observer;
   
2. 
   
3. public class StudentObserver implements Observer {
   
4.    @Override
   
5.    public void OnAction(MyEvent event) {
   
6.        System.out.println("收到回调通知"+event.getName());
   
7.        System.out.println("学生收到通知，要开始上课了");
   
8.    }
   
9. }
   

5、测试类的代码如下：

1. package com.weizhaoyang.observer;
   
2. 
   
3. public class ObserverTest  {
   
4.    public static void main(String[] args) {
   
5.        Observer observer=new StudentObserver();
   
6.        Subject  subject=new Subject();
   
7.        subject.addObserver(observer);
   
8.        subject.action3();
   
9.    }
   
10. }
    

运行的结果如下：

这就是基于事件的观察者模式，在监听器里面就可以依赖目标了。在spring中就是基于事件来设计的。