设计模式学习笔记之观察者模式(一)

观察者(Observer)模式又名发布-订阅（Publish/Subscribe）模式。

1.定义

Define a one-to-many dependency between objects so that when one object changes state, all its dependents aer notified and updated automatically.

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

2. 组成部分

1)抽象目标角色（Subject）：目标角色知道它的观察者，可以有任意多个观察者观察同一个目标。并且提供注册和删除观察者对象的接口。目标角色往往由抽象类或者接口来实现。

2)抽象观察者角色（Observer）：为那些在目标发生改变时需要获得通知的对象定义一个更新接口。抽象观察者角色主要由抽象类或者接口来实现。

3)具体目标角色（Concrete Subject）：将有关状态存入各个Concrete Observer对象。当它的状态发生改变时, 向它的各个观察者发出通知。

4)具体观察者角色（Concrete Observer）：存储有关状态，这些状态应与目标的状态保持一致。实现Observer的更新接口以使自身状态与目标的状态保持一致。在本角色内也可以维护一个指向Concrete Subject对象的引用。

3.Java代码

接下来我们自己来模拟一个观察者模式（Observer）[其中涉及到2个接口，2个实现类，还有1个测试类]

1)Subject接口

/**
* 抽象主题角色
* @author jiangqq
*
*/
public interface Subject {
/**
* 注册添加观察者
* @param observer
*/
public void addObserver(Observer observer);
/**
* 刪除观察者
* @param observer
*/
public void removeObserver(Observer observer);
/**
* 对已经注册的观察者对象发送通知
* @param observer
*/
public void notifyObserver(String str);
}

2)具体主题角色ConcreteSubject

/**
* 具体主题角色 :主要功能是添加，删除观察者，并且当主题角色内部状态发生改变的时候，来通知观察者
* @author jiangqq
*
*/
public class ConcreteSubject implements Subject {
List<Observer> list=new ArrayList<Observer>();
@Override
public void addObserver(Observer observer) {
list.add(observer);
}
@Override
public void removeObserver(Observer observer) {
list.remove(observer);
}
@Override
public void notifyObserver(String str) {
for(Observer  observer:list){
observer.update(str);
}
}
}

3)抽象观察者角色(Observer)

/**
* 抽象观察者角色
* @author jiangqq
*
*/
public interface Observer {
/**
* 当观察者接受到主题发来的通知，自动调用update()来更新自己
*/
public void update(String str);
}

4)具体观察者角色(ConcreteObserver)

public class ConcreteObserver implements Observer {
@Override
public void update(String str) {
System.out.println("收到的信息是:"+str);
}
}

5)测试类

public class TestCustomObserver {
public static void main(String[] args) {
Subject sub=new ConcreteSubject();
Observer ob1=new ConcreteObserver();
Observer ob2=new ConcreteObserver();
Observer ob3=new ConcreteObserver();
//注册三个观察者，模拟当主题角色发送通知，三个观察者更新自己
sub.addObserver(ob1);
sub.addObserver(ob2);
sub.addObserver(ob3);
sub.notifyObserver("今天天氣很好...");
//移除一個观察者
sub.removeObserver(ob1);
sub.notifyObserver("今天天氣不好...");
}
}

运行结果:



4.观察者模式在安卓中的API

抽象观察者角色（Observer）

具体观察者角色（DataSetObserver），

抽象主题角色（Observable< T >抽象类），

具体主题角色（DataSetObserverable），

1)Observer

package java.util;
public interface Observer {
void update(Observable observable, Object data);
}

2)DataSetObserver

package android.database;
public abstract class DataSetObserver {
public void onChanged() {
// Do nothing
}
public void onInvalidated() {
// Do nothing
}
}

3)Observable

import java.util.ArrayList;
public abstract class Observable<T> {
protected final ArrayList<T> mObservers = new ArrayList<T>();
public void registerObserver(T observer) {
if (observer == null) {
throw new IllegalArgumentException("The observer is null.");
}
synchronized(mObservers) {
if (mObservers.contains(observer)) {
throw new IllegalStateException("Observer " + observer + " is already registered.");
}
mObservers.add(observer);
}
}
public void unregisterObserver(T observer) {
if (observer == null) {
throw new IllegalArgumentException("The observer is null.");
}
synchronized(mObservers) {
int index = mObservers.indexOf(observer);
if (index == -1) {
throw new IllegalStateException("Observer " + observer + " was not registered.");
}
mObservers.remove(index);
}
}
public void unregisterAll() {
synchronized(mObservers) {
mObservers.clear();
}
}
}

4)DataSetObservable

package android.database;
public class DataSetObservable extends Observable<DataSetObserver> {
public void notifyChanged() {
synchronized(mObservers) {
// since onChanged() is implemented by the app, it could do anything, including
// removing itself from {@link mObservers} - and that could cause problems if
// an iterator is used on the ArrayList {@link mObservers}.
// to avoid such problems, just march thru the list in the reverse order.
for (int i = mObservers.size() - 1; i >= 0; i--) {
mObservers.get(i).onChanged();
}
}
}
public void notifyInvalidated() {
synchronized (mObservers) {
for (int i = mObservers.size() - 1; i >= 0; i--) {
mObservers.get(i).onInvalidated();
}
}
}
}

5.观察者模式在安卓中的潜在应用

平时我们在使用ListView,GridView等时需要构建适配器和关联适配器。在自定义适配器继承BaseAdapter时我们经常使用的一个方法是adapter.notifyDataSetChanged()来通知ListView,GridView等更新数据。但其底层是怎么实现的呢？

BaseAdapter关联了一个DataSetObservable对象，并实现registerDataSetObserver和unregisterDataSetObserver两个方法实现注册和撤销Observer，方法notifyDataSetChanged间接调用Observer的实现者的onChange()方法，以达到通知数据改变的作用。使用ListView和BaseAdapter组合时，当BaseAdapter的item改变时，我们经常会调用notifyDataSetChanged()，通知Listview刷新。

1)构建DataSetObservable对象

private final DataSetObservable mDataSetObservable = new DataSetObservable();

2)注册Observer

public void registerDataSetObserver(DataSetObserver observer) {
mDataSetObservable.registerObserver(observer);
}

3)撤销Observer

public void unregisterDataSetObserver(DataSetObserver observer) {
mDataSetObservable.unregisterObserver(observer);
}

4)通知ListView等更新数据

/**
* Notifies the attached observers that the underlying data has been changed
* and any View reflecting the data set should refresh itself.
*/
public void notifyDataSetChanged() {
mDataSetObservable.notifyChanged();
}

但是，但是，但是，我们从来没有调用BaseAdapter的registerDataSetObserver(DataSetObserver observer)注册Observer，那么Listview如何接收到通知，并执行刷新动作呢？

我们来看看ListView做了什么

/**
* Sets the data behind this ListView.
*
* The adapter passed to this method may be wrapped by a {@link WrapperListAdapter},
* depending on the ListView features currently in use. For instance, adding
* headers and/or footers will cause the adapter to be wrapped.
*
* @param adapter The ListAdapter which is responsible for maintaining the
*        data backing this list and for producing a view to represent an
*        item in that data set.
*
* @see #getAdapter()
*/
@Override
public void setAdapter(ListAdapter adapter) {
if (mAdapter != null && mDataSetObserver != null) {
mAdapter.unregisterDataSetObserver(mDataSetObserver);
}

resetList();
mRecycler.clear();

if (mHeaderViewInfos.size() > 0|| mFooterViewInfos.size() > 0) {
mAdapter = new HeaderViewListAdapter(mHeaderViewInfos, mFooterViewInfos, adapter);
} else {
mAdapter = adapter;
}

mOldSelectedPosition = INVALID_POSITION;
mOldSelectedRowId = INVALID_ROW_ID;

// AbsListView#setAdapter will update choice mode states.
super.setAdapter(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();
}

注意下面3行

mAdapter = adapter;

mDataSetObserver = new AdapterDataSetObserver();

mAdapter.registerDataSetObserver(mDataSetObserver);

当我们setAdapter(ListAdapter adapter)时，BaseAdapter同时注册了AdapterDataSetObserver()，至于AdapterDataSetObserver是如何通知Listvew和每个子item刷新（invalidate）的，这里涉及到的内容已经超出文章的范围，具体请查看源码。

其实，Android用到DataSetObserver的地方很多，Cursor,WebView,Adapter,…非常之多。