设计模式（二）观察者模式
一、模式动机
建立对象之间的一对多关系，一个对象发生改变时会自动通知其他对象，其他对象将做出相应的反应。其中，发生改变的对象叫做主题，被通知的对象叫做观察者。在使用过程中可以根据需要增加和删除观察者，这样系统扩展就变得非常容易。
二、模式定义
在对象之间定义一对多的依赖，当一个对象改变时，依赖它的对象会收到通知，并自动更新。观察者模式又叫做发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-监听器（Source/Listener）模式或从属者（Dependents）模式。
三、模式结构
观察者模式包含以下4个角色：
1、Subject：抽象主题角色，包含了所有观察者的引用（比如可以保存在ArrayList中），通知观察者以及添加、删除观察者的抽象方法；
2、ConcreteSubject：具体主题角色，继承自Subject，实现了其中的抽象方法；
3、Observer：抽象观察者角色，包含了一个更新自身状态的抽象方法，在获知主题更新后，将调用此方法；
4、ConcreteObserver：具体观察者角色，继承自Observer，实现了更新自身状态的抽象方法。如果有必要，则还可以保存主题的引用。
四、代码实现
抽象主题类Subject：
import java.util.ArrayList; import java.util.List; public abstract class Subject { private List<Observer> observerList = new ArrayList<>(); /** * 添加观察者 * @param observer */ public void attach(Observer observer){ observerList.add(observer); } /** * 删除观察者 * @param observer */ public void detach(Observer observer){ observerList.add(observer); } /** * 通知观察者 * @param newState */ public void notifyObservers(String newState){ for(Observer observer:observerList){ observer.update(newState); } } }
具体主题类ConcreteSubject：
public class ConcreteSubject extends Subject { private String subjectState; public void setNewState(String newState){ this.subjectState = newState; System.out.println("主题状态发生改变，新的状态为：" + newState); this.notifyObservers(newState); } }
抽象观察者接口Observer：
public interface Observer { /** * 观察者更新自身状态 * @param newState 新的状态 */ public void update(String newState); }
具体观察者类ConcreteObserverA：
public class ConcreteObserverA implements Observer { private String oberverState; @Override public void update(String newState) { oberverState = newState; System.out.println("观察者A状态已改变，新的状态为：" + newState); } }
具体观察者类ConcreteObserverB：
public class ConcreteObserverB implements Observer{ private String observerState; @Override public void update(String newState) { observerState = newState; System.out.println("观察者B状态已改变，新的状态为：" + newState); } }
在客户端类Client中进行测试：
public class Client { public static void main(String[] args){ ConcreteSubject subject = new ConcreteSubject(); Observer observerA = new ConcreteObserverA(); subject.attach(observerA); Observer observerB = new ConcreteObserverB(); subject.attach(observerB); // 主题状态改变 subject.setNewState("new state"); } }
运行结果：
主题状态发生改变，新的状态为：new state
观察者A状态已改变，新的状态为：new state
观察者B状态已改变，新的状态为：new state
五、观察者模式中的推和拉
主题的状态中有时会包含很多信息，在上面的例子中，我们把主题中的所有信息都推给了观察者，但观察者可能只需要这些信息中的一部分，实现方法是在主题中将要推送给观察者的信息字段上添加getter方法，然后在观察者更新状态的方法中传入主题的引用（推方式中传入的是主题所有的数据），并通过主题的getter方法来拉取所需要的数据。
用观察者拉取的方式重写上面的代码：
抽象主题类：
import java.util.ArrayList; import java.util.List; public abstract class Subject { private List<Observer> observerList = new ArrayList<>(); /** * 添加观察者 * @param observer */ public void attach(Observer observer){ observerList.add(observer); } /** * 删除观察者 * @param observer */ public void detach(Observer observer){ observerList.add(observer); } /** * 通知观察者 * @param subject 主题引用 */ public void notifyObservers(Subject subject){ for(Observer observer:observerList){ observer.update(this); } } }
具体主题类ConcreteSubject：
public class ConcreteSubject extends Subject { private String subjectState; public void setNewState(String newState){ this.subjectState = newState; System.out.println("主题状态发生改变，新的状态为：" + newState); this.notifyObservers(this); } public String getState(){ return subjectState; } }
观察者接口：
public interface Observer { /** * 观察者更新自身状态 * @param subject 主题引用 */ public void update(Subject subject); }
具体观察者类ConcreteObserverA：
public class ConcreteObserverA implements Observer { private String oberverState; @Override public void update(Subject subject) { oberverState = ((ConcreteSubject)subject).getState(); System.out.println("观察者A状态已改变，新的状态为：" + oberverState); } }
具体观察者类ConcreteObserverB：
public class ConcreteObserverB implements Observer{ private String observerState; @Override public void update(Subject subject) { observerState = ((ConcreteSubject)subject).getState(); System.out.println("观察者B状态已改变，新的状态为：" + observerState); } }
在客户端Client中进行测试：
public class Client { public static void main(String[] args){ ConcreteSubject subject = new ConcreteSubject(); Observer observerA = new ConcreteObserverA(); subject.attach(observerA); Observer observerB = new ConcreteObserverB(); subject.attach(observerB); // 主题状态改变 subject.setNewState("new state"); } }
结果：
主题状态发生改变，新的状态为：new state
观察者A状态已改变，新的状态为：new state
观察者B状态已改变，新的状态为：new state
六、使用JDK内置的观察者模式
在java.util包中，有一个Obsever接口和一个Observable类，分别对应上文中的Observer接口和Subject类，实现了Observer接口的类就是观察者，继承了Observable类的类就是主题（被观察者），这样对主题来讲，使用addObserver(Observer)方法来添加观察者，使用deleteObserver(Observer)方法来删除观察者，当主题发生改变时，使用以下步骤通知观察者：
1、调用setChanged()方法，标记状态已经改变的事实；
2、调用方法notifyObservers()或者notifyObservers(Object object)来通知观察者，前一个方法适用于观察者拉取数据，后一种方法可以在通知的时候，传递任何的数据对象给观察者，主题将数据推给了观察者。
当观察者发现主题发生改变时，则调用自身的update(Observable o, Object arg)来更新自身状态，其中前一个参数标识了观察者所观察的主题，后一个则是主题调用notifyObservers方法时传入的数据对象，如果没有则为空。
代码实现：
主题类（被观察者类）：
import java.util.Observable; public class ConcreteSubject extends Observable { private String subjectState; /** * 主题（被观察者）状态改变 * @param newState */ public void setState(String newState){ subjectState = newState; System.out.println("主题状态改变，新的状态是：" + subjectState); System.out.println("通知观察者"); setChanged(); notifyObservers(); } /** * 让观察者拉取数据 * @return */ public String getSubjectState(){ return subjectState; } }
观察者类：
import java.util.Observable; import java.util.Observer; public class ConcreteObserver implements Observer { private String observerState; public ConcreteObserver(Observable observable){ observable.addObserver(this); } @Override public void update(Observable o, Object arg) { observerState = ((ConcreteSubject)o).getSubjectState(); System.out.println("观察者状态改变，新的状态是：" + observerState); } }
使用客户端Client来测试：
public class Client { public static void main(String[] args){ ConcreteSubject subject = new ConcreteSubject(); ConcreteObserver observer = new ConcreteObserver(subject); subject.setState("new state"); } }
结果如下：
主题状态改变，新的状态是：new state
通知观察者
观察者状态改变，新的状态是：new state
在JDK中，还有其他应用体现了观察者模式，比如在一个按钮上添加监听器（ActionListener），当按钮被按下时（主题发生改变），触发ActionListener中的相应逻辑。
六、观察者模式的优缺点
优点：
1、在观察者模式下，主题和观察者之间实现了松耦合。主题只知道观察者实现了一个接口（Observer接口），主题并不需要关心观察者具体的类是谁，做了些什么等其他细节，添加或删除观察者，主题不会受到影响，我们可以独立地复用主题和观察者，而且系统也变得很有弹性，易于扩展。
缺点：
1、当观察者数目较多时，主题可能要花费较长时间通知观察者；
2、观察者之间有循环依赖的话，被观察者会触发他们之间的循环调用，从而导致系统崩溃。
七、适用场景
1、一个对象的改变将导致其他对象发生改变，而不需要关心有多少对象需要跟着改变；
2、一个对象需要通知其他对象，但不需要知道这些对象的具体情况；
3、可以使用观察者模式实现链式触发机制，当对象A发生改变，则影响B对象，B对象的改变又会影响C对象。
