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

1.觀察者模式模式簡介

定義

觀察者模式（又被稱為發(fā)布-訂閱（Publish/Subscribe）模式，屬于行為型模式的一種，它定義了一種一對多的依賴關系，讓多個觀察者對象同時監(jiān)聽某一個主題對象。這個主題對象在狀態(tài)變化時，會通知所有的觀察者對象，使他們能夠自動更新自己。

觀察者模式結構圖

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

2.觀察者模式簡單實現(xiàn)

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

抽象觀察者（Observer）

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

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

具體觀察者（ConcrereObserver）

微信用戶是觀察者，里面實現(xiàn)了更新的方法：

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）

微信公眾號是具體主題（具體被觀察者），里面存儲了訂閱該公眾號的微信用戶，并實現(xiàn)了抽象主題中的方法：

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();
        //創(chuàng)建微信用戶
        WeixinUser user1=new WeixinUser("楊影楓");
        WeixinUser user2=new WeixinUser("月眉兒");
        WeixinUser user3=new WeixinUser("紫軒");
        //訂閱公眾號
        mSubscriptionSubject.attach(user1);
        mSubscriptionSubject.attach(user2);
        mSubscriptionSubject.attach(user3);
        //公眾號更新發(fā)出消息給訂閱的微信用戶
        mSubscriptionSubject.notify("劉望舒的專欄更新了");
    }
}

結果

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

3.使用觀察者模式的場景和優(yōu)缺點

使用場景

  • 關聯(lián)行為場景，需要注意的是，關聯(lián)行為是可拆分的，而不是“組合”關系。
  • 事件多級觸發(fā)場景。
  • 跨系統(tǒng)的消息交換場景，如消息隊列、事件總線的處理機制。

優(yōu)點

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

缺點

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

4.Android中的觀察者模式

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

public abstract class BaseAdapter implements ListAdapter, SpinnerAdapter {

    //數(shù)據(jù)集觀察者
    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);
    }

    /**
     * 當數(shù)據(jù)集變化時，通知所有觀察者
     */
    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時產(chǎn)生的：

@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();
            //創(chuàng)建數(shù)據(jù)觀察者
            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的數(shù)據(jù)發(fā)生變化時，我們調用Adapter的notifyDataSetChanged()方法，這個方法又會調用觀察者們（AdapterDataSetObserver）的onChanged()方法，onChanged()方法又會調用requestLayout()方法來重新進行布局。

最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯(lián)系作者
【社區(qū)內容提示】社區(qū)部分內容疑似由AI輔助生成，瀏覽時請結合常識與多方信息審慎甄別。
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發(fā)布，文章內容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務。

相關閱讀更多精彩內容

友情鏈接更多精彩內容