設計模式（五）觀察者模式

1.觀察者模式模式簡介

定義

觀察者模式（又被稱爲發佈-訂閱（Publish/Subscribe）模式，屬於行爲型模式的一種，它定義了一種一對多的依賴關係，讓多個觀察者對象同時監聽某一個主題對象。這個主題對象在狀態變化時，會通知所有的觀察者對象，使他們能夠自動更新自己。

觀察者模式結構圖

Subject：抽象主題（抽象被觀察者），抽象主題角色把所有觀察者對象保存在一個集合裏，每個主題都可以有任意數量的觀察者，抽象主題提供一個接口，可以增加和刪除觀察者對象。
ConcreteSubject：具體主題（具體被觀察者），該角色將有關狀態存入具體觀察者對象，在具體主題的內部狀態發生改變時，給所有註冊過的觀察者發送通知。
Observer：抽象觀察者，是觀察者者的抽象類，它定義了一個更新接口，使得在得到主題更改通知時更新自己。
ConcrereObserver：具體觀察者，是實現抽象觀察者定義的更新接口，以便在得到主題更改通知時更新自身的狀態。

2.觀察者模式簡單實現

觀察者模式這種發佈-訂閱的形式我們可以拿微信公衆號來舉例，假設微信用戶就是觀察者，微信公衆號是被觀察者，有多個的微信用戶關注了程序猿這個公衆號，當這個公衆號更新時就會通知這些訂閱的微信用戶。好了我們來看看用代碼如何實現：

抽象觀察者（Observer）

裏面定義了一個更新的方法：

public interface Observer {
    public void update(String message);
}

具體觀察者（ConcrereObserver）

微信用戶是觀察者，裏面實現了更新的方法：

public class WeixinUser implements Observer {
    // 微信用戶名
    private String name;
    public WeixinUser(String name) {
        this.name = name;
    }
    @Override
    public void update(String message) {
        System.out.println(name + "-" + message);
    }


}

抽象被觀察者（Subject）

抽象主題，提供了attach、detach、notify三個方法：

public interface Subject {
    /**
     * 增加訂閱者
     * @param observer
     */
    public void attach(Observer observer);
    /**
     * 刪除訂閱者
     * @param observer
     */
    public void detach(Observer observer);
    /**
     * 通知訂閱者更新消息
     */
    public void notify(String message);
}

察者（ConcreteSubject）

微信公衆號是具體主題（具體被觀察者），裏面存儲了訂閱該公衆號的微信用戶，並實現了抽象主題中的方法：

public class SubscriptionSubject implements Subject {
    //儲存訂閱公衆號的微信用戶
    private List<Observer> weixinUserlist = new ArrayList<Observer>();

    @Override
    public void attach(Observer observer) {
        weixinUserlist.add(observer);
    }

    @Override
    public void detach(Observer observer) {
        weixinUserlist.remove(observer);
    }

    @Override
    public void notify(String message) {
        for (Observer observer : weixinUserlist) {
            observer.update(message);
        }
    }
}

客戶端調用

public class Client {
    public static void main(String[] args) {
        SubscriptionSubject mSubscriptionSubject=new SubscriptionSubject();
        //創建微信用戶
        WeixinUser user1=new WeixinUser("楊影楓");
        WeixinUser user2=new WeixinUser("月眉兒");
        WeixinUser user3=new WeixinUser("紫軒");
        //訂閱公衆號
        mSubscriptionSubject.attach(user1);
        mSubscriptionSubject.attach(user2);
        mSubscriptionSubject.attach(user3);
        //公衆號更新發出消息給訂閱的微信用戶
        mSubscriptionSubject.notify("劉望舒的專欄更新了");
    }
}

結果

楊影楓-劉望舒的專欄更新了
月眉兒-劉望舒的專欄更新了
紫軒-劉望舒的專欄更新了

3.使用觀察者模式的場景和優缺點

使用場景

關聯行爲場景，需要注意的是，關聯行爲是可拆分的，而不是“組合”關係。
事件多級觸發場景。
跨系統的消息交換場景，如消息隊列、事件總線的處理機制。

優點

解除耦合，讓耦合的雙方都依賴於抽象，從而使得各自的變換都不會影響另一邊的變換。

缺點

在應用觀察者模式時需要考慮一下開發效率和運行效率的問題，程序中包括一個被觀察者、多個觀察者，開發、調試等內容會比較複雜，而且在Java中消息的通知一般是順序執行，那麼一個觀察者卡頓，會影響整體的執行效率，在這種情況下，一般會採用異步實現。

4.Android中的觀察者模式

Android源碼中也有很多使用了觀察者模式，比如OnClickListener、ContentObserver、android.database.Observable等；還有組件通訊庫RxJava、RxAndroid、EventBus；在這裏將拿我們最常用的Adapter的notifyDataSetChanged()方法來舉例：
當我們用ListView的時候，數據發生變化的時候我們都會調用Adapter的notifyDataSetChanged()方法，這個方法定義在BaseAdaper中，我們來看看BaseAdaper的部分源碼：

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

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

    /**
     * 當數據集變化時，通知所有觀察者
     */
    public void notifyDataSetChanged() {
        mDataSetObservable.notifyChanged();
    }

很明顯BaseAdapter用的是觀察者模式，BaseAdapter是具體被觀察者，接下來看看mDataSetObservable.notifyChanged()：

public class DataSetObservable extends Observable<DataSetObserver> {
    public void notifyChanged() {
        synchronized(mObservers) {
            for (int i = mObservers.size() - 1; i >= 0; i--) {
                mObservers.get(i).onChanged();
            }
        }
    }

我們看到了mObservers，這就是觀察者的集合，這些觀察者是在ListView通過setAdaper()設置Adaper時產生的：

@Override
    public void setAdapter(ListAdapter adapter) {
        if (mAdapter != null && mDataSetObserver != null) {
            mAdapter.unregisterDataSetObserver(mDataSetObserver);
        }
        ...
        super.setAdapter(adapter);

        if (mAdapter != null) {
            mAreAllItemsSelectable = mAdapter.areAllItemsEnabled();
            mOldItemCount = mItemCount;
            mItemCount = mAdapter.getCount();
            checkFocus();
            //創建數據觀察者
            mDataSetObserver = new AdapterDataSetObserver();
            //註冊觀察者
            mAdapter.registerDataSetObserver(mDataSetObserver);

            ...
        }

接下來看看觀察者AdapterDataSetObserver中處理了什麼：

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

從上面的代碼看不出什麼，再看看AdapterDataSetObserver的父類AdapterView的AdapterDataSetObserver：

class AdapterDataSetObserver extends DataSetObserver {
        private Parcelable mInstanceState = null;
        @Override
        public void onChanged() {
            mDataChanged = true;
            mOldItemCount = mItemCount;
            mItemCount = getAdapter().getCount();
            if (AdapterView.this.getAdapter().hasStableIds() && mInstanceState != null
                    && mOldItemCount == 0 && mItemCount > 0) {
                AdapterView.this.onRestoreInstanceState(mInstanceState);
                mInstanceState = null;
            } else {
                rememberSyncState();
            }
            checkFocus();
            //重新佈局
            requestLayout();
        }

        ...

        public void clearSavedState() {
            mInstanceState = null;
        }
    }

我們看到在onChanged()方法中調用了requestLayout()方法來重新進行佈局。好了，看到這裏我們都明白了，當ListView的數據發生變化時，我們調用Adapter的notifyDataSetChanged()方法，這個方法又會調用觀察者們（AdapterDataSetObserver）的onChanged()方法，onChanged()方法又會調用requestLayout()方法來重新進行佈局。

魯南周潤發

發佈了24 篇原創文章 · 獲贊 11 · 訪問量 5萬+

私信關注

設計模式（五）觀察者模式

1.觀察者模式模式簡介

2.觀察者模式簡單實現

3.使用觀察者模式的場景和優缺點

4.Android中的觀察者模式

物理機開關機

Unity3D中Vector3.SmoothDamp原理，適用於CocosCreate、LayaBox等引擎

多邊形碰撞檢測（判斷點在多邊形內）

設計模式（十）工廠方法模式

設計模式（七）裝飾模式

設計模式（一）設計六大原則

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結