源代码：https://gitee.com/AgentXiao/BehavioralPatterns
要点：
1、观察者模式的使用范围及核心
2、自定义实现观察者模式
3、类库提供的观察者模式
4、开发中的使用场景
一、场景
（1）网站上，很多人订阅了”java主题”的新闻。当有这个主题新闻时，就会将这些新闻发给所有订阅的人。
（2）大家一起玩CS游戏时，服务器需要将每个人的方位变化发给所有的客户。
上面这些场景，我们都可以使用观察者模式来处理。我们可以把多个订阅者、客户称之为观察者； 需要同步给多个订阅者的数据封装到对象中，称之为目标。
二、观察者模式
观察者模式主要用于1：N的通知。当目标对象Subject的状态改变时，及时地告诉一系列对象（观察者对象），令观察者对做出响应。
通知观察者的方式：
（1）推：强制推送，观察者只能被动接收！
（2）拉：观察者自主觉得什么时候获取目标对象的信息！
观察者模式的类图
三、自定义实现
1、目标对象
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName Subject
* @Description 目标对象
* @Author xwd
* @Date 2018/10/28 18:25
*/
public class Subject {
protected List list = new ArrayList<>();//存放观察者对象
/**
* @MethodName registerObserver
* @Descrition 注册观察者
* @Param [observer]
* @return void
*/
public void registerObserver(Observer observer){
list.add(observer);
}
/**
* @MethodName removeObserver
* @Descrition 移除观察者
* @Param [observer]
* @return void
*/
public void removeObserver(Observer observer){
list.remove(observer);
}
/**
* @MethodName notifyAllObserver
* @Descrition 通知所有的观察者
* @Param []
* @return void
*/
public void notifyAllObserver(){
for(Observer observer:list){
observer.getMsg(this);
}
}
}
2、具体目标对象
/**
* @ClassName ConcreteSubject
* @Description 具体目标对象
* @Author xwd
* @Date 2018/10/28 18:32
*/
public class ConcreteSubject extends Subject{
private int state;//状态值，只是简单的模拟该目标的状态
/**
* @MethodName getState
* @Descrition 获取状态值
* @Param []
* @return int
*/
public int getState() {
return state;
}
/**
* @MethodName setState
* @Descrition 改变状态值并通知所有的观察者
* @Param [state]
* @return void
*/
public void setState(int state) {
this.state = state;
this.notifyAllObserver();
}
}
3、抽象观察者
/**
* @InterfaceName Observer
* @Description 观察者
* @Author xwd
* @Date 2018/10/28 18:25
*/
public interface Observer {
/**
* @MethodName getMsg
* @Descrition 获得指定目标对象的信息
* @Param [subject]
* @return void
*/
void getMsg(Subject subject);
}
4、具体观察者
/**
* @ClassName ObserverA
* @Description 观察者A
* @Author xwd
* @Date 2018/10/28 18:35
*/
public class ObserverA implements Observer{
private int MyState;//同样，只是简单的模拟状态
/**
* @MethodName getMsg
* @Descrition 获得状态值。实际中需要改进，因为具体的目标对象不止一个时，就不能通过转型进行实现
* @Param [subject]
* @return void
*/
@Override
public void getMsg(Subject subject) {
MyState = ((ConcreteSubject)subject).getState();
}
public int getMyState() {
return MyState;
}
public void setMyState(int myState) {
MyState = myState;
}
}
/**
* @ClassName ObserverB
* @Description 观察者B
* @Author xwd
* @Date 2018/10/28 18:35
*/
public class ObserverB implements Observer{
private int MyState;//同样，只是简单的模拟状态
/**
* @MethodName getMsg
* @Descrition 获得状态值。实际中需要改进，因为具体的目标对象不止一个时，就不能通过转型进行实现
* @Param [subject]
* @return void
*/
@Override
public void getMsg(Subject subject) {
MyState = ((ConcreteSubject)subject).getState();
}
public int getMyState() {
return MyState;
}
public void setMyState(int myState) {
MyState = myState;
}
}
/**
* @ClassName ObserverC
* @Description 观察者C
* @Author xwd
* @Date 2018/10/28 18:35
*/
public class ObserverC implements Observer{
private int MyState;//同样，只是简单的模拟状态
/**
* @MethodName getMsg
* @Descrition 获得状态值。实际中需要改进，因为具体的目标对象不止一个时，就不能通过转型进行实现
* @Param [subject]
* @return void
*/
@Override
public void getMsg(Subject subject) {
MyState = ((ConcreteSubject)subject).getState();
}
public int getMyState() {
return MyState;
}
public void setMyState(int myState) {
MyState = myState;
}
}
5、客户
/**
* @ClassName Client
* @Description 测试观察者模式
* @Author xwd
* @Date 2018/10/28 18:45
*/
public class Client {
public static void main(String[] args) {
//实例化客观存在的对象：目标对象和观察者
Subject subject = new ConcreteSubject();
ObserverA a = new ObserverA();
ObserverB b = new ObserverB();
ObserverC c = new ObserverC();
//建立联系
subject.registerObserver(a);
subject.registerObserver(b);
subject.registerObserver(c);
//改变目标对象的状态并通知所有的观察者
((ConcreteSubject) subject).setState(5000);
subject.notifyAllObserver();
//查看观察者的状态
System.out.println(a.getMyState());
System.out.println(b.getMyState());
System.out.println(c.getMyState());
}
}
6、测试结果
测试结果
四、类库实现
javaSE提供了java.util.Observerable和java.util.Observer来实现观察者模式。
1、具体目标对象
/**
* @ClassName ConcreteSubject
* @Description 具体目标对象
* @Author xwd
* @Date 2018/10/28 19:04
*/
public class ConcreteSubject extends Observable {
private int state;
/**
* @MethodName setState
* @Descrition 目标对象状态发生改变同时通知所有的观察者
* @Param [state]
* @return void
*/
public void setState(int state) {
this.state = state;//目标对象的状态发生了改变
setChanged();//表示目标对象已经做了更改
notifyObservers(state);//通知所有的观察者
}
public int getState() {
return state;
}
}
2、具体观察者
/**
* @ClassName ObserverA
* @Description 观察者
* @Author xwd
* @Date 2018/10/28 19:11
*/
public class ObserverA implements Observer {
private int state;
/**
* @MethodName update
* @Descrition 更新状态
* @Param [o, arg]
* @return void
*/
@Override
public void update(Observable o, Object arg) {
state = ((ConcreteSubject)o).getState();
}
public int getState() {
return state;
}
public void setState(int state) {
this.state = state;
}
}
3、客户
import pri.xiaowd.observer2.ConcreteSubject;
import pri.xiaowd.observer2.ObserverA;
import pri.xiaowd.observer.*;
/**
* @ClassName Client
* @Description 测试观察者模式
* @Author xwd
* @Date 2018/10/28 18:45
*/
public class Client {
public static void main(String[] args) {
//实例化客观存在的对象：目标对象和观察者
ConcreteSubject subject = new ConcreteSubject();
ObserverA a = new ObserverA();
ObserverA b = new ObserverA();
ObserverA c = new ObserverA();
//建立联系
subject.addObserver(a);
subject.addObserver(b);
subject.addObserver(c);
//改变目标对象的状态并通知所有的观察者
subject.setState(8000);
//查看观察者的状态
System.out.println(a.getState());
System.out.println(b.getState());
System.out.println(c.getState());
}
}
测试可得，我们实现了相同的功能!
在父类java,util.Observable中，有如下内容：
java,util.Observable
可见底层是通过Vector类实现观察者的存储的，但是这从jdk1.9开始就已经过时了，因此使用类库来实现观察者模式也是已经过时了！
五、总结
开发中常见的场景：
- 聊天室程序的，服务器转发给所有客户端
- 网络游戏(多人联机对战)场景中，服务器将客户端的状态进行分发
- 邮件订阅
- Servlet中，监听器的实现
- Android中，广播机制
- JDK的AWT中事件处理模型,基于观察者模式的委派事件模型(Delegation Event Model)
- 京东商城中，群发某商品打折信息