设计模式学习笔记之观察者模式(一)-CSDN博客

本文链接：https://blog.csdn.net/yes7488266/article/details/50616496

观察者(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,…非常之多。