设计模式之观察者模式源码分析及实践

/**
 * 数据源，被观察者
 */
public class DataSource extends Observable {

    // 数据发生变化时调用该方法通知观察者
    public void updateData(String content){
        // 标记状态或内容已经发生改变
        setChanged();
        // 通知所有观察者
        notifyObservers(content);
    }
}

/**
 * 观察者，自定义 TextView，监听数据变化
 */

public class MyTextView extends TextView implements Observer {

    // 自定义 View 三个构造函数
    public MyTextView(Context context) {
        this(context,null);
    }

    public MyTextView(Context context, @Nullable AttributeSet attrs) {
        this(context, attrs,0);
    }

    public MyTextView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }
    // 父类 Observer 中的方法，当调用 notifyObservers 时调用
    @Override
    public void update(Observable o, Object arg) {
        setText(arg.toString());
    }
}

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.sky.viewtest.ObserverTestActivity">

    <Button
        android:id="@+id/btn_change"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="数据变化"/>

    <com.sky.viewtest.design_pattern.MyTextView
        android:id="@+id/tv_text1"
        android:layout_width="match_parent"
        android:layout_height="30dp"
        android:gravity="center"/>

    <com.sky.viewtest.design_pattern.MyTextView
        android:id="@+id/tv_text2"
        android:layout_width="match_parent"
        android:gravity="center"
        android:layout_height="30dp" />

</LinearLayout>

public class ObserverTestActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_observer);
        // 模拟数据变化
        findViewById(R.id.btn_change).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                changeData();
            }
        });
    }

    private void changeData(){
        // 创建具体的被观察者类实例
        DataSource dataSource = new DataSource();

        MyTextView myTextView1 = (MyTextView) findViewById(R.id.tv_text1);
        MyTextView myTextView2 = (MyTextView) findViewById(R.id.tv_text2);
        // 添加观察者
        dataSource.addObserver(myTextView1);
        dataSource.addObserver(myTextView2);
        // 通知所有观察者数据更新
        dataSource.updateData("数据变化啦");
    }

}

public interface Observer {
    void update(Observable o, Object arg);
}

public class Observable {
    // 1.1 数据是否变化标记
    private boolean changed = false;
    // 1.2 长度自增长数组
    private Vector<Observer> obs;

    /** Construct an Observable with zero Observers. */

    public Observable() {
        obs = new Vector<>();
    }
    // 2.1 添加观察者对象
    public synchronized void addObserver(Observer o) {
        if (o == null)
            throw new NullPointerException();
        if (!obs.contains(o)) {
            obs.addElement(o);
        }
    }
    // 2.2 删除观察者对象
    public synchronized void deleteObserver(Observer o) {
        obs.removeElement(o);
    }
    // 3.1 通知所有观察者
    public void notifyObservers() { 
        notifyObservers(null);
    }

    public void notifyObservers(Object arg) {
        Object[] arrLocal;
        // 线程同步
        synchronized (this) {
            // 3.2 获取是否发生变化的标记
            if (!hasChanged())
                return;
            // 3.3 转化为 Object 数组
            arrLocal = obs.toArray();
            // 重置标记
            clearChanged();
        }
        // 遍历所有观察者并调用其 update 方法
        for (int i = arrLocal.length-1; i>=0; i--)
            ((Observer)arrLocal[i]).update(this, arg);
    }
    // 删除所有观察者对象
    public synchronized void deleteObservers() {
        obs.removeAllElements();
    }
    // 设置标记为 true，表明数据发生了变化且已经通知过
    protected synchronized void setChanged() {
        changed = true;
    }
    // 清除标记，恢复默认状态
    protected synchronized void clearChanged() {
        changed = false;
    }
    // 获取标记
    public synchronized boolean hasChanged() {
        return changed;
    }
    // 获取观察者的数量
    public synchronized int countObservers() {
        return obs.size();
    }
}

public abstract static class Adapter<VH extends RecyclerView.ViewHolder> {
    private final RecyclerView.AdapterDataObservable mObservable = new RecyclerView.AdapterDataObservable();
    ...
    public final void notifyDataSetChanged() {
        mObservable.notifyChanged();
    }
    ...
}

static class AdapterDataObservable extends Observable<AdapterDataObserver>

package android.database;

import java.util.ArrayList;

/**
 * Provides methods for registering or unregistering arbitrary observers in an {@link ArrayList}.
 *
 * This abstract class is intended to be subclassed and specialized to maintain
 * a registry of observers of specific types and dispatch notifications to them.
 *
 * @param T The observer type.
 */
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);
        }
    }

    /**
     * Removes a previously registered observer. The observer must not be null and it
     * must already have been registered.
     * @param observer the observer to unregister
     * @throws IllegalArgumentException the observer is null
     * @throws IllegalStateException the observer is not yet registered
     */
    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);
        }
    }

    /**
     * Remove all registered observers.
     */
    public void unregisterAll() {
        synchronized(mObservers) {
            mObservers.clear();
        }
    }
}

public class RecyclerView extends ViewGroup implements ScrollingView, NestedScrollingChild2 {
    // 为了方便理解我打乱了顺序，不要钻牛角尖
    // 1. AdapterDataObservable：具体被观察者   Observable：抽象被观察者
    static class AdapterDataObservable extends Observable<AdapterDataObserver> {
        //3.mObservable.notifyChanged()
        public void notifyChanged() {
            for (int i = mObservers.size() - 1; i >= 0; i--) {
                mObservers.get(i).onChanged();
            }
        }
    }
    ...
    public abstract static class Adapter<VH extends ViewHolder> {
        //2. 具体被观察者实例 mObservable
        private final AdapterDataObservable mObservable = new AdapterDataObservable();
        ...
        public final void notifyDataSetChanged() {
            mObservable.notifyChanged();
        }
    }
}

public void notifyChanged() {
    for (int i = mObservers.size() - 1; i >= 0; i--) {
        mObservers.get(i).onChanged();
    }
}

public abstract static class AdapterDataObserver {
    public void onChanged() {
        // Do nothing
    }
    ...
}

private class RecyclerViewDataObserver extends AdapterDataObserver {
    RecyclerViewDataObserver() {
    }

    @Override
    public void onChanged() {
        assertNotInLayoutOrScroll(null);
        mState.mStructureChanged = true;

        setDataSetChangedAfterLayout();
        if (!mAdapterHelper.hasPendingUpdates()) {
            requestLayout();
        }
    }
    ...
}

public void setAdapter(Adapter adapter) {
    // bail out if layout is frozen
    setLayoutFrozen(false);
    setAdapterInternal(adapter, false, true);
    requestLayout();
}

private final RecyclerViewDataObserver mObserver = new RecyclerViewDataObserver();

private void setAdapterInternal(Adapter adapter, boolean compatibleWithPrevious,
                                boolean removeAndRecycleViews) {
    //1.第一个 if 
    if (mAdapter != null) {
        mAdapter.unregisterAdapterDataObserver(mObserver);
        mAdapter.onDetachedFromRecyclerView(this);
    }
    if (!compatibleWithPrevious || removeAndRecycleViews) {
        removeAndRecycleViews();
    }
    mAdapterHelper.reset();
    final Adapter oldAdapter = mAdapter;
    mAdapter = adapter;
    //2.为新的 adapter 注册观察者 
    if (adapter != null) {
        adapter.registerAdapterDataObserver(mObserver);
        adapter.onAttachedToRecyclerView(this);
    }
    if (mLayout != null) {
        mLayout.onAdapterChanged(oldAdapter, mAdapter);
    }
    mRecycler.onAdapterChanged(oldAdapter, mAdapter, compatibleWithPrevious);
    mState.mStructureChanged = true;
    markKnownViewsInvalid();
}

public void unregisterAdapterDataObserver(AdapterDataObserver observer) {
    mObservable.unregisterObserver(observer);
}

public void registerAdapterDataObserver(AdapterDataObserver observer) {
    mObservable.registerObserver(observer);
}

//被观察者（一个抽象类，方便扩展）
public abstract class Observable{

    public final ArrayList<Class<?>> obserList = new ArrayList<Class<?>>();

    /**AttachObserver（通过实例注册观察者）
    *<b>Notice:</b>obcan'tbenull,oritwillthrowNullPointerException
    **/
    public<T> void registerObserver(T ob){
        if(ob==null) throw new NullPointerException();
        this.registerObserver(ob.getClass());
    }

    /**
    *AttachObserver（通过Class注册观察者）
    *@paramcls
    */
    public void registerObserver(Class<?> cls){
        if(cls==null) throw new NullPointerException();
        synchronized(obserList){
            if(!obserList.contains(cls)){
                obserList.add(cls);
            }
        }
    }

    /**UnattachObserver（注销观察者）
    *<b>Notice:</b>
    *<b>ItreverseswithattachObserver()method</b>
    **/
    public<T>void unRegisterObserver(Tob){
        if(ob==null) throw new NullPointerException();
        this.unRegisterObserver(ob.getClass());
    }

    /**UnattachObserver（注销观察者，有时候在未获取到实例使用）
    *<b>Notice:</b>
    *<b>ItreverseswithattachObserver()method</b>
    **/
    public void unRegisterObserver(Class<?>cls){
        if(cls==null) throw new NullPointerException();
        synchronized(obserList){
            Iterator<Class<?>>iterator=obserList.iterator();
            while(iterator.hasNext()){
                if(iterator.next().getName().equals(cls.getName())){
                    iterator.remove();
                    break;
                }
            }
        }
    }

    /**detachallobservers*/
    public void unRegisterAll(){
        synchronized(obserList){
            obserList.clear();
        }
    }

    /**Ruturnthesizeofobservers*/
    public int countObservers(){
        synchronized(obserList){
            returnobserList.size();
        }
    }

    /**
    *notify all observer（通知所有观察者，在子类中实现）
    *@paramobjs
    */
    public abstract void notifyObservers(Object... objs);

    /**
    *notify one certain observer（通知某一个确定的观察者）
    *@paramcls
    *@paramobjs
    */
    public abstract void notifyObserver(Class<?> cls, Object... objs);

    /**
    *notifyonecertainobserver
    *@paramcls
    *@paramobjs
    */
    public abstract<T> void notifyObserver(T t, Object... objs);
}

//观察者，需要用到观察者模式的类需实现此接口
public interface Observer{
    void update(Object...objs);
}

//目标被观察者
public class ConcreteObservable extends Observable{

    private static ConcreteObservableinstance = null;
    private ConcreteObservable(){};
    public static synchronized ConcreteObservablegetInstance(){
        if(instance == null){
            instance=newConcreteObservable();
        }
        returninstance;
    }

    @Override
    public <T> void notifyObserver(T t, Object... objs){
        if(t == null) throw new NullPointerException();
        this.notifyObserver(t.getClass(), objs);
    }

    @Override
    public void notifyObservers(Object... objs){
        for(Class<?>cls : obserList){
            this.notifyObserver(cls, objs);
        }
    }

    //通过java反射机制实现调用
    @Override
    public void notifyObserver(Class<?>cls, Object...objs){
        if(cls == null) throw new NullPointerException();
        Method[] methods = cls.getDeclaredMethods();
        for(Method method : methods){
            if(method.getName().equals("update")){
                try{
                    method.invoke(cls,objs);
                    break;
                }catch(IllegalArgumentException e){
                    e.printStackTrace();
                }catch(IllegalAccessException e){
                    e.printStackTrace();
                }catch(InvocationTargetException e){
                    e.printStackTrace();
                }
            }
        }
    }
}

//使用(实现Observer接口）
public class Text extends Activity implements Observer{
    publicvoidonCreate(...){
        ConcreteObservable.getInstance().registerObserver(Text.class);
        ....
    }

    //实现接口处理
    publicvoidupdate(Object...objs){
        //做操作，比如更新数据，更新UI等
    }
}