Android 设计模式：观察者模式详解

setChanged();告知数据改变，通过 notifyObservers();发送信号通知观察者。

MyObserver 是观察者

public class MyObserver implements Observer {

    private int id;
    private MyPerson myPerson;

    public MyObserver(int id) {
        System.out.println("我是观察者---->" + id);
        this.id = id;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public MyPerson getMyPerson() {
        return myPerson;
    }

    public void setMyPerson(MyPerson myPerson) {
        this.myPerson = myPerson;
    }

    @Override
    public void update(Observable observable, Object data) {
        System.out.println("观察者---->" + id + "得到更新");
        this.myPerson = (MyPerson) observable;
        System.out.println(((MyPerson) observable).toString());
    }

}

观察者接受到通知后，调用 update 方法进行更新操作。

public class MainActivity extends Activity {

    private Button btnAddObserver;
    private Button btnChangeData;
    private MyPerson observable;
    private MyObserver myObserver;
    private List<MyObserver> myObservers;
    private ListView listview;

    private int i;

    private Handler handler = new Handler() {
        public void handleMessage(android.os.Message msg) {
            MyListAdapter myListAdapter = new MyListAdapter(MainActivity.this,
                    myObservers);
            listview.setAdapter(myListAdapter);

        };
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        btnAddObserver = (Button) findViewById(R.id.btn_add_observer);
        btnChangeData = (Button) findViewById(R.id.btn_change_data);
        listview = getListView();

        observable = new MyPerson();
        myObservers = new ArrayList<MyObserver>();

        btnAddObserver.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                myObserver = new MyObserver(i);
                i++;
                observable.addObserver(myObserver);
                myObservers.add(myObserver);
                handler.sendEmptyMessage(0);
            }
        });

        btnChangeData.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                observable.setName("a" + i);
                observable.setAge(10 + i);
                observable.setSex("男" + i);
                handler.sendEmptyMessage(0);
            }
        });

    }

    @Override
    protected void onDestroy() {
        // TODO Auto-generated method stub
        super.onDestroy();
        observable.deleteObserver(myObserver);
    }
}

Android 源码中的模式实现

在以前，我们最常用到的控件就是 ListView 了，而 ListView 最重要的一个点就是 Adapter，在我们往 ListView 添加数据后，我们都会调用一个方法：notifyDataSetChanged(), 这个方法就是用到了我们所说的观察者模式。

跟进这个方法 notifyDataSetChanged 方法，这个方法定义在 BaseAdapter 中，代码如下：

public abstract class BaseAdapter implements ListAdapter, SpinnerAdapter {
    // 数据集观察者
    private final DataSetObservable mDataSetObservable = new DataSetObservable();

    // 代码省略

    public void registerDataSetObserver(DataSetObserver observer) {
        mDataSetObservable.registerObserver(observer);
    }

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

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

可以发现，当数据发生变化时候，notifyDataSetChanged 中会调用 mDataSetObservable.notifyChanged() 方法

public class DataSetObservable extends Observable<DataSetObserver> {
    /**
     * Invokes onChanged on each observer. Called when the data set being observed has
     * changed, and which when read contains the new state of the data.
     */
    public void notifyChanged() {
        synchronized(mObservers) {
            // 调用所有观察者的 onChanged 方式
            for (int i = mObservers.size() - 1; i >= 0; i--) {
                mObservers.get(i).onChanged();
            }
        }
    }

}

mDataSetObservable.notifyChanged() 中遍历所有观察者，并且调用它们的 onChanged 方法。

那么这些观察者是从哪里来的呢？首先 ListView 通过 setAdapter 方法来设置 Adapter

@Override
public void setAdapter(ListAdapter adapter) {
    // 如果已经有了一个 adapter，那么先注销该 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();
        // 将这个观察者注册到 Adapter 中，实际上是注册到 DataSetObservable 中
        mAdapter.registerDataSetObserver(mDataSetObserver);

        // 代码省略
    } else {
        // 代码省略
    }

    requestLayout();
}

在设置 Adapter 时会构建一个 AdapterDataSetObserver，最后将这个观察者注册到 adapter 中，这样我们的被观察者、观察者都有了。

AdapterDataSetObserver 定义在 ListView 的父类 AbsListView 中，代码如下：

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

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

它由继承自 AbsListView 的父类 AdapterView 的 AdapterDataSetObserver，代码如下：

class AdapterDataSetObserver extends DataSetObserver {

    private Parcelable mInstanceState = null;
    // 调用 Adapter 的 notifyDataSetChanged 的时候会调用所有观察者的 onChanged 方法，核心实现就在这里
    @Override
    public void onChanged() {
        mDataChanged = true;
        mOldItemCount = mItemCount;
        // 获取 Adapter 中数据的数量
        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();
        // 重新布局 ListView、GridView 等 AdapterView 组件
        requestLayout();
    }

    // 代码省略

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

当 ListView 的数据发生变化时，调用 Adapter 的 notifyDataSetChanged 函数，这个函数又会调用 DataSetObservable 的 notifyChanged 函数，这个函数会调用所有观察者 (AdapterDataSetObserver) 的 onChanged 方法。这就是一个观察者模式！

总结：AdapterView 中有一个内部类 AdapterDataSetObserver，在 ListView 设置 Adapter 时会构建一个 AdapterDataSetObserver，并且注册到 Adapter 中，这个就是一个观察者。而 Adapter 中包含一个数据集可观察者 DataSetObservable，在数据数量发生变更时开发者手动调用 Adapter notifyDataSetChanged，而 notifyDataSetChanged 实际上会调用 DataSetObservable 的 notifyChanged 函数，该函数会遍历所有观察者的 onChanged 函数。在 AdapterDataSetObserver 的 onChanged 函数中会获取 Adapter 中数据集的新数量，然后调用 ListView 的 requestLayout() 方法重新进行布局，更新用户界面。

常见开源框架实现

比较知名的使用观察者模式的开源框架有 RxJava、LiveData、EventBus 等。这些框架在底层大多基于此模式实现事件分发与数据监听机制。

RxJava 通过 Observable 和 Observer 接口实现了响应式编程，支持异步流处理。LiveData 作为 Jetpack 的一部分，利用观察者模式确保 UI 组件在数据变化时安全更新，且遵循生命周期感知原则。EventBus 则提供了一种轻量级的发布订阅机制，用于组件间解耦通信。

最佳实践与注意事项

在使用观察者模式时，特别是在 Android 开发中，需要注意内存泄漏问题。如果观察者持有了 Context 的强引用，且未及时注销，会导致 Context 无法被 GC 回收。建议使用 WeakReference 持有 Context，或者在 Activity/Fragment 销毁时主动移除观察者。此外，对于高频通知场景，应评估线程切换开销，避免主线程阻塞。

模式总结

优点

观察者模式解除了主题和具体观察者的耦合，让耦合的双方都依赖于抽象，而不是依赖具体。从而使得各自的变化都不会影响另一边的变化。

缺点

依赖关系并未完全解除，抽象通知者依旧依赖抽象的观察者。

适用场景

当一个对象的改变需要给变其它对象时，而且它不知道具体有多少个对象有待改变时。

一个抽象某型有两个方面，当其中一个方面依赖于另一个方面，这时用观察者模式可以将这两者封装在独立的对象中使它们各自独立地改变和复用。