JDK对观察者模式的支持主要是通过Observable类和Observer接口。
继承Observable类表示“主题”角色，实现Observer接口表示观察者。
Observer的简单功能介绍
update(Observable o, Object arg) Observable唯一的方法，在被通知时被
Observable调用.o表示主题对象，arg表示通知信息。由此看出这是一个“推-拉结合”使用的方式。arg不传值就是拉模式，传值就是推模式，当然也可以推一部分，拉一部分。
Observable的简单功能介绍：
notifyObservers() 如果hasChanged()=ture，通知所有的观察着(则调用Observer.update()方法)
notifyObservers(Object arg) 如果hasChanged()=ture，通知所有的观察着(则调 用Observer.update()方法),并把参数arg传过去
说明：notifyObservers()内部其实是notifyObservers(null)；notifyObservers(Object arg)内部其实是 update(this,arg)和Observer中的 update方法对应。
注意点：调用notifyObservers方法之前一定要先调用setChanged();方法。
JDK中Observable类和Observer接口实现：
1.抽象主题
java.util.Observable
2.具体主题
import java.util.Observable;
public class ConcreteSubject extends Observable {
public void doBusiness(Object obj) {
super.setChanged();
super.notifyObservers(obj);
}
}
3.抽象观察者
java.util.Observer
4.具体观察者
import java.util.Observable;
import java.util.Observer;
public class ConcreteObserverA implements Observer {
@Override
public void update(Observable o, Object arg) {
System.out.println("A Subject:" + o.getClass().getName() + " Object: " + arg.getClass().getName());
}
}
import java.util.Observable;
import java.util.Observer;
public class ConcreteObserverB implements Observer {
@Override
public void update(Observable o, Object arg) {
System.out.println("B Subject:" + o.getClass().getName() + " Object: " + arg.getClass().getName());
}
}
5.测试调用
import java.util.Observer;
public class Test {
public static void main(String[] args) {
ConcreteSubject observable = new ConcreteSubject();
Observer observer1 = new ConcreteObserverA();
Observer observer2 = new ConcreteObserverB();
observable.addObserver(observer1);
observable.addObserver(observer2);
observable.doBusiness(observer2);
}
}
通俗的说，观察者模式定义了一个一对多的依赖关系，让一个或多个观察者对象监察一个主题对象，这样一个主题对象在状态上的变化就能够通知所有依赖于此对象的观察者对象，使得这些观察者对象能够自动更新。经典的例子就是GUI界面编程模式中的监听模式。
观察者模式（Observer）完美的将观察者和被观察的对象分离开。比如说，用户界面可以看作一个观察者，业务数据被观察者，用户界面观察业务数据的变化，发现数据变化后，就显示最新动态在界面上。
观察者（Observer）模式有时有称为发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-收听者（Source/Listener）模式或者从属者（Dependents）模式。
推模型和拉模型
推模型：目标对象主动向观察者推送目标的详细信息，不管观察者是否需要，推送的信息通常是目 标对象的全部或部分数据，相当于是在广播通信。实现方法就是，update 方法加一个参数，通过这个参数把数据传过去。
拉模型：目标对象在通知观察者的时候，只传递少量信息，如果观察者需要更具体的信息，由观察 者主动到目标对象中获取，相当于是观察者从目标对象中拉数据。 一般这种模型的实现中，会把目标对象自身通过update方法传递给观察者，这样在观察者 需要获取数据的时候，就可以通过这个引用来获取了。
观察者模式的优缺点
1.观察者模式实现了观察者和目标之间的抽象耦合：原本目标对象在状态发生改变的时候，需要直接调用所有的观察者对象，但是抽象出观察者接口过后，目标和观察者就只是在抽象层面上耦合了，也就是说目标只是知道观察者接口，并不 知道具体的观察者的类，从而实现目标类和具体的观察者类之间解耦。
2.观察者模式实现了动态联动：所谓联动，就是做一个操作会引起其它相关的操作。由于观察者模式对观察者注册实行管 理，那就可以在运行期间，通过动态的控制注册的观察者，来控制某个动作的联动范围，从而 实现动态联动。
观察者模式支持广播通信
由于目标发送通知给观察者是面向所有注册的观察者，所以每次目标通知的信息就要对所有注册的观察者进行广播。当然，也可以通过在目标上添加新的功能来限制广播的范围。
在广播通信的时候要注意一个问题，就是相互广播造成死循环的问题。比如A和B两个对象互为观察者和目标对象，A对象发生状态变化，然后A来广播信息，B对象接收到通知后，在处理过程中，使得B对象的状态也发生了改变，然后B来广播信息，然后A对象接到通知后，又触 发广播信息……，如此A引起B变化，B又引起A变化，从而一直相互广播信息，就造成死循环了。
观察者模式可能会引起无谓的操作，降低性能
由于观察者模式每次都是广播通信，不管观察者需不需要，每个观察者都会被调用update方法，如果观察者不需要执行相应处理，那么这次操作就浪费了。
增加了复杂度，容易引起误操作。死循环等。
观察者模式的效果有以下的优点：
实现了表示层和数据逻辑层的分离，并定义了稳定的更新消息传递机制，类别清晰，并抽象了更新接口，使得可以有各种各样不同的表示层（观察者）。
Subject在发送广播通知的时候，无须指定具体的Observer，Observer可以自己决定是否要订阅Subject的通知。
观察者模式支持广播通讯。被观察者会向所有的登记过的观察者发出通知。
遵守大部分GRASP原则和常用设计原则，高内聚、低偶合。
Subject和Observer之间是松偶合的，分别可以各自独立改变。观察者模式在被观察者和观察者之间建立一个抽象的耦合。被观察者角色所知道的只是一个具体观察者列表，每一个具体观察者都符合一个抽象观察者的接口。被观察者并不认识任何一个具体观察者，它只知道它们都有一个共同的接口。 由于被观察者和观察者没有紧密地耦合在一起，因此它们可以属于不同的抽象化层次。如果被观察者和观察者都被扔到一起，那么这个对象必然跨越抽象化和具体化层次。
观察者模式有下面的缺点：
第一、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。
第二、如果在被观察者之间有循环依赖的话，被观察者会触发它们之间进行循环调用，导致系统崩溃。在使用观察者模式是要特别注意这一点。
第三、如果对观察者的通知是通过另外的线程进行异步投递的话，系统必须保证投递是以自恰的方式进行的。
第四、虽然观察者模式可以随时使观察者知道所观察的对象发生了变化，但是观察者模式没有相应的机制使观察者知道所观察的对象是怎么发生变化的。
观察者模式的构造
1.抽象主题（Subject）角色：
目标角色知道它的观察者，可以有任意多个观察者观察同一个目标。
并且提供注册和删除观察者对象的接口。
目标角色往往由抽象类或者接口来实现。
主题角色把所有对视察者对象的援用保留在一个凑集（List）中，每个主题都能够有任何数目的观察者。抽象主题供给一个接口，可以增添跟删除察看者对象,主题角色又叫做形象被观察着角色,个别用一个抽象类或者一个接口实现
2.抽象观察者（Observer）角色：
为那些在目标发生改变时需要获得通知的对象定义一个更新接口。
抽象观察者角色主要由抽象类或者接口来实现。
为所有具体观察者定义一个接口，在得到主题的通知时更新自己。这个接口又叫做更新借口。抽象观察者角色普通用一个抽象类或一个接口实现。
3.具体主题（ConcreteSubject）角色：
将有关状态存入各个Concrete Observer对象。
当它的状态发生改变时, 向它的各个观察者发出通知。
将有关状态存入具体观察者对象,在具体的主题内部状态转变时,给所有登记过的观察者发出告诉。具体主题角色又叫做具体被观察着角色。
4.具体观察者(ConcreteObserver)角色：
存储有关状态，这些状态应与目标的状态保持一致。
实现Observer的更新接口以使自身状态与目标的状态保持一致。
在本角色内也可以维护一个指向Concrete Subject对象的引用。
存储于主题状态自恰的状态。详细观察者角色实现抽象观察者角色所请求更新接口，以便使自身的状况与主题的状态相和谐 。
被观察者接口应当有以下几个要素：
1、一份观察者的清单，来控制观察者。
2、增删方法，对清单进行操作。以及一个通知观察者的方法，通过调用观察者的update方法。
观察者接口应当有以下几个要素：
1、update方法，用于维系和被观察者之间的联系。
自定的实现：
1.抽象主题
public interface AbstractSubject {
public void addWatcher(AbstractWatcher watcher);
public void removeWatcher(AbstractWatcher watcher);
public void removeAllWatchers();
public void notifyAllWatahcers();
}
2.抽象观察者
public interface AbstractWatcher {
public void update();
}
3.具体主题
import java.util.ArrayList;
import java.util.List;
public class ConcreteSubject implements AbstractSubject {
private List<AbstractWatcher> watcherList = new ArrayList<AbstractWatcher>();
@Override
public void addWatcher(AbstractWatcher watcher) {
this.watcherList.add(watcher);
}
@Override
public void removeWatcher(AbstractWatcher watcher) {
this.watcherList.remove(watcher);
}
@Override
public void removeAllWatchers() {
this.watcherList.clear();
}
@Override
public void notifyAllWatahcers() {
for (AbstractWatcher watcher : this.watcherList) {
watcher.update();
}
}
}
4.具体观察者
public class ConcreteWatcherA implements AbstractWatcher {
@Override
public void update() {
System.out.println("update A ...");
}
}
public class ConcreteWatcherB implements AbstractWatcher {
@Override
public void update() {
System.out.println("update B ...");
}
}
public class ConcreteWatcherC implements AbstractWatcher {
@Override
public void update() {
System.out.println("update C ...");
}
}
5.调用测试
public class Test {
public static void main(String[] args) {
AbstractSubject subject = new ConcreteSubject();
AbstractWatcher watcher1 = new ConcreteWatcherA();
AbstractWatcher watcher2 = new ConcreteWatcherB();
AbstractWatcher watcher3 = new ConcreteWatcherC();
subject.addWatcher(watcher1);
subject.addWatcher(watcher2);
subject.addWatcher(watcher3);
subject.notifyAllWatahcers();
}
}
