一文带你彻底搞懂发布与订阅设计(观察者主题对象状态角色)

一、介绍

我们常说的发布订阅设计模式，也叫观察者模式，也就是事件监听机制，观察者模式订阅了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，当这个主题对象发生改变时，会通知所有的观察者对象，使他们能够自动的更新自己！

一个软件系统要求某个对象在发生变化时，某些其他的对象作出相应的改变，能做到这点的设计方案有很多，但观察者模式是满足这一要求的各种设计方案中最重要的一种。

从整体来看，观察者模式所涉及的角色有：

废话也不多说了，下面我们直接讲案例！

抽象主题角色，有增加观察者、删除观察者、通知观察者的功能，内容如下：

public abstract class AbstractSubject { / 用来保存注册的观察者对象 / private List<Observer> list = new ArrayList<Observer>(); / 注册观察者对象 / public void add(Observer observer){ list.add(observer); System.out.println("add an observer"); } / 删除观察者对象 @param observer / public void remove(Observer observer){ list.remove(observer); System.out.println("delete an observer"); } / 通知所有注册的观察者对象 @param state / public void notifyObservers(String state){ for (int i = 0; i < list.size(); i++) { list.get(i).update(state); } }}

具体主题角色，这个change方法放在子类中是因为可能不同的主题在改变观察者状态的时候会做一些不同的操作，因此就不统一放在父类Subject里面了，内容如下：

public class ConcreteSubject extends AbstractSubject{ private String state; public void change(String newState){ state = newState; System.out.println("主题状态：" + state); //状态发生改变，通知所有的观察者 super.notifyObservers(state); }}

观察者接口，内容如下：

public interface Observer { / 修改状态 @param state / void update(String state);}

具体观察者实现了观察者接口，内容如下：

public class ConcreteObserver implements Observer{ @Override public void update(String state) { System.out.println("观察者，收到状态：" + state); }}

客户端调用代码，一旦主题调用了change方法改变观察者的状态，那么观察者Observer里面的observerState全都改变了，内容如下：

public class ObserverClient { public static void main(String[] args) { //创建一个主题角色 ConcreteSubject subject = new ConcreteSubject(); //创建观察者对象 ConcreteObserver observer = new ConcreteObserver(); //将观察者加入主题对象上 subject.add(observer); //改变主题状态 subject.change("hello world"); }}

运行结果如下：

add an observer主题状态：hello world观察者，收到状态：hello world

这里只添加了一个观察者，有兴趣的可以试试看多添加几个观察者，效果都是一样的，主题角色改变状态，观察者状态全变。

观察者模式的两种模型

两种模型的比较

JDK是有直接支持观察者模式的，就是java.util.Observer这个接口，内容如下：

public interface Observer { / This method is called whenever the observed object is changed. An application calls an <tt>Observable</tt> object's <code>notifyObservers</code> method to have all the object's observers notified of the change. @param o the observable object. @param arg an argument passed to the <code>notifyObservers</code> method. / void update(Observable o, Object arg);}

这就是观察者的接口，定义的观察者只需要实现这个接口就可以了。
update()方法，被观察者对象的状态发生变化时，被观察者的notifyObservers()方法就会调用这个方法，内容如下：

public class Observable { private boolean changed = false; private Vector obs; / Construct an Observable with zero Observers. / public Observable() { obs = new Vector(); } / Adds an observer to the set of observers for this object, provided that it is not the same as some observer already in the set. The order in which notifications will be delivered to multiple observers is not specified. See the class comment. @param o an observer to be added. @throws NullPointerException if the parameter o is null. / public synchronized void addObserver(Observer o) { if (o == null) throw new NullPointerException(); if (!obs.contains(o)) { obs.addElement(o); } } ...}

这是被观察者的父类，也就是主题对象。
这是一个线程安全的类，是基于Vector实现的。

创建一个观察者，内容如下：

import java.util.Observable;import java.util.Observer;public class Watched implements Observer { @Override public void update(Observable o, Object arg) { System.out.println("观察者，收到状态：" + arg); }}

创建一个主题，内容如下：

import java.util.Observable;public class Subject extends Observable { private String data; public void setData(String newData){ System.out.println("主题状态：" + newData); data = newData; setChanged(); notifyObservers(data); }}

写一个main函数调用，内容如下：

public class WatchedClient { public static void main(String[] args) { //创建观察者对象 Watched watched = new Watched(); //创建主题 Subject subject = new Subject(); //将观察者对象加入主题 subject.addObserver(watched); //修改主题状态 subject.setData("hello world"); }}

运行结果，内容如下：

主题状态：hello world观察者，收到状态：hello world

看到主题对象改变的时候，观察者对象的状态也随之改变。

引入设计模式最主要的作用我认为就是两点：

使用观察者模式可以很好地做到这两点。
增加观察者，直接new出观察者并注册到主题对象之后就完事了，删除观察者，主题对象调用方法删除一下就好了，其余都不用管。
主题对象状态改变，内部会自动帮我们通知每一个观察者，是不是很方便呢？

观察者模式主要应用场景有：