Java设计模式之观察者模式

发表于 |

观察者模式是一种比较经典的模式。被观察者可以对应多个观察者，是一种一对多的模式。被观察者一旦有变动，就会通知到所有注册的观察者，被观察者可以增加也可以移除，易于扩展。观察者模式又被称之为发布订阅模式，监听器模式等等，下面通过一个买票的例子来介绍一下这种模式

买票

买票，这个动作隐含了两个主体，一个是人，一个是票，同时这个动作还包含了一个隐藏的动作，通知。好了，这个通知就是我们用观察者模式的地方了。

大麦网有这么个功能，缺货登记，就是有票了就告诉登记的人。那我们改造一下，变成票有变化，就通知登记人。

上面的例子可以很明显分辨出来，票就是被观察的对象，人是观察者。

被观察者

下一步，来梳理一下通知这部分需要哪些功能。

首先，肯定是我订阅这个票的动态，暂时取名为addObserver，其次有订阅动态就有取消订阅removeObserver，当然最重要的还是通知notifyObservers。

下面我们就定义一个抽象类Observable—实现上面所提到的三个基本功能

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
package me.learn.pattern.observer;

import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;

public abstract class Observable {

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

    protected void addObserver(Observer observer) {
        this.observers.add(observer);
    }

    protected void addObservers(Observer... observers) {
        this.observers.addAll(Arrays.asList(observers));
    }

    protected void removeObserver(Observer observer) {
        this.observers.remove(observer);
    }

    protected void removeAllObservers() {
        this.observers.clear();
    }

    protected void notifyObservers(Object data) {
        for (Observer observer : observers) {
            observer.update(this, data);
        }
    }

}

观察者

买票的另一主体是人。那么一个人在这个过程中他想要的其实很简单，就是通知到我，就像大麦的缺货登记，我登记了，你要通知我，也就是调用我的方法，然后我可以做我收到这个通知之后的事情。那就很明确了，观察者需要的就是一个类似更新update的方法。我们定义一下这个观察者的接口。

1
2
3
4
5
package me.learn.pattern.observer;

public interface Observer {
    void update(Observable observable, Object data);
}

接下来只要定义票继承被观察者基类，人实现观察者方法就可以了。

再说买票

其实，上面的过程已经说完了观察者模式，但是让我们再想想缺货登记。票和人，其实都既是观察者也是被观察者，票需要被观察余量，也需要观察人的购票；人既需要观察票的动态，也是被观察是否购票的对象。所以我们来写一个既是观察者也是被观察者的例子吧。

首先定义票，继承被观察者，并实现观察者。

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
53
54
55
56
57
58
59
package me.learn.pattern.observer;

import java.util.Objects;
import java.util.concurrent.atomic.AtomicInteger;

public class Ticket extends Observable implements Observer {

    private AtomicInteger left;

    public Ticket() {
        this.left = new AtomicInteger(0);
    }

    public Ticket(int left) {
        this.left = new AtomicInteger(left);
    }

    public synchronized void setLeft(int left) {
        this.left.set(left);
    }

    public synchronized void sold(int number) {
        if (this.left.get() >= number) {
            this.left.compareAndSet(this.left.get(), this.left.intValue() - number);
            super.notifyObservers(this.left.get());
        } else {
            System.out.println("sold out");
        }
    }

    public synchronized void soldAllTickets() {
        this.left.set(0);
        super.notifyObservers(this.left.get());
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Ticket ticket = (Ticket) o;
        return Objects.equals(left, ticket.left);
    }

    @Override
    public int hashCode() {
        return Objects.hash(left);
    }

    @Override
    public String toString() {
        return "Ticket";
    }

    @Override
    public void update(Observable observable, Object data) {
        System.out.println(observable + " buys "+data+" ticket");
        sold((Integer) data);
    }
}

其次，购票人。

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
package me.learn.pattern.observer;

public class PersonWhoWantTickets extends Observable implements Observer {

    private String name;

    public PersonWhoWantTickets(String name) {
        this.name = name;
    }

    public void buyOneTicket() {
        System.out.println(name + " buys one ticket");
        super.notifyObservers(1);
    }

    @Override
    public void update(Observable observable, Object data) {
        System.out.println(this + " received notice# tickets left["+data+"]");
        if ((int)data == 0) {
            System.out.println("oh, i can not buy more");
        } else {
            buyOneTicket();
        }
    }

    @Override
    public String toString() {
        return "PersonWhoWantTickets{" +
                "name='" + name + '\'' +
                '}';
    }

    public static void main(String[] argv) {
        Ticket ticket = new Ticket(13);

        PersonWhoWantTickets person = new PersonWhoWantTickets("person");
        person.addObserver(ticket);
        ticket.addObservers(person);
        ticket.sold(5);

        person.buyOneTicket();
    }
}

有意思，这样就有意思了。