观察者模式
观察者模式定义了一个一对多的依赖关系，让多个观察者对象同时监听同一个主题对象。当这个主题状态发生改变时，会通知所有观察者对象，让它们自动更新自己。
场景
- 聊天室程序的创建。服务器创建好后，A、B、C三个客户端连接好公开聊天。A向服务器发送数据，服务器在将数据分别发送给其他在线客户。也就是说，每个客户端需要更新服务器端的数据。
- 网站上，很多人订阅了“Java主题”的新闻。当有这个主题新闻时，就会将这些新闻发给所有订阅的人。
- 大家在玩CS游戏时，服务器需要将每个人的方位变化发给所有的客户。
上面这些场景，我们都可以使用观察者模式来处理。我们可以把多个订阅者、客户称之为观察者；需要同步给多个订阅者的数据封装到对对象中，称之为目标。
模式结构
结构图
- 抽象主题角色(Subject): 把所有对观察者对象的引用保存在一个集合中，每个抽象主题角色都可以有任意数量的观察者。抽象主题提供一个接口，可以增加和删除观察者角色。一般用一个抽象类和接口来实现。
- 具体主题角色(ConcreteSubject): 在具体主题内部状态改变时，给所有登记过的观察者发出通知。具体主题角色通常用一个子类实现。
- 抽象观察者角色(Observer)： 为所有具体的观察者定义一个接口，在得到主题的通知时更新自己。
- 具体观察者角色(ConcreteObserver)： 该角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。通常用一个子类实现。如果需要，具体观察者角色可以保存一个指向具体主题角色的引用。
代码
抽象主题角色(Subject)
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
| package designMode.Observer;
import java.util.ArrayList;
import java.util.List;
public class Subject {
private List<Observer> list = new ArrayList<>();
public void registerObserve(Observer observer) {
list.add(observer);
}
public void removeObserve(Observer observer) {
list.remove(observer);
}
public void notifyAllObserve() {
for (Observer observer : list) {
observer.update(this);
}
}
}
|
具体主题角色(ConcreteSubject)
1
2
3
4
5
6
7
8
9
10
11
12
13
| public class ConcreteSubject extends Subject {
private int state;
public int getState() {
return state;
}
public void setState(int state) {
this.state = state;
this.notifyAllObserve();
}
}
|
抽象观察者角色(Observer)
1
2
3
| public interface Observer {
void update(Subject subject);
}
|
具体观察者角色(ConcreteObserver)
1
2
3
4
5
6
7
8
9
| public class ConcreteObserver implements Observer {
private int myState;
@Override
public void update(Subject subject) {
myState = ((ConcreteSubject) subject).getState();
System.out.println("观察者得到的值：" + myState);
}
}
|
客户端
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| public class Client {
public static void main(String[] args) {
ConcreteSubject concreteSubject=new ConcreteSubject();
ConcreteObserver concreteObserver1=new ConcreteObserver();
ConcreteObserver concreteObserver2=new ConcreteObserver();
ConcreteObserver concreteObserver3=new ConcreteObserver();
concreteSubject.addObserver(concreteObserver1);
concreteSubject.addObserver(concreteObserver2);
concreteSubject.addObserver(concreteObserver3);
concreteSubject.setState(100);
}
}
|
控制台
1
2
3
| 观察者得到的值：2
观察者得到的值：2
观察者得到的值：2
|
推模式与拉模式
- 推模式：每次都会把通知以广播的方式发送给所有观察者，所有观察者只能被动接收， 推送的信息通常是主题对象的全部或部分数据 。
- 拉模式： 主题对象在通知观察者的时候，只传递少量信息。如果观察者需要更具体的信息，由观察者主动到主题对象中获取，相当于是观察者从主题对象中拉数据。一般这种模型的实现中，把主题对象自身通过update()方法传递给观察者，这样在观察者需要获取数据的时候，就可以通过这个引用来获取了 。
- 比较： 推模式是假定主题对象知道观察者需要的数据；而拉模式是主题对象不知道观察者具体需要什么数据，没有办法的情况下，干脆把自身传递给观察者，让观察者自己去按需要取值。
Java自带对观察者模式的支持
JavaSE中提供了java.util.Observable和java.util.Observer来实现观察者模式。
具体目标对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| public class ConcreteSubject extends Observable{
private int state;
public int getState() {
return state;
}
public void setState(int state) {
this.state = state;
setChanged();
notifyObservers(state);
}
}
|
具体观察者
1
2
3
4
5
6
7
8
| public class ConcreteObserver implements Observer{
private int mystate;
public void update(Observable observable, Object arg) {
mystate=((ConcreteSubject) observable).getState();
System.out.println("观察者接收到的状态:"+mystate);
}
}
|
客户端
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| public class Client {
public static void main(String[] args) {
ConcreteSubject concreteSubject=new ConcreteSubject();
ConcreteObserver concreteObserver1=new ConcreteObserver();
ConcreteObserver concreteObserver2=new ConcreteObserver();
ConcreteObserver concreteObserver3=new ConcreteObserver();
concreteSubject.addObserver(concreteObserver1);
concreteSubject.addObserver(concreteObserver2);
concreteSubject.addObserver(concreteObserver3);
concreteSubject.setState(100);
}
}
|
控制台
1
2
3
| 观察者接收到的状态:100
观察者接收到的状态:100
观察者接收到的状态:100
|
