观察者模式是一种比较经典的模式。被观察者可以对应多个观察者，是一种一对多的模式。被观察者一旦有变动，就会通知到所有注册的观察者，被观察者可以增加也可以移除，易于扩展。观察者模式又被称之为发布订阅模式，监听器模式等等，下面通过一个买票的例子来介绍一下这种模式
买票
买票，这个动作隐含了两个主体，一个是人，一个是票，同时这个动作还包含了一个隐藏的动作，通知。好了，这个通知就是我们用观察者模式的地方了。
大麦网有这么个功能，缺货登记，就是有票了就告诉登记的人。那我们改造一下，变成票有变化，就通知登记人。
上面的例子可以很明显分辨出来，票就是被观察的对象，人是观察者。
被观察者
下一步，来梳理一下通知这部分需要哪些功能。
首先，肯定是我订阅这个票的动态，暂时取名为addObserver，其次有订阅动态就有取消订阅removeObserver，当然最重要的还是通知notifyObservers。
下面我们就定义一个抽象类Observable---实现上面所提到的三个基本功能
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的方法。我们定义一下这个观察者的接口。
package me.learn.pattern.observer;
public interface Observer {
void update(Observable observable, Object data);
}
接下来只要定义票继承被观察者基类，人实现观察者方法就可以了。
再说买票
其实，上面的过程已经说完了观察者模式，但是让我们再想想缺货登记。票和人，其实都既是观察者也是被观察者，票需要被观察余量，也需要观察人的购票；人既需要观察票的动态，也是被观察是否购票的对象。所以我们来写一个既是观察者也是被观察者的例子吧。
首先定义票，继承被观察者，并实现观察者。
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);
}
}
其次，购票人。
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();
}
}
