一、概述
对象之间存在一对多的情况时，当某个对象发生变化，其他对象会收到通知并作出相应的变化。通俗点说就是发布订阅模式，当订阅者订阅了发布者，发布者在发布消息之后，订阅者就会收到消息，而没有订阅的无法收到消息。Android中最经典的用到了观察者模式就是View的点击事件，通过setOnClickListener订阅View的点击事件，当我们手指点击View后，View就会通知我们，然后我们在onClick方法中作出相应的处理。著名的RxJava也是观察者模式为代表的三方库，这里RxJava不是本文重点，如需了解请查看其他文档。
观察者模式是一种行为型的设计模式，最主要的4个核心角色：
- 抽象观察者：提供了一个接口，定义了观察者收到消息时更新的相关操作；
- 具体观察者：实现了抽象观察者的接口，在收到数据更新的消息时，根据具体的业务逻辑做出相应的更新操作。
- 抽象被观察者：定义了添加、删除观察者的操作，以及通知观察者对象的方法；
- 具体被观察者：实现了抽象被观察者接口(或者继承了抽象类)，在添加、删除观察者方法以及通知方法中，做出自己具体的逻辑。
当被观察者发生变化时，观察者能收到通知并作出相应的反应，我们可以在现实生活中举个具体的例子加以理解。比如我们浏览别人的博客时，如果觉得作者写的不错，想要作者有新文章时我们会收到通知，就可以订阅这个作者，那么我们就是订阅者(观察者)、作者就是发布者(被观察者)；再比如微信上的公众号，只有我们订阅了某个公众号之后，我们(观察者、订阅者)就会收到公众号(被观察者、发布者)的推文，收到推文之后(作出的反应)我们就可以浏览文章，当然，我们取消了订阅之后就无法收到推文了。
二、使用
上面说到Android最简单、使用最多的观察者模式就是View的点击事件，这里就不再举例了。Java从JDK 1.0就有了一个Observable类，提供给我们使用观察者模式。接下来我们就通过使用JDK自带的Observable类和自定义类来分别讲解说明观察者模式。并以订阅公众号文章为例。
1、使用JDK的Observable类
我们先自定义一个读者观察者，实现自JDK中的Observer接口，重写了update方法，这个方法就是用来收到消息通知后，我们需要做的操作，里面的Object参数就是更新的内容。
public class WeObserver implements Observer {
private static final String TAG = "XXX";
private String name;
public WeObserver(String name){
this.name = name;
}
@Override
public void update(Observable o, Object arg) {
Log.e(TAG, name + "，收到文章更新了：" + arg);
}
}
然后，我们自定义一个公众号文章被观察者，JDK已经为我们做了封装，直接继承自Observable类就行，并定义一个发送推文的方法，其中调用setChanged()表示进行数据已改变，并调用notifyObservers()方法通知观察者，把更新内容传递进去，这样观察者就会收到消息。
public class ArticleObservable extends Observable {
/**
* 推文
*/
public void pushArticle(String article){
setChanged();
notifyObservers(article);
}
}
最后我们来测试一下。我们定义了3个人物观察者：zhangObserver、guanObserver、liuObserver；定义了一个公众号的被观察者：articleObservable。并调用了addObserver()方法使得观察者订阅被观察者，这里我们订阅了2个，最后调用pushArticle()方法发表推文。运行结果如下。
WeObserver zhangObserver = new WeObserver("张飞");
WeObserver guanObserver = new WeObserver("关羽");
WeObserver liuObserver = new WeObserver("刘备");
ArticleObservable articleObservable = new ArticleObservable();
articleObservable.addObserver(zhangObserver);
articleObservable.addObserver(guanObserver);
articleObservable.pushArticle("哈哈，我就是标题党");
articleObservable.pushArticle("震惊！你居然还在做这件事...");
articleObservable.deleteObserver(guanObserver);
articleObservable.pushArticle("突发！一年轻小伙在田里挖到宝...");
从下图中我们可以看到，只有zhangObserver、guanObserver订阅了公众号，才会收到推文，而liuObserver不会收到；调用deleteObserver()方法解除了guanObserver，使得观察者不再订阅公众号，这样guanObserver也不会再收到推文了。
2、浅析JDK的Observable
从上面的使用可以，在JDK中使用Observable还是很简单的，下面我们来看看具体的源码。先来看看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);
}
Observer它是一个接口，并且只有一个update方法，从注释中我们就可以知道，这个方法就是当观察的对象发生变化时，此方法会被回调。当调用被观察者的notifyObservers方法时，就会调用此方法进行通知变化。再来看看Observable类。
public class Observable {
private boolean changed = false;
private Vector<Observer> 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);
}
}
/**
* Deletes an observer from the set of observers of this object.
* Passing <CODE>null</CODE> to this method will have no effect.
* @param o the observer to be deleted.
*/
public synchronized void deleteObserver(Observer o) {
obs.removeElement(o);
}
/**
* If this object has changed, as indicated by the
* <code>hasChanged</code> method, then notify all of its observers
* and then call the <code>clearChanged</code> method to
* indicate that this object has no longer changed.
* <p>
* Each observer has its <code>update</code> method called with two
* arguments: this observable object and <code>null</code>. In other
* words, this method is equivalent to:
* <blockquote><tt>
* notifyObservers(null)</tt></blockquote>
*
* @see java.util.Observable#clearChanged()
* @see java.util.Observable#hasChanged()
* @see java.util.Observer#update(java.util.Observable, java.lang.Object)
*/
public void notifyObservers() {
notifyObservers(null);
}
/**
* If this object has changed, as indicated by the
* <code>hasChanged</code> method, then notify all of its observers
* and then call the <code>clearChanged</code> method to indicate
* that this object has no longer changed.
* <p>
* Each observer has its <code>update</code> method called with two
* arguments: this observable object and the <code>arg</code> argument.
*
* @param arg any object.
* @see java.util.Observable#clearChanged()
* @see java.util.Observable#hasChanged()
* @see java.util.Observer#update(java.util.Observable, java.lang.Object)
*/
public void notifyObservers(Object arg) {
/*
* a temporary array buffer, used as a snapshot of the state of
* current Observers.
*/
Object[] arrLocal;
synchronized (this) {
/* We don't want the Observer doing callbacks into
* arbitrary code while holding its own Monitor.
* The code where we extract each Observable from
* the Vector and store the state of the Observer
* needs synchronization, but notifying observers
* does not (should not). The worst result of any
* potential race-condition here is that:
* 1) a newly-added Observer will miss a
* notification in progress
* 2) a recently unregistered Observer will be
* wrongly notified when it doesn't care
*/
// Android-changed: Call out to hasChanged() to figure out if something changes.
// Upstream code avoids calling the nonfinal hasChanged() from the synchronized block,
// but that would break compatibility for apps that override that method.
// if (!changed)
if (!hasChanged())
return;
arrLocal = obs.toArray();
clearChanged();
}
for (int i = arrLocal.length-1; i>=0; i--)
((Observer)arrLocal[i]).update(this, arg);
}
/**
* Clears the observer list so that this object no longer has any observers.
*/
public synchronized void deleteObservers() {
obs.removeAllElements();
}
/**
* Marks this <tt>Observable</tt> object as having been changed; the
* <tt>hasChanged</tt> method will now return <tt>true</tt>.
*/
protected synchronized void setChanged() {
changed = true;
}
/**
* Indicates that this object has no longer changed, or that it has
* already notified all of its observers of its most recent change,
* so that the <tt>hasChanged</tt> method will now return <tt>false</tt>.
* This method is called automatically by the
* <code>notifyObservers</code> methods.
*
* @see java.util.Observable#notifyObservers()
* @see java.util.Observable#notifyObservers(java.lang.Object)
*/
protected synchronized void clearChanged() {
changed = false;
}
/**
* Tests if this object has changed.
*
* @return <code>true</code> if and only if the <code>setChanged</code>
* method has been called more recently than the
* <code>clearChanged</code> method on this object;
* <code>false</code> otherwise.
* @see java.util.Observable#clearChanged()
* @see java.util.Observable#setChanged()
*/
public synchronized boolean hasChanged() {
return changed;
}
/**
* Returns the number of observers of this <tt>Observable</tt> object.
*
* @return the number of observers of this object.
*/
public synchronized int countObservers() {
return obs.size();
}
}
其实Observable类也很简单。先来看看构造方法，知道Observable是使用了Vector作为装载Observer对象的容器，而Vector它是线程安全的，具体的Vector源码这里就不展开，可以自己去查看相应的文章。可以看到在Observable的方法都有synchronized修饰，说明Observable它也是线程安全的。再来看看addObserver()这个方法，如果到Vector列表中不存在当前观察者对象时才能被添加进去，既不允许重复添加；deleteObserver()方法也是很简单，直接从Vector中移除观察者对象；setChanged()方法设置changed变量为true，这个changed变量用于判断被观察者是否发生了变化，所以当被观察者发生变化时，必须调用此方法；最后看看notifyObservers()方法，可以看到先调用了hasChanged()方法判断是否有变化，没有则直接返回，所以要在之前调用setChanged()方法，下面会清除changed变量，最后面是一个for循环，会循环调用每个观察者对象的update方法，并把变化内容参数传递进去。Observable类就这么简单。
3、使用自定义类
上一小节是用的JDK的Observable、Observer使用的观察者模式。之前说过观察者模式有4个核心角色，这里Observable就是抽象的被观察者，Observer就是抽象的观察者。我们在使用自定义类时，就需要自己写关于注册、移除观察者、数据更新通知的功能，其实就是面向接口编程，使用接口回调。 按照JDK的样例，我们可以这样写出观察者模式：
自定义的观察者，里面包含一个数据更新通知的方法。
public interface CustomObserver {
void notifyDataChanged(String data);
}
自定义的被观察者接口，包含通用的方法，并持有观察者的对象
public interface CustomObservable {
void addObserver(CustomObserver observer);
void deleteObserver(CustomObserver observer);
void sendData(String str);
}
具体的观察者，这个和上面例子其实是一样的。
public class MyObserver implements CustomObserver{
private static final String TAG = "XXX";
private String name;
public MyObserver(String name){
this.name = name;
}
@Override
public void notifyDataChanged(String data) {
Log.e(TAG, name + "，收到文章更新：" + data);
}
}
具体的被观察者，这里我们使用的是ArrayList，整个类都不是线程安全的，这里只是举例说明，可以根据具体的逻辑进行调整。
public class MyObservable implements CustomObservable{
private List<CustomObserver> myObserverList;
public MyObservable(){
myObserverList = new ArrayList<>();
}
@Override
public void addObserver(CustomObserver observer) {
myObserverList.add(observer);
}
@Override
public void deleteObserver(CustomObserver observer) {
myObserverList.remove(observer);
}
@Override
public void sendData(String str) {
if(myObserverList != null && myObserverList.size() != 0){
for(CustomObserver customObserver : myObserverList){
customObserver.notifyDataChanged(str);
}
}
}
}
最后进行测试。打印输出如下图。
MyObserver myObserver1 = new MyObserver("曹操");
MyObserver myObserver2 = new MyObserver("曹丕");
MyObserver myObserver3 = new MyObserver("曹仁");
MyObservable myObservable = new MyObservable();
myObservable.addObserver(myObserver1);
myObservable.addObserver(myObserver2);
myObservable.sendData("关羽温酒斩华雄");
myObservable.deleteObserver(myObserver2);
myObservable.sendData("关羽大意失荆州");
三、总结
观察者和被观察者之间抽象耦合。观察者模式容易扩展，被观察者只持有观察者集合，并不需要知道具体观察者内部的实现。当被观察者发生变化时，观察者也会同时做出相应的操作。这里其实和我们项目中使用接口回调有点相似，其实接口回调是观察者模式的特殊实现，接口回调是一对一的，只监听一个事件，而观察者模式是一对多的关系。
github地址：github.com/leewell5717…
