设计模式---观察者模式

定义：

对象间的一对多关系，当一个对象发生改变时，所依赖它的对象都会得到通知

（当某个事件发生，会引发其它事件的发送）

现实生活中场景：

1.电饭锅煮饭，当室内饭熟了，会自动跳转到保温模式

2.ATM取款机，输入密码连续几次错误时，自动吞卡，并通知摄像头连续拍摄

类图：

通用代码：

观察者：

package com.lt.observer;

public interface Observer {

	public void update();
}

被观察者：

package com.lt.observer;

import java.util.ArrayList;
import java.util.List;

public abstract class Subject {

	public List<Observer> list = new ArrayList<Observer>();

	public void addObserver(Observer observer) {
		list.add(observer);
	}

	public void deleteObserver(Observer observer) {
		list.remove(observer);
	}

	public void notifyObservers() {
		for (Observer observer : list) {
			observer.update();
		}
	}
}

观察者A：

package com.lt.observer;

public class ObserverA implements Observer{

	@Override
	public void update() {
		System.out.println("观察者A:update");
	}

}

观察者B:

package com.lt.observer;

public class ObserverB implements Observer{

	@Override
	public void update() {
		System.out.println("观察者B:update");
	}

}

main方法：

package com.lt.observer;

public class Main {

	public static void main(String[] args) {
		SubjectA subjectA = new SubjectA();
		ObserverA observerA = new ObserverA();
		ObserverB observerB = new ObserverB();
		subjectA.addObserver(observerA);
		subjectA.addObserver(observerB);
		subjectA.notifyObservers();
	}
}

结果：

java中提供了已经封装好的Observer和Observable类。

Android中观察者模式的应用：

BaseAdapter对象调用notifyDataSetChanged()方法通知ListView对象刷新界面，BaseAdapter相当于“被观察者”，ListView相当于“观察者”，当BaseAdapter对象的数据发生变化时，调用notifyDataSetChanged()通知ListView对象刷新界面。

原代码：

1.

/**
     * 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调用notifyDataSetChanged()，在该方法中调用mDataSetObservable的notifyChanged()，接下来我们看看mDataSetObservable和notifyChanged()方法

2.

public abstract class BaseAdapter implements ListAdapter, SpinnerAdapter {
    private final DataSetObservable mDataSetObservable = new DataSetObservable();

mDataSetObservable为DataSetObservable的实例，从这边我们可以知道mDataSetObservable就是观察者模式中的被观察者对象，DataSetObservable为被观察者类

3.

public class DataSetObservable extends Observable<DataSetObserver> {
    /**
     * Invokes {@link DataSetObserver#onChanged} on each observer.
     * Called when the contents of the data set have changed.  The recipient
     * will obtain the new contents the next time it queries the data set.
     */
    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();
            }
        }
    }

notifyChanged()方法中循环通知所有的观察者，调用观察者的onChanged()方法，该方法我们在第8步中再看，mObservers为观察者对象队列，那么mObservers从哪里来的呢，可以推断出在父
类Observable<DataSetObserver>中声明，我们再看Observable<DataSetObserver>类  

4.

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>();

    /**
     * Adds an observer to the list. The observer cannot be null and it must not already
     * be registered.
     * @param observer the observer to register
     * @throws IllegalArgumentException the observer is null
     * @throws IllegalStateException the observer is already registered
     */
    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);
        }
    }

mObservers是存放观察者的ArrayList，该类中用registerObserver(T observer)方法来注册一个观察者，这个方法哪里被调用的呢，来注册观察者呢。

5.

public abstract class BaseAdapter implements ListAdapter, SpinnerAdapter {
    private final DataSetObservable mDataSetObservable = new DataSetObservable();

    public boolean hasStableIds() {
        return false;
    }
    
    public void registerDataSetObserver(DataSetObserver observer) {
        mDataSetObservable.registerObserver(observer);
    }

在BaseAdapter类中我们可以看到registerDataSetObserver(DataSetObserver observer)方法调用了在第4步中的registerObserver(T observer)的方法，这个方法有在哪里调用的呢

6.

 @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());

在ListView类中setAdapter方法中可以看调用了mAdapter.registerDataSetObserver(mDataSetObserver)这个方法，在这里我们终于看到了第四步中mObservers的成员是从这里注册的，观察者对象为mDateSetObserver,接下来我们再看看mDateSetObserver对象。

7.

/**
     * Should be used by subclasses to listen to changes in the dataset
     */
    AdapterDataSetObserver mDataSetObserver;

mDateSetObserver对象是AdapterDataSetObserver类的实例

8.

现在我们再来看看第三步中的提到的onChanged方法，这个方法重写了父类的onChanged方法，我们再看看其父类的onChangede方法

class AdapterDataSetObserver extends AdapterView<ListAdapter>.AdapterDataSetObserver {
        @Override
        public void onChanged() {
            super.onChanged();
            if (mFastScroller != null) {
                mFastScroller.onSectionsChanged();
            }
        }

        @Override
        public void onInvalidated() {
            super.onInvalidated();
            if (mFastScroller != null) {
                mFastScroller.onSectionsChanged();
            }
        }
    }

9.

 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();
        }

该方法中最终zui调用了requestLayout()方法来重新刷新界面，也就是刷新了ListView。

总结：

ListView对象调用setAdapter(ListAdapter adapter)方法，

在该方法中调用adapter.registerDataSetObserver(mDataSetObserver),

registerDataSetObserver(mDataSetObserver)方法中又调用 mDataSetObservable.registerObserver(observer)方法，

完成”被观察者”mDataSetObservable注册”观察者”mDataSetObserver；

当adapter数据发生改变时，调用notifyDataSetChanged（）方法，

在该方法中又调用mDataSetObservable的notifyChanged()方法来通知观察者，

观察者调用onChanged()方法，执行requestLayout()来刷新界面

事件响应：

button.setonclickListener();

广播接受：