Scott's world.

设计模式-观察者模式

Word count: 1.7kReading time: 6 min
2019/08/23 Share

设计模式-观察者模式

模式定义

定义对象间的一种一对多依赖关系,使得每当一个对象状态发生改变时,其相关依赖对象皆得到通知并被自动更新。观察者模式又叫做发布-订阅(Publish/Subscribe)模式、模型-视图(Model/View)模式、源-监听器(Source/Listener)模式或从属者(Dependents)模式。

模式动机

建立一种对象与对象之间的依赖关系,一个对象发生改变时将自动通知其他对象,其他对象将相应做出反应。在此,发生改变的对象称为观察目标,而被通知的对象称为观察者,一个观察目标可以对应多个观察者,而且这些观察者之间没有相互联系,可以根据需要增加和删除观察者,使得系统更易于扩展,这就是观察者模式的模式动机。

观察者模式类图

Subject: 主题
ConcreteSubject: 具体主题
Observer: 观察者
ConcreteObserver: 具体观察者
在这里插入图片描述

模式例子-微信订阅推送

在这里插入图片描述

主题:服务号
观察者:普通使用者

代码分析:

1.创建主题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package observe;

/**
* TODO
*
* @author tudou
* @version 1.0
* @date 2019/5/26 17:39
**/
public interface Subject {

/**
* 注册一个观察者
* @param observer
*/
public void registerObserver(Observer observer);

/**
* 移除一个观察者
* @param observer
*/
public void removeObserver(Observer observer);

/**
* 通知所有的观察者
*/
public void notifyObservers();
}

2.创建观察者

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package observe;

/**
* TODO
*
* @author tudou
* @version 1.0
* @date 2019/5/26 17:40
**/
public interface Observer {

/**
* 所有的观察者都需要实现此接口
*/
public void update(String msg);
}

  1. 具体主题即微信服务的内容
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    package observe;

    import java.util.ArrayList;
    import java.util.List;

    /**
    * TODO
    *
    * @author tudou
    * @version 1.0
    * @date 2019/5/26 17:43
    **/
    public class ObjectFor3D implements Subject{

    private List<Observer> observers=new ArrayList<>();

    /**
    * 推送信息
    */
    String msg;

    @Override
    public void registerObserver(Observer observer) {
    observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {

    int index= observers.indexOf(observer);
    if(index>=0){
    observers.remove(index);
    }
    }

    @Override
    public void notifyObservers() {

    for(Observer observer:observers){
    observer.update(msg);
    }
    }

    /**
    * 主题更新消息
    * @param msg
    */
    public void setMsg(String msg) {
    this.msg = msg;
    notifyObservers();
    }
    }

4.创建相应用户

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package observe;

/**
* TODO
*
* @author tudou
* @version 1.0
* @date 2019/5/26 17:46
**/
public class Observer1 implements Observer {

private Subject subject;

public Observer1(Subject subject){
this.subject=subject;
subject.registerObserver(this);
}

@Override
public void update(String msg) {
System.out.println("observer 1 接收到的推送消息:"+msg);
}
}

package observe;

/**
* TODO
*
* @author tudou
* @version 1.0
* @date 2019/5/26 17:46
**/
public class Observer2 implements Observer {

private Subject subject;

public Observer2(Subject subject){
this.subject=subject;
subject.registerObserver(this);
}

@Override
public void update(String msg) {
System.out.println("observer 2 接收到的推送消息:"+msg);
}
}

5.进行测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package observe;

/**
* TODO
*
* @author tudou
* @version 1.0
* @date 2019/5/26 17:48
**/
public class test {

public static void main(String[] args) {
//创建一个服务号
ObjectFor3D objectFor3D=new ObjectFor3D();
//向客户推送消息
Observer1 observer1=new Observer1(objectFor3D);
Observer2 observer2=new Observer2(objectFor3D);

objectFor3D.setMsg("第一条消息");
objectFor3D.setMsg("第二条消息");
}

测试结果:
在这里插入图片描述

观察者模式描述了如何建立对象与对象之间的依赖关系,如何构造满足这种需求的系统。
这一模式中的关键对象是观察目标和观察者,一个目标可以有任意数目的与之相依赖的观察者,一旦目标的状态发生改变,所有的观察者都将得到通知。
作为对这个通知的响应,每个观察者都将即时更新自己的状态,以与目标状态同步,这种交互也称为发布-订阅(publishsubscribe)。目标是通知的发布者,它发出通知时并不需要知道谁是它的观察者,可以有任意数目的观察者订阅它并接收通

当然实现方式java中已经帮我们实现了观察者模式,借助于java.util.Observable和java.util.Observer。

模式应用

观察者模式在软件开发中都有广泛的应用,如本文提及到微信订阅号推送消息,电子商务网站可以在执行发送操作后给用户多个发送商品打折信息,某团队战斗游戏中某队友牺牲将给所有成员提示等等,凡是涉及到一对一或者一对多的对象交互场景都可以使用观察者模式.

总结

  • 观察者模式定义对象间的一种一对多依赖关系,使得每当一个对象状态发生改变时,其相关依赖对象皆得到通知并被自动更新。观察者模式又叫做发布-订阅模式、模型-视图模式、源-监听器模式或从属者模式。观察者模式是一种对象行为型模式。
  • 观察者模式包含四个角色:目标又称为主题,它是指被观察的对象;具体目标是目标类的子类,通常它包含有经常发生改变的数据,当它的状态发生改变时,向它的各个观察者发出通知;观察者将对观察目标的改变做出反应;在具体观察者中维护一个指向具体目标对象的引用,它存储具体观察者的有关状态,这些状态需要和具体目标的状态保持一致。
  • 观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个目标对象,当这个目标对象的状态发生变化时,会通知所有观察者对象,使它们能够自动更新。
  • 观察者模式的主要优点在于可以实现表示层和数据逻辑层的分离,并在观察目标和观察者之间建立一个抽象的耦合,支持广播通信;其主要缺点在于如果一个观察目标对象有很多直接和间接的观察者的话,将所有的观察者都通知到会花费很多时间,而且如果在观察者和观察目标之间有循环依赖的话,观察目标会触发它们之间进行循环调用,可能导致系统崩溃。
  • 观察者模式适用情况包括:一个抽象模型有两个方面,其中一个方面依赖于另一个方面;一个对象的改变将导致其他一个或多个对象也发生改变,而不知道具体有多少对象将发生改变;一个对象必须通知其他对象,而并不知道这些对象是谁;需要在系统中创建一个触发链。
  • 在JDK的java.util包中,提供了Observable类以及Observer接口,它们构成了Java语言对观察者模式的支持。

参考

https://blog.csdn.net/lmj623565791/article/details/24179699
https://design-patterns.readthedocs.io/zh_CN/latest/behavioral_patterns/observer.html

CATALOG
  1. 1. 设计模式-观察者模式
    1. 1.0.1. 模式定义
    2. 1.0.2. 模式动机
    3. 1.0.3. 观察者模式类图
    4. 1.0.4. 模式例子-微信订阅推送
      1. 1.0.4.1. 代码分析:
    5. 1.0.5. 模式应用
    6. 1.0.6. 总结
    7. 1.0.7. 参考