定义
定义对象之前一种一对多的依赖关系，使得当一个对象改变状态，所有依赖这个对象的对象都会得到通知并且自动更新。
使用场景
- 关联行为场景。ps:关联行为是可拆分的，不是“组合”关系
- 事件多级触发场景
- 跨系统的消息交互场景。比如消息队列事件总线的处理机制
结构和UML图
观察者模式UML.jpg
- Subject:抽象主题,也就是被观察者(Observable)角色，抽象主题角色把所有的观察者的引用保存在一个集合中，每个主题都可以有任意数量的观察者，抽象主题提供一个接口么可以添加/删除观察者对象。
- ConcreteSubject:具体主题，又名具体被观察者,该觉得将有关组状态保存进具体的观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知。
- Observer:抽象观察者，观察者的抽象类，定义了一个更新接口，使得在得到主题的更改通知时来更改自己。
- ConcreteSubject:具体的观察者，实现了抽象观察者角色所定义的更新接口，以便在主题的状态改变时更新自身的状态。
简单示例
我们平时如果订阅了某个平台的博客，在有新的博客时会通过邮件等方式通知我们订阅者。这里我就以这个写一个简单的观察者模式的示例
抽象主题:
//抽象主题角色，Subject：被观察者
public abstract class Blog {
protected final ArrayList<User> mObservers = new ArrayList();
public void addUser(User user){
mObservers.add(user);
}
public void removeUser(User user){
mObservers.remove(user);
}
public void removeAll(){
mObservers.clear();
}
}具体主题:
//具体主题角色，ConcreteSubject：具体被观察者
public class ConcreteBlog extends Blog{
public ConcreteBlog() {
// TODO Auto-generated constructor stub
}
public void notifyChanged(String str){
for(int i=mObservers.size()-1;i>=0;i--){
mObservers.get(i).update(str);
}
}
}抽象观察者:
//抽象观察者角色
public abstract class User {
public void update(String str) {
}
}具体的观察者:
public class ConcreteUser extends User {
@Override
public void update(String str) {
System.out.println(str);
}
}Client：
public class Client {
public Client() {
// TODO Auto-generated constructor stub
}
public static void main(String[] args) {
//创建被观察者
ConcreteBlog blog=new ConcreteBlog();
//创建观察者
ConcreteUser user1=new ConcreteUser();
ConcreteUser user2=new ConcreteUser();
ConcreteUser user3=new ConcreteUser();
//将观察者注册到可观察对象的观察者列表中
blog.addUser(user1);
blog.addUser(user2);
blog.addUser(user3);
blog.notifyChanged("发布博客了,快来看啊！");
}
}}RecyclerView源码中的观察者模式
在使用RecyclerView的时候，我们在每次更新了RecyclerView的数据后通常调用notifyDataSetChanged()方法来更新我们的视图，那么我们就从这里开始，一步步跟进到源码看看RecyclerView的观察者模式是怎么实现的
public static abstract class Adapter<VH extends ViewHolder> {
//定义观察者
private final AdapterDataObservable mObservable = new AdapterDataObservable();
private boolean mHasStableIds = false;
public abstract VH onCreateViewHolder(ViewGroup parent, int viewType);
.........//省略
public void registerAdapterDataObserver(AdapterDataObserver observer) {
mObservable.registerObserver(observer);
}
public void unregisterAdapterDataObserver(AdapterDataObserver observer) {
mObservable.unregisterObserver(observer);
}
//通知所有观察者
public final void notifyDataSetChanged() {
mObservable.notifyChanged();
}由上可知，其实我们的RecyclerView.Adapter本质就是观察者模式，接着下一步我们跟进到notifyDataSetChanged()方法来看看
static class AdapterDataObservable extends Observable<AdapterDataObserver> {
public boolean hasObservers() {
return !mObservers.isEmpty();
}
//调用没一个观察者的onChanged()方法来通知他们被观察者发生了变化
public void notifyChanged() {
for (int i = mObservers.size() - 1; i >= 0; i--) {
mObservers.get(i).onChanged();
}
}
public void notifyItemRangeChanged(int positionStart, int itemCount) {
notifyItemRangeChanged(positionStart, itemCount, null);
}
public void notifyItemRangeChanged(int positionStart, int itemCount, Object payload) {
for (int i = mObservers.size() - 1; i >= 0; i--) {
mObservers.get(i).onItemRangeChanged(positionStart, itemCount, payload);
}
}
.......//省略这样一看，原来就是在AdapterDataObservable.notifyChanged()方法中来遍历所有的观察者，调用他们的onChange()方法，来通知的。我特意还贴出了notifyItemRangeChanged()方法，我们发现都是通过一样的模式去通知观察者的。
这样下来，我们知道了被观察者(Observable)是怎么实现的，现在我们来找找看观察者(Observer)是从哪儿来的呢？
回想一下，平时我们RecyclerView关联数据的时候都是通过调用setAdapter()方法实现的，那我们进去看看
public void setAdapter(Adapter adapter) {
// bail out if layout is frozen
setLayoutFrozen(false);
setAdapterInternal(adapter, false, true);
requestLayout();
}咦？该方法把adapter传进了setAdapterInternal()方法，我们再跟进去看看。其实看到最后调用requestLayout()方法来重绘View我们就知道观察者的注册操作肯定是在上面方法中完成。
//定义在RecyclerView中，RecyclerViewDataObserver继承与AdapterDataObserver
private final RecyclerViewDataObserver mObserver = new RecyclerViewDataObserver();
private void setAdapterInternal(Adapter adapter, boolean compatibleWithPrevious,
boolean removeAndRecycleViews) {
//如果当前已经存在一个adapter了，就先注销这个adapter对象的观察者
if (mAdapter != null) {
mAdapter.unregisterAdapterDataObserver(mObserver);
mAdapter.onDetachedFromRecyclerView(this);
}
if (!compatibleWithPrevious || removeAndRecycleViews) {
removeAndRecycleViews();
}
mAdapterHelper.reset();
final Adapter oldAdapter = mAdapter;
mAdapter = adapter;
if (adapter != null) {
//将观察者注册到Adapter中，实质是注册到AdapterDataObservable中
adapter.registerAdapterDataObserver(mObserver);
adapter.onAttachedToRecyclerView(this);
}
if (mLayout != null) {
mLayout.onAdapterChanged(oldAdapter, mAdapter);
}
//数据更新操作
mRecycler.onAdapterChanged(oldAdapter, mAdapter, compatibleWithPrevious);
mState.mStructureChanged = true;
//将之前的所有已知的itemveiw设置invalid（ViewHolder标志位FLAG_UPDATE | FLAG_INVALID）
markKnownViewsInvalid();
}通过以上的代码我们知道，在设置setAdapter的时候会构建一个RecyclerViewDataObserver，也就是我们的观察者(RecyclerViewDataObserver),然后将它注册到被观察者(RecyclerViewDataObserver)中。我们找到了被观察者是怎么和观察者关联的，但是具体RecyclerViewDataObserver是什么东西呢？内部是怎么闪现的呢？我们继续研究研究，上面代码中我提到RecyclerViewDataObserver继承与AdapterDataObserver，那我们先来看看他的父类
public static abstract class AdapterDataObserver {
public void onChanged() {
// Do nothing
}
public void onItemRangeChanged(int positionStart, int itemCount) {
// do nothing
}
public void onItemRangeChanged(int positionStart, int itemCount, Object payload) {
// fallback to onItemRangeChanged(positionStart, itemCount) if app
// does not override this method.
onItemRangeChanged(positionStart, itemCount);
}
public void onItemRangeInserted(int positionStart, int itemCount) {
// do nothing
}
public void onItemRangeRemoved(int positionStart, int itemCount) {
// do nothing
}
public void onItemRangeMoved(int fromPosition, int toPosition, int itemCount) {
// do nothing
}
}基本父类都是空方法，没有具体的实现。我们在来看看RecyclerViewDataObserver是如何重写父类的onChanged()方法的
private class RecyclerViewDataObserver extends AdapterDataObserver {
RecyclerViewDataObserver() {
}
@Override
public void onChanged() {
assertNotInLayoutOrScroll(null);
mState.mStructureChanged = true;
//
setDataSetChangedAfterLayout();
if (!mAdapterHelper.hasPendingUpdates()) {
//重新布局
requestLayout();
}
}
......//省略
}好了。目前我们就到此为止吧(其实后面的我还没去仔细研究),总结一下，当RecyclerView的数据发生变化时，调用Adapter的notifyDataSetChanged()方法，这个方法又会调用AdapterDataObservable的notifyChanged()方法。这个方法又会调用所有观察者的onChanged()方法，在onChanged方法里dui RecyclerView进行重新布局是的RecyclerView刷新界面。一个完整的观察者模式就出来了。
总结
最后我们更加容易懂的一句话来总结:我们在创建Adapter的时候构建了一个RecyclerViewDataObserver，并且在setAdapter()的时候注册进了Adapter(本质是注册到AdapterDataObservable)。在我们调用notifyDataSetChanged()方法的时候，其实就是调用了AdapterDataObservable的notifyChanged()方法，该方法会遍历所有观察者的onChanged()方法,该方法会调用RecyclerView重新布局。(好像这句话比较长哈)
