十一、观察者设计模式
1. 观察者模式的介绍
观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使它们能够自动更新自己。
例如：我们在使用应用市场下载应用时，我们的通知栏会有下载进度显示，我们的详情页会有进度显示，我们的列表中也会有下载进度显示，这就是一个典型的观察者设计模式，多个观察者监听同一个下载进度。
2. 观察者模式的使用场景
- 事件的多级触发场景。
- 跨系统的消息交换场景。
3. 观察者模式的UML类图
UML角色介绍
Subject: 抽象主题角色，也就是被观察的角色，抽象主题角色的所有观察者对象的引用保存在一个集合里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象。
ConcreteSuject: 将有关状态存入具体观察者对象，在具体主题的内部状态改变时，给所有登记过的观察者发出通知。
Obser: 为所有具体观察者定义一个接口，在得到主题的通知时更新自己。这个接口叫做更新接口。
ConcreteObserver： 具体的观察者，该角色实现抽象观察者角色所定义的更新接口，以便在主题的状态发生变化时更新自身的状态。
4. 观察者模式的简单实现
（1）、 首先定义一个观察者接口：
public interface Observer {
/** * 更新接口 * * @param subject 传入主题对象，获取主题的状态信息 */
public void update(Subject subject);
}观察者接口里面只有一个方法update(Subject suject)，当有更新时，将被观察者对象传进来，然后获取其状态信息。
（2）、接着定义具体的观察者，实现观察者接口：
public class ConcreteObserver implements Observer {
private ConcreteSubject concreteSubject;
private String name;
public ConcreteObserver(String name) {
this.name = name;
}
@Override
public void update(Subject subject) {
concreteSubject = (ConcreteSubject) subject;
String state = concreteSubject.getState();
System.out.println(name + " 观察到: " + state);
}
}
具体观察者在收到更新后，在update方法里面做出具体的操作
（3）、然后，定义具体的被观察对象
public abstract class Subject {
//用来保存注册的观察者
private List<Observer> observers = new ArrayList<Observer>();
/** * 注册观察者，将其加入到集合中 * * @param observer */
public void registerObserver(Observer observer) {
if (!observers.contains(observer)) {
observers.add(observer);
}
}
/** * 取消注册 * * @param observer */
public void unrigisterObserver(Observer observer) {
if (observers.contains(observer)) {
observers.remove(observer);
}
}
/** * 通知所有的观察者 */
public void notifyObservers() {
for (Observer observer : observers) {
observer.update(this);
}
}
}被观察者里有一个集合，用户存储所有的观察者对象的引用。
使用registerObserver方法添加到集合中，使用unregisterObserver方法将观察者对象从集合中移除。
最后调用notifyObservers方法遍历所有的观察者，调用它们的update方法，将被观察者自身对象传递进去。
具体的每个观察者在自己的update方法里面做出相应的行为。
（4）、具体的被观察者
public class ConcreteSubject extends Subject {
private String state;
public String getState() {
return state;
}
public void change(String newSate) {
this.state = newSate;
this.notifyObservers();
}
}这个具体的观察者，其实在日常开发中，根本没有抽象观察者，都只有一个具体的被观察者，这里为了实现UML类图里面的对应关系，所以多了一个抽象的观察者。
5. 观察者模式在Android源码中
我们平时在更新ListView时，都会使用notifyDataSetChanged()方法来更新界面，其实这就是一个观察者设计模式。
我们先简单来说一下大致步骤。
（1）、首先我们会通过setAdapter来设置Adapter，在Adapter里面设置了一个观察者。观察者里面有一个changed()方法，onChanged()方法面会重新刷新布局。
（2）、当我们的数据发生变化时，会调用Adapter里面的notifyDataSetChanged()方法来更新数据，在notifyDataSetChanged()方法里面，最终会遍历所有的的观察者，并调用其changed()方法。
下面我们从源码的角色：
（1）、首先我们我们先找出观察者，从刚刚的分析中，我们知道setAdapter会设置一个观察者。所以我们从setAdapter入手。
public void setAdapter(ListAdapter adapter) {
//忽略以上代码
if (mAdapter != null) {
mAreAllItemsSelectable = mAdapter.areAllItemsEnabled();
mOldItemCount = mItemCount;
mItemCount = mAdapter.getCount();
checkFocus();
//这段代码就是观察者。
mDataSetObserver = new AdapterDataSetObserver();
mAdapter.registerDataSetObserver(mDataSetObserver);
mRecycler.setViewTypeCount(mAdapter.getViewTypeCount());
int position;
if (mStackFromBottom) {
position = lookForSelectablePosition(mItemCount - 1, false);
} else {
position = lookForSelectablePosition(0, true);
}
setSelectedPositionInt(position);
setNextSelectedPositionInt(position);
if (mItemCount == 0) {
// Nothing selected
checkSelectionChanged();
}
} else {
mAreAllItemsSelectable = true;
checkFocus();
// Nothing selected
checkSelectionChanged();
}
requestLayout();
}从以上代码我们可以看到，setAdapter里面我们看到如下代码：
mDataSetObserver = new AdapterDataSetObserver(); mAdapter.registerDataSetObserver(mDataSetObserver);从名字我们不难猜测到这是一个观察者。我们继续点进去，在AbsListView中我们看到如下代码：
class AdapterDataSetObserver extends AdapterView<ListAdapter>.AdapterDataSetObserver {
@Override
public void onChanged() {
super.onChanged();
if (mFastScroll != null) {
mFastScroll.onSectionsChanged();
}
}
@Override
public void onInvalidated() {
super.onInvalidated();
if (mFastScroll != null) {
mFastScroll.onSectionsChanged();
}
}
}
我们发现AdapterDataSetObserver继承自AdapterView.AdapterDataSetObserver,继续跟进：
class AdapterDataSetObserver extends DataSetObserver {
private Parcelable mInstanceState = null;
@Override
public void onChanged() {
mDataChanged = true;
mOldItemCount = mItemCount;
mItemCount = getAdapter().getCount();
// Detect the case where a cursor that was previously invalidated has
// been repopulated with new data.
if (AdapterView.this.getAdapter().hasStableIds() && mInstanceState != null
&& mOldItemCount == 0 && mItemCount > 0) {
AdapterView.this.onRestoreInstanceState(mInstanceState);
mInstanceState = null;
} else {
rememberSyncState();
}
checkFocus();
requestLayout();
}
@Override
public void onInvalidated() {
mDataChanged = true;
if (AdapterView.this.getAdapter().hasStableIds()) {
// Remember the current state for the case where our hosting activity is being
// stopped and later restarted
mInstanceState = AdapterView.this.onSaveInstanceState();
}
// Data is invalid so we should reset our state
mOldItemCount = mItemCount;
mItemCount = 0;
mSelectedPosition = INVALID_POSITION;
mSelectedRowId = INVALID_ROW_ID;
mNextSelectedPosition = INVALID_POSITION;
mNextSelectedRowId = INVALID_ROW_ID;
mNeedSync = false;
checkFocus();
requestLayout();
}
上述代码就是我们想要的观察者的庐山真面目。里面我们注意发现有onChanged()方法，这个就相当于UML类图的update()方法。
（2）、 接着我们找出被观察对象。
我们从BaseAdapter里面的notifyDataSetChanged()方法入手，我们看到如下代码：
public void notifyDataSetChanged() {
mDataSetObservable.notifyChanged();
}同时我们可以看到如下代码：
public void registerDataSetObserver(DataSetObserver observer) {
mDataSetObservable.registerObserver(observer);
}
public void unregisterDataSetObserver(DataSetObserver observer) {
mDataSetObservable.unregisterObserver(observer);
}从方法的名字可以看出，以上两个方法的作用是，注册观察者和反注册观察者。
我们继续跟进，看到如下代码：
public class DataSetObservable extends Observable<DataSetObserver> {
public void notifyChanged() {
synchronized(mObservers) {
//遍历所有的观察者，调用每个观察者的onChanged方法。
for (int i = mObservers.size() - 1; i >= 0; i--) {
mObservers.get(i).onChanged();
}
}
}
}
从上面的代码中我们可以看到，notifyChanged()方法遍历了所有的观察者，并调用了其onChanged()方法。
分析到这里，我们可以肯定的说，这就是一个典型的观察者设计模式。
最后画张图来总结一下，让调用更加清晰明了。
6. 观察者模式的Android开发
下面模拟我们在应用市场下载通过一个应用时，可以同时在通知栏，详情页面，ListView同时观察到同步的进度。模拟每隔一秒钟将下载进度发给所有的观察者。
（1）、首先定义一个观察者接口接口：Listener
public interface Listener {
//更新进度的方法
void update(int progress);
}（2）、具体的观察者:DownLoadListener
public class DownListener implements Listener {
//观察者的名称
public String name;
public DownListener(String name) {
this.name = name;
}
//具体观察者在收到更新后所进行的操作
@Override
public void update(int progress) {
System.out.println(name + " ，下载进度: " + progress);
}
}（3）、下载服务DownloadService。模拟下载服务主要用到了计时器工具类，Timer和TimerTask,每隔一秒钟，通过handler将进度发送出去。handler收到进度后，遍历所有的观察者，调用所有监听的观察者的update方法，将进度传递进去。
public class DownloadService {
private List<Listener> listeners = new ArrayList<Listener>();
private static final int DOWN = 1;
private int progress = 1;
private Timer mTimer;
private Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case DOWN:
//通知所有的观察者
notifyAllListeners(msg.arg1);
break;
default:
break;
}
}
};
public DownloadService() {
mTimer = new Timer();
}
//模拟开启服务
public void startService() {
setTimerTask();
}
//定时服务
private void setTimerTask() {
mTimer.schedule(new TimerTask() {
@Override
public void run() {
Message message = new Message();
message.arg1 = ++progress;
message.what = DOWN;
handler.sendMessage(message);
}
}, 1000, 1000/* 表示1000毫秒之後，每隔1000毫秒執行一次 */);
}
//遍历通知所有的观察者
public void notifyAllListeners(int progress) {
for (Listener listener :
listeners) {
listener.update(progress);
}
}
//注册监听
public void registerService(Listener listener) {
if (!listeners.contains(listener)) {
listeners.add(listener);
}
}
//取消监听
public void ungisterService(Listener listener) {
if (listeners.contains(listener)) {
listeners.remove(listener);
}
}
}
（4）、 测试代码：
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//构造三个观察者
Listener listener1 = new DownListener("观察者1");
Listener listener2 = new DownListener("观察者2");
Listener listener3 = new DownListener("观察者3");
//下载服务
DownloadService downloadService = new DownloadService();
//注册监听者
downloadService.registerService(listener1);
downloadService.registerService(listener2);
downloadService.registerService(listener3);
//开启服务
downloadService.startService();
}
}7. 总结
- 优点：
- 观察者与被观察者之间属于轻度的关联关系，两个之间是抽象呢耦合的。易于扩展。
- 缺点：
- 由于观察者模式是一条触发链，当观察者比较多的时候，靠能会导致执行效率下降，一个观察者的卡顿，会导致整整体的执行效率。