中的監聽器模式與觀察者模式
1、 觀察者模式與監聽器機制
1.1 觀察者模式
1.2 監聽器（Listener）機制
代碼的基本框架：
* 被監控著
package com.wonders.group;
import java.util.Collection;
public class ModelTie {
private Collection<Object> dataSet;
public interface DataSetSupervioer {
public void onChange();
}
private DataSetSupervioer dataSetChangeListener;
public void setDataSetChangeListener(DataSetSupervioer
dataSetChangeListener) {
this.dataSetChangeListener = dataSetChangeListener;
}
public void notifyDataSetChange() {
if (null != dataSetChangeListener) {
dataSetChangeListener.onChange();
}
}
public Collection<Object> getDataSet() {
return dataSet;
}
public ModelTie setDataSet(Collection<Object> dataSet)
{
this.dataSet = dataSet;
this.notifyDataSetChange(); // 數據設置完畢要通知監聽器進行更新操作
return this;
}
}
* 監控者
package com.wonders.group;
import java.util.Collection;
import java.util.Iterator;
import com.wonders.group.ModelTie.DataSetSupervioer;
public class PresentationTie {
private ModelTie model;
public PresentationTie() {
super();
// 添加監聽器
model.setDataSetChangeListener(new DataSetSupervioer()
{
public void onChange() {
// 填寫壹些前置操作，如更新數據
DisplayModel(); // 重新繪制
// 填寫壹些後置操作，如更新狀態
}
});
}
public void DisplayModel() {
Collection<Object> collection =
model.getDataSet();
if (collection != null) {
for (Iterator iterator = collection.iterator();
iterator.hasNext();) {
System.out.println(((Object)
iterator.next()).toString());
// 其他等等操作
}
}
}
public ModelTie getModel() {
return model;
}
public void setModel(ModelTie model) {
this.model = model;
}
}
2、
ArrayAdapter的觀察者實現機制
以下僅羅列關鍵代碼：
public class ArrayAdapter<T> extends BaseAdapter implements Filterable
{
private boolean mNotifyOnChange = true;
/**
* Adds the specified object at the end of the array.
*/
public void add(T object) {
if (mOriginalValues != null) {
synchronized (mLock) {
mOriginalValues.add(object);
if (mNotifyOnChange) notifyDataSetChanged();
}
} else {
mObjects.add(object);
if (mNotifyOnChange) notifyDataSetChanged();
}
}
/**
* Inserts the specified object at the specified index in the
array.
*/
public void insert(T object, int index) {
if (mOriginalValues != null) {
synchronized (mLock) {
mOriginalValues.add(index, object);
if (mNotifyOnChange) notifyDataSetChanged();
}
} else {
mObjects.add(index, object);
if (mNotifyOnChange) notifyDataSetChanged();
}
}
/**
* Removes the specified object from the array.
*/
public void remove(T object) {
if (mOriginalValues != null) {
synchronized (mLock) {
mOriginalValues.remove(object);
}
} else {
mObjects.remove(object);
}
if (mNotifyOnChange) notifyDataSetChanged();
}
/**
* Remove all elements from the list.
*/
public void clear() {
if (mOriginalValues != null) {
synchronized (mLock) {
mOriginalValues.clear();
}
} else {
mObjects.clear();
}
if (mNotifyOnChange) notifyDataSetChanged();
}
/**
* Sorts the content of this adapter using the specified
comparator.
*/
public void sort(Comparator<? super T> comparator) {
Collections.sort(mObjects, comparator);
if (mNotifyOnChange) notifyDataSetChanged();
}
@Override
public void notifyDataSetChanged() {
super.notifyDataSetChanged(); //
關鍵代碼，這個notifyDataSetChanged()是從父類BaseAdapter繼承過來的，所以看看在父類中它幹了些什麽
mNotifyOnChange = true;
}
}
/**
* Common base class of common implementation for an {@link
Adapter} that can be
* used in both {@link ListView} (by implementing the
specialized
* {@link ListAdapter} interface} and {@link Spinner} (by
implementing the
* specialized {@link SpinnerAdapter} interface.
*/
public abstract class BaseAdapter implements ListAdapter,
SpinnerAdapter {
private final DataSetObservable mDataSetObservable = new
DataSetObservable();
public void registerDataSetObserver(DataSetObserver observer)
{
這對方法用來註冊或註銷
觀察ArrayAdapter的觀察者的
mDataSetObservable.registerObserver(observer);
}
public void unregisterDataSetObserver(DataSetObserver
observer) {
mDataSetObservable.unregisterObserver(observer);
}
/**
* Notifies the attached View that the underlying data has
been changed
* and it should refresh itself.
*/
public void notifyDataSetChanged() {
mDataSetObservable.notifyChanged(); //
關鍵代碼：說明調的是成員變量mDataSetObservable的方法，所以進入DataSetObservable看看具體是如何操作的
}
public void notifyDataSetInvalidated() {
mDataSetObservable.notifyInvalidated();
}
}
package android.database;
/**
* A specialization of Observable for DataSetObserver that
provides methods for
* invoking the various callback methods of DataSetObserver.
*/
public class DataSetObservable extends
Observable<DataSetObserver> {
/**
* Invokes onChanged on each observer. Called when the data
set being observed has
* changed, and which when read contains the new state of the
data.
*/
public void notifyChanged() {
synchronized(mObservers) {
for (DataSetObserver observer : mObservers) { //
這裏的mObservers是哪來的呢?繼續追蹤，但首先可以判斷是來自Observable<DataSetObserver>的。進入看看
observer.onChanged();
}
}
}
/**
* Invokes onInvalidated on each observer. Called when the
data set being monitored
* has changed such that it is no longer valid.
*/
public void notifyInvalidated() {
synchronized (mObservers) {
for (DataSetObserver observer : mObservers) {
observer.onInvalidated();
}
}
}
}
public abstract class Observable<T> {
/**
* The list of observers. An observer can be in the list at
most
* once and will never be null.
*/
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();
}
}
}