一、概述
观察者模式是对象的行为模式，又叫发布-订阅(Publish/Subscribe)模式、模型-视图(Model/View)模式、源-监听器(Source/Listener)模式或从属者(Dependents)模式。
观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使它们能够自动更新自己。
UML 类图
Subject：一般是抽象类或者接口，他把所有对观察者对象的引用保存在一个聚集里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象。
Observer：抽象观察者，为所有具体的观察者定义一个接口，在得到主题的通知时更新自己。这个接口方法叫做更新接口。抽象观察者一般用一个抽象类或者一个接口实现。更新接口通常包含一个update 方法，这个方法叫更新方法。
ConcreteSubject：具体主题或者具体通知者，将有关状态存入具体观察者对象，在具体主题的内部状态改变时，给所有等级过得观察者发出通知。具体主题角色通常用一个具体子类实现。
ConcreteObserver：具体观察者，实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相互。具体观察者角色可以保持一个指向具体主题对象的引用。具体观察者角色通常用一个具体子类实现。
二、实例
代码：
Subject
/**
* 被观察者 Subject：
* 目标知道它的观察者。可以有任意多个观察者观察同一个目标
* 提供注册和删除观察者对象的接口
*/
public interface IWorker {
void attach(IPlayer mObserver);
void detach(IPlayer mObserver);
// 这种是推模型
// 拉模型通常都是把主题对象当做参数传递 void notice(IPlayer player)
void notice();
}
具体的被观察者
/**
* 具体的被观察者
*/
public class Worker implements IWorker {
private List<IPlayer> players;
private String tactical;
private String train;
public Worker() {
players = new ArrayList<IPlayer>();
}
@Override
public void attach(IPlayer mObserver) {
players.add(mObserver);
}
@Override
public void detach(IPlayer mObserver) {
int i = players.size();
if (i > 0)
players.remove(mObserver);
}
@Override
public void notice() {
for (int i = 0; i < players.size(); i++) {
players.get(i).update(tactical, train);
}
}
public void setNotice(String tactical, String train) {
this.tactical = tactical;
this.train = train;
// 信息更新完毕，通知所有的观察者
notice();
}
}
Observer
/**
* 观察者 Observer： 为那些在目标发生改变时需要获得通知的对象定义一个更新接口。
*/
public interface IPlayer {
void update(String tactical, String train);
}
具体的观察者
/**
* 具体的观察者
*/
public class Player implements IPlayer {
private String name;
private String tactical;
private String train;
public Player(String name) {
this.name = name;
}
@Override
public void update(String tactical, String train) {
this.tactical = tactical;
this.train = train;
todayPlay();
}
public void todayPlay() {
System.out.println(name + "今天安排：" + tactical + "," + train);
}
}
Client
public class Client {
public static void main(String[] args) {
Worker worker = new Worker();
IPlayer messi = new Player("messi");
IPlayer cluo = new Player("cluo");
worker.attach(messi);
worker.attach(cluo);
worker.detach(messi);
worker.setNotice("首发", "盘带");
}
}
结果：
三、总结：
通过上面的例子可以看出，Worker 和 Player 两者处于松耦合状态，甚至是零耦合状态，如果某一需求改变了，需要进行代码的修改，这并不会涉及到另一者，这是非常好的松耦合设计，只需要实现接口就好。
在观察者模式中又有两种模型，推模型和拉模型
-
推模型：被观察者向观察者推送自身的详细信息，不管观察者是否需要，推送的信息通常是主题对象的全部或部分数据
-
拉模型：被观察者通过把自身的引用传递给观察者，需要观察者自行通过该引用来获取相关的信息。我们上面的例子使用的就是推模型。把Worker 的两个成员变量推送给观察者Player，如果要把上面的例子改成拉模型也可以，只需要把notice() 方法改为notice(IPlayer play) 即可。
-
Java 提供的对观察者模式的支持就是拉模式， 在JAVA语言的java.util库里面，提供了一个Observable类以及一个Observer接口，构成JAVA语言对观察者模式的支持。
被观察者：
public class Watched extends Observable {
private String data = "123";
public String getData() {
return data;
}
public void setData(String data) {
if (this.data.equals(data)) {
this.data = data;
setChanged();
}
notifyObservers();
}
}
观察者：
public class Watcher implements Observer {
public Watcher(Observable o) {
// 将该观察者放入待通知观察者里
o.addObserver(this);
}
@Override
public void update(Observable o, Object arg) {
System.out.println("状态发生改变：" + ((Watched) o).getData());
}
}
客户端：
public class WatchClient {
public static void main(String[] args) {
// 创建被观察者对象
Watched watched = new Watched();
// 创建观察者对象，并将被观察者对象登记
Watcher watcher = new Watcher(watched);
// 给被观察者状态赋值
watched.setData("123");
watched.setData("abc");
watched.setData("!@#");
}
}
结果：
两者区别：
-
推模型是假定主题对象知道观察者需要的数据；而拉模型是主题对象不知道观察者具体需要什么数据，没有办法的情况下，干脆把自身传递给观察者，让观察者自己去按需要取值
-
推模型可能会使得观察者对象难以复用，因为观察者的update()方法是按需要定义的参数，可能无法兼顾没有考虑到的使用情况。这就意味着出现新情况的时候，就可能提供新的update()方法，或者是干脆重新实现观察者；而拉模型就不会造成这样的情况，因为拉模型下，update()方法的参数是主题对象本身，这基本上是主题对象能传递的最大数据集合了，基本上可以适应各种情况的需要。
经过上面的几个例子，相信大家对观察者模式有了一个比较深刻的认识了，最后我们再说说观察者模式可以用在什么地方。比如我们有两个对象，一个对象依赖于另一个对象的变化而变化，此时我们可以将这两个对象抽象出来，做成接口，利用观察者模式来进行解耦，又或者，当一个对象发生变化的时候，需要通知别的对象来做出改变，但又不知道这样的对象有多少个，此时利用观察者模式非常合适。Javaweb 的Listener 的实现思想就是这样的。