有一个模式可以帮你的对象知悉情况，不会错过该对象感兴趣的事。程序运行时对象可以决定是否要被继续通知。观察者模式是JDK中使用最多的模式之一，非常有用。我们会一并介绍一对多的关系，以及松耦合。有了观察者，你将会消息灵通。
第二篇观察者让你的对象了解情况
我们看看报社的订阅模式
- 报社的业务就是出版报纸
- 向某家报社订阅报纸
- 当你不想看报纸的时候，取消订阅，他们就不会再送新报纸来。
- 只要报社还在运行，就会一直有人或单位向他们订阅报纸或者取消订阅报纸
出版者 + 订阅者 = 观察者模式
如果你了解报纸的订阅是怎么回事，其实就知道观察者模式是怎么回事，只是因为名字不一样：出版者称为主题，订阅者改为观察者。
让我们来看的更仔细一点：
鸭子跑过来告诉主题（魔法屋），我也当观察者，想看看主题里有什么宝贝。魔法屋的宝贝就是数据，一但有宝贝请通知我！鸭子注册（订阅）主题。
鸭子对象也是正儿八经的观察者了，鸭子静候通知，希望遇到宝贝。一旦收获通知，就能看到宝贝。
主题有了的新的数据， 鸭子看到了嘎嘎叫，终于等到梦想成真的时刻。
老鼠对于这个宝贝感到很无聊，于是不想在获取通知了。老鼠要求主题对象删除（取消订阅）自己。老鼠离开了！主题知道老鼠的请求后，把它从观察者中除名。
主题有了一个新的数据（宝贝），除了老鼠之外，每个观察者都会收到通知。老鼠心中暗暗的怀念这些宝贝，或许哪一天我还是会回来的。
观察者模式 定义了对象之间的一对多依赖，这样一来，当一个对象改变状态，它的所有依赖者都会收到通知并自动更新。
主题和观察者定义了一对多的关系。观察者依赖与主题（可观察者），只要可观察者状态一有变化，观察者就会被通知。实现观察者模式的方法不止一种，常见的一种是Subject 与 Observer 接口的类设计做法最常见。
定义观察者模式类图
问答
这和一对多关系有何关联？
主题时具有状态的对象，并且可以控制这些状态。也就是说，有一个具有状态的主题。观察者使用这些状态，虽然这些状态不属于他们。有许多的观察者，依赖主题来告诉他们状态何时改变了。这就产生了一个关系：一个主题对应多个观察者。
松耦合的威力
当两个对象之间松耦合，他们依然可以交互，但是不太清楚彼此之间的细节。
观察者模式提供了一种对象设计，让主题和观察者之间松耦合。
为什么呢？
主题只知道观察者实现了某个接口（也就是Observer接口），主题不需要知道观察者的具体类是谁、做了写什么或其它任何细节。
改变主题或者观察者其中一方，不会影响另一方。因为两者是松耦合，所以只要它们之间的接口仍被遵守，我们就可以自由的改变它们。
设计原则： 为了交互对象之间的松耦合设计而努力。
在继续的内容之前，请试着画出我们图片中 猫🐱 老鼠🐀 这些观察者和主题（魔法屋）需要的类。确定你的图能够显示出和各个部分如何结合起来，以及别的开发人员能够实现自己的观察者组件。
魔法屋
看看这个设计图，和你的设计图有何bu同？
实现魔法屋
依照上图中的类图， 我们要开始实现这个系统了。
package com.study.observer;
/**
* <==> 等同与标记
* 可观察者 <==> 主题 <==> 报社 <==>魔法屋 <==> 被观察者
* 报社向观察者提供任何数据对象
*/
public interface Subject {
//添加观察者
void registerObserver(Observer obj);
//移除观察者
void removeObserver(Observer obj);
//当主题状态改变时,这个方法被调用,通知所有的观察者
void notifyObserver(Object t);
//当主题状态改变时,这个方法被调用,通知所有的观察者
void notifyObserver();
}
/**
* 观察者
*/
public interface Observer {
// 当被观察者状态改变时,更新通知
void update(Subject o, Object data);
}
我们的魔法屋
package com.study.observer;
import java.util.ArrayList;
/**
* 可观察者 <==> 主题 <==> 报社 <==>魔法屋
*/
public class MagicHouse implements Subject {
// 存放订阅者
private ArrayList<Observer> observers = new ArrayList<Observer>();
/**
* 当注册观察者時，我们只需把它加到ArrayList即可。
*/
@Override
public void registerObserver(Observer obj) {
observers.add(obj);
}
/**
* 当观察者取消注册，我们把它从ArrayList中删除
*/
@Override
public void removeObserver(Observer obj) {
int i = observers.indexOf(obj);
if (i >= 0) {
observers.remove(obj);
}
}
/**
* 我们在这里把状态告诉每一个观察者，因为观察者都实现了update（）， 所以我们知道如何通知它们
*/
@Override
public void notifyObserver(Object t) {
for (Observer observer : observers) {
observer.update(this, t);
}
}
@Override
public void notifyObserver() {
notifyObserver(null);
}
// 魔法屋弄出一个宝贝
public void publish(String news) {
notifyObserver(news);
}
}
Tom and Jerry观察者
package com.study.observer;
/**
* Tom 观察者
*/
public class TomObserver implements Observer {
// 观察者名字
private String name;
private Object mData;
/**
* @param observable 创建观察者时添加到魔法屋
* @param name 观察者的名字
*/
public TomObserver(Subject observable, String name) {
observable.registerObserver(this);
this.name = name;
}
/**
* @param observable 魔法屋
* @param data 魔法屋发送过来的数据 <==> Jerry看到的宝贝
*/
@Override
public void update(Subject observable, Object data) {
this.mData = data;
System.out.println(name + mData);
}
}
package com.study.observer;
/**
* Jerry 观察者
*/
public class RatObserver implements Observer {
// 观察者名字
private String name;
private Object mData;
/**
* @param observable 创建观察者时添加到魔法屋
* @param name 观察者的名字
*/
public RatObserver(Subject observable, String name) {
observable.registerObserver(this);
this.name = name;
}
/**
* @param observable 魔法屋
* @param data 魔法屋发送过来的数据 <==> Jerry看到的宝贝
*/
@Override
public void update(Subject observable, Object data) {
this.mData = data;
System.out.println(name + mData);
}
}
魔法屋建设的差不多了，我们还需要一些代码将这一切连接起来。这是我们的第一次尝试，现在开始测试吧：
package com.study.observer;
public class TestObserver {
public static void main(String[] args) {
// 创建被观察者
MagicHouse magicHouse = new MagicHouse();
// 创建两个不同的观察者
new TomObserver(magicHouse, "汤姆-Tom");
new RatObserver(magicHouse, "杰瑞-Jerry");
// 更新可观察者的数据，会自动通知所有已注册的观察者
magicHouse.publish("有一个鸡腿");
}
}
运行程序，让观察者（魔法屋）产生宝贝
汤姆-Tom有一个鸡腿
杰瑞-Jerry有一个鸡腿
使用Java内置的观察者模式
到目前为止，我们已经从无到有的完成了观察者模式。但是，Java API有内置的观察者模式。java.util包（package）内包含最基本的Observer接口和Observable类，这和我们的Subject接口和Observer接口很相似。Observer接口和Observable类使用起来很方便，因为许多功能已经实现准备好了了。你甚至可以使用推或者拉的方法传递数据，稍后就会看到这样的例子。
为了更了解java.util.Observer和java.util.Observable，看看下面的图，这是修改后的魔法屋OO设计。
Java内置的观察者模式如何运作
和我们在魔法屋中的实现类似，但有一些小差异。最明显的差异是MagicHourse 现在扩展自Observable类，并继承到一些添加，删除，通知观察者的方法（以及其它的一些方法）。用法和我们之前写的非常类似！
可观察者如何送出通知.....
1 先调用setChange()方法，标记状态已经改变的事情。
protected synchronized void setChanged() {
changed = true;
}
2 然后调用两种notifyObservers()方法中的一个：
notifyObservers() 或 notifyObservers(Object args)，当通知时，传递任何数据的对象给每一个观察者。
public void notifyObservers(Object arg) {
/*
* a temporary array buffer, used as a snapshot of the state of
* current Observers.
*/
Object[] arrLocal;
synchronized (this) {
//当状态没有发生改变，不通知观察者
if (!changed)
return;
arrLocal = obs.toArray();
clearChanged();
}
//主题通知观察者
for (int i = arrLocal.length-1; i>=0; i--)
((Observer)arrLocal[i]).update(this, arg);
}
protected synchronized void clearChanged() {
changed = false;
}
public synchronized boolean hasChanged() {
return changed;
}
这样做有其必要性，setChange（）方法可以让你在更新观察者时，有更多的弹性，你可以适当的通知观察者，。比方说，魔法屋没有任何数据更新，调用notifyObserders()这个方法就不好了。另外也有一个hasChanged()方法告诉你changed标志的当前状态
利用内置的支持做魔法屋
首先，我们把魔法屋改成使用java.util.Observable
package head.firest.inner.observer;
import java.util.Observable;
/**
* 可观察者 <==> 主题 <==> 报社 <==>魔法屋
*/
public class MagicHourse extends Observable {
//我们不需要记住观察者们而建立数据结构
// 魔法屋弄出一个宝贝，调用notifyObservers()之前，先调用setChanged()方法来指示状态已经改变
public void publish(String news) {
setChanged();
notifyObservers(news);
}
}
现在，让我们重做TomObserver
package head.firest.inner.observer;
import java.util.Observable;
import java.util.Observer;
/**
* Tom 观察者
*/
public class TomObserver implements Observer {
// 观察者名字
private String name;
private Object mData;
private Observable observeable;
/**
* @param observeable 创建观察者时添加到魔法屋
* @param name 观察者的名字
*/
public TomObserver(Observable observeable, String name) {
this.observeable=observeable;
observeable.addObserver(this);
this.name = name;
}
/**
* @param observeable 魔法屋
* @param data 魔法屋发送过来的数据 <==> Tom看到的宝贝
*/
@Override
public void update(Observable o, Object arg) {
if(o instanceof MagicHourse) { //先确定可观察者属于MagicHourse类
this.mData = arg;
System.out.println(name + mData);
}
}
}
JerryObserver和TomObserver观察者很相似，大家动手写写。
运行代码
杰瑞-Jerry有一个鸡腿
汤姆-Tom有一个鸡腿
嗯，你注意到差别了吗？再看一次 。。。。。。
杰瑞-Jerry有一个鸡腿
汤姆-Tom有一个鸡腿
汤姆-Tom有一个鸡腿
杰瑞-Jerry有一个鸡腿
不要依赖观察者被通知的次序，在我们的程序中，如果依赖调用次序，我们的代码就是错的。这绝对不是我们认为的松耦合。
Observable 将关键的方法保护了起来
如果你看看Observable API,你就会发布setChanged()方法被保护了起来。这意味者，除非你继承Observable类，否则你无法创建Observable对象。这个设计违法了第二个设计原则：多用组合，少用继承。
如果你能够扩展java.util.Observable，那么它可以符合你的需求。否则，你可能要自己实现一套观察者模式。你已经熟悉了观察者模式，应该都能熟练使用它们。
在JDK中，还有一些地方可以找到观察者模式
让我们看看一个简单的Swing API:JButton 。如果你观察下JButton的超类AbstractButton，会看到许多增加与删除倾听者的方法。比方说ActionListener让你倾听可能发生在按钮上的动作。
我们的程序很简单，你有一个按钮，上面写着Should I do it ?（我该做吗？）当你按下按钮，倾听者必须回答此问题。我们实现了两个倾听者，一个是天使（AngelListener），一个是魔鬼（DevilListener)。程序的运行行为如下：
我们只需一个JButton对象，把它加到JFrame，然后设置好倾听者就行。
package head.firest.inner.observer;
import java.awt.BorderLayout;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
/**
* 倾听者小例子
*
*/
public class SwingObserverExample {
public static void main(String[] args) {
SwingObserverExample swingObserverExample = new SwingObserverExample();
swingObserverExample.go();
}
public void go() {
JFrame frame = new JFrame();
//设置窗口大小
frame.setBounds(0, 0, 300, 250);
Toolkit toolkit = Toolkit.getDefaultToolkit();
int x = (int) (toolkit.getScreenSize().getWidth() - frame.getWidth()) / 2;
int y = (int) (toolkit.getScreenSize().getHeight() - frame.getHeight()) / 2;
//设置窗口剧中显示
frame.setLocation(x, y);
//创建按，添加天使和魔鬼点击监听事件
JButton button = new JButton("Should I do it?");
button.addActionListener(new AagelListener());
button.addActionListener(new DevilListener());
frame.getContentPane().add(BorderLayout.CENTER, button);
// 显示窗口
frame.setVisible(true);
}
class AagelListener implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
System.out.println("Don't do it,you might regret it!");
}
}
class DevilListener implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
System.out.println("Come on,do it!");
}
}
}
运行结果
Come on,do it!
Don't do it,you might regret it!
设计箱内的工具
OO原则
- 针对接口编程，不针对实现编程
- 为交互对象之间的松耦合设计而努力
观察者模式 在对象之间定义一对多的依赖，当一个对象改变状态，依赖它的对象都会收到通知，并自动更新。
项目地址：https://github.com/githubwwj/DesignPattern
文章参考自 Head Firest 设计模式一书
