设计模式--观察者模式

发表于 | 分类于

定义

观察者模式定义了对象之间的一对多的依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。
实现观察者模式最常用的方法是用Subject与Observer接口的类设计。

观察者模式的实现

发布者接口

1
2
3
4
5
interface Subject{
    public void registerObserver(Observer o);
    public void removeObserver(Observer o);
    public void notifyObservers();
}

观察者接口

1
2
3
interface Observer{
    public void update(String message);
}

发布者具体实现

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
class OfficialCount implements Subject{
    private ArrayList<Observer> observers;	//观察者列表
    private String content;	//发布的内容
    public OfficialCount(){
        observers = new ArrayList<>();
    }
	//添加观察者
    public void registerObserver(Observer o){
        if(!observers.contains(o)){
            observers.add(o);
        }
    }
	//移除观察者
    public void removeObserver(Observer o){
        if(observers.contains(o)){
            observers.remove(o);
        }
    }
	//通知观察者
    public void notifyObservers(){
        for(Observer o: observers){
            o.update(content);
        }
    }
	//发布新消息内容
    public void releaseMessage(String content){
        this.content = content;
        notifyObservers();
    }
}

观察者具体实现

1
2
3
4
5
6
7
8
9
10
11
12
13
class User implements Observer{
    private Subject subject;
	//新用户关注公众号的时候就注册到发布者
    public User(Subject subject){
        this.subject = subject;
        subject.registerObserver(this);
    }
	//更新内容，message来自于发布者
    public void update(String message){
        System.out.println("订阅号\n" + message);
    }
}

客户端调用

1
2
3
4
5
6
7
8
9
10
11
public class ObserverPattern {
    public static void main(String[] args){
        OfficialCount officalCount = new OfficialCount();
        Observer o1 = new User(officalCount);
        Observer o2 = new User(officalCount);
        officalCount.notifyObservers();
        officalCount.releaseMessage("有生之年系列 猎人不休刊了");
        officalCount.releaseMessage("时事热评 台湾回归啦");
    }
}

总结

优点：
解除耦合，让耦合的双方都依赖于抽象，从而使得各自的变换都不会影响另一边的变换。

缺点：
在应用观察者模式时需要考虑一下开发效率和运行效率的问题，程序中包括一个被观察者、多个观察者，开发、调试等内容会比较复杂，而且在Java中消息的通知一般是顺序执行，那么一个观察者卡顿，会影响整体的执行效率，在这种情况下，一般会采用异步实现。

使用场景：

  1. 关联行为场景，需要注意的是，关联行为是可拆分的，而不是“组合”关系。
  2. 事件多级触发场景。
  3. 跨系统的消息交换场景，如消息队列、事件总线的处理机制。