Java 观察者模式_在观察者模式中,抽象主题提供一个什么方法和什么方法

观察者模式定义：定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。

类图

• Subject：主题接口，对象使用此接口注册为观察者，或者把自己从观察者中删除。
• ConcreteSubjectA，ConcreteSubjectB：具体的主题。一个具体的主题总是实现主题接口，具体接口还实现了notifyObservers( )方法，此方法用于在状态改变时更新所有当前观察者。
• Observer：观察者接口，所有潜在的观察者都必须实现这个接口，当主题状态改变的时候，notify( )方法会被调用。
• ConcreteObserverA，ConcreteObserverB：具体的观察者。观察者必须注册具体的主题，以便接受更新。

观察者模式简单实现

观察者模式这种发布-订阅的形式我们可以拿微信公众号来举例，假设微信用户就是观察者，微信公众号是被观察者，有多个的微信用户关注了程序猿这个公众号，当这个公众号更新时就会通知这些订阅的微信用户。好了我们来看看用代码如何实现：

抽象观察者（Observer）里面定义了一个更新的方法：

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

具体观察者（ConcrereObserver）微信用户是观察者，里面实现了更新的方法：

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);
    }

}
1
2
3
4
5
6
7
8
9
10
11
12

抽象被观察者（Subject）抽象主题，提供了addObserver、deleteObserver、notifyObservers三个方法：

public interface Subject {

    //添加观察者
    void addObserver(Observer observer);
    //删除观察者
    void deleteObserver(Observer observer);
    //通知所有的观察者有更新
    void notifyObservers(String message);

}

1
2
3
4
5
6
7
8
9
10
11

具体被观察者（ConcreteSubject）微信公众号是具体主题（具体被观察者），里面存储了订阅该公众号的微信用户，并实现了抽象主题中的方法：

public class WeixinSubject implements Subject {

    private List<Observer> observerList = new ArrayList<>();

    @Override
    public void addObserver(Observer observer) {
        observerList.add(observer);
    }

    @Override
    public void deleteObserver(Observer observer) {
        observerList.remove(observer);
    }

    @Override
    public void notifyObservers(String message) {
        for (Observer observer : observerList) {
            observer.update(message);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

客户端调用

public class Client {
    public static void main(String[] args) {
        WeixinSubject mSubscriptionSubject=new WeixinSubject ();
        //创建微信用户
        WeixinUser user1=new WeixinUser("杨影枫");
        WeixinUser user2=new WeixinUser("月眉儿");
        WeixinUser user3=new WeixinUser("紫轩");
        //订阅公众号
        mSubscriptionSubject.addObserver(user1);
        mSubscriptionSubject.addObserver(user2);
        mSubscriptionSubject.addObserver(user3);
        //公众号更新发出消息给订阅的微信用户
        mSubscriptionSubject.notifyObservers("刘望舒的专栏更新了");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

输出结果

杨影枫-刘望舒的专栏更新了
月眉儿-刘望舒的专栏更新了
紫轩-刘望舒的专栏更新了
1
2
3

使用观察者模式的场景和优缺点

使用场景

• 关联行为场景，需要注意的是，关联行为是可拆分的，而不是“组合”关系。

• 事件多级触发场景。

• 跨系统的消息交换场景，如消息队列、事件总线的处理机制。

优点

解除耦合，让耦合的双方都依赖于抽象，从而使得各自的变换都不会影响另一边的变换。

缺点

在应用观察者模式时需要考虑一下开发效率和运行效率的问题，程序中包括一个被观察者、多个观察者，开发、调试等内容会比较复杂，而且在Java中消息的通知一般是顺序执行，那么一个观察者卡顿，会影响整体的执行效率，在这种情况下，一般会采用异步实现。

Android中的观察者模式

以RecyclerView和RecyclerView.Adapter.notifyDataSetChanged( )为例。

在使用RecyclerView的时候，我们在每次更新了RecyclerView的数据后通常调用notifyDataSetChanged()方法来更新我们的视图，那么我们就从这里开始，一步步跟进到源码看看RecyclerView的观察者模式是怎么实现的

 //RecyclerView的内部类
 public static abstract class Adapter<VH extends ViewHolder> {
 
   //注释0处，mObservable是被观察者，AdapterDataObservable继承了java内置的Observable类
   private final AdapterDataObservable mObservable = new AdapterDataObservable();
   
   //是否有观察者
   public final boolean hasObservers() {
        return mObservable.hasObservers();
   }
   
   //注册观察者
    public void registerAdapterDataObserver(AdapterDataObserver observer) {
        mObservable.registerObserver(observer);
    }
    
    //删除观察者
    public void unregisterAdapterDataObserver(AdapterDataObserver observer) {
        mObservable.unregisterObserver(observer);
    }
    
    //notifyDataSetChanged()方法
    public final void notifyDataSetChanged() {
		 //注释1处，调用每一个观察者的onChanged( )方法
         mObservable.notifyChanged();
    }    
  ....
  //其他方法省略   
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

注释0处，mObservable是被观察者，AdapterDataObservable继承了java内置的Observable类。

在注释1处，Adapter的notifyDataSetChanged()方法中，会调用mObservable的notifyChanged方法，内部会调用每一个观察者的onChanged( )方法。

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

当我们给RecyclerView设置适配器的时候

 public void setAdapter(Adapter adapter) {
      setLayoutFrozen(false);
      //内部会调用这个方法
      setAdapterInternal(adapter, false, true);
      requestLayout();
}
1
2
3
4
5
6

private void setAdapterInternal(Adapter adapter, boolean compatibleWithPrevious,
            boolean removeAndRecycleViews) {
	// ...
    if (adapter != null) {
	    //adapter会注册一个观察者mObserver
        adapter.registerAdapterDataObserver(mObserver);
        adapter.onAttachedToRecyclerView(this);
    }
   //...
}
1
2
3
4
5
6
7
8
9
10

这个mObserver是一个RecyclerView的一个变量。

private final RecyclerViewDataObserver mObserver = new RecyclerViewDataObserver();
1

Adapter的registerAdapterDataObserver方法。

public void registerAdapterDataObserver(@NonNull AdapterDataObserver observer) {
    //内部调用Observable的registerObserver方法，把观察者加入到观察者集合中
    mObservable.registerObserver(observer);
}
1
2
3
4

Observable的registerObserver方法。

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11

private class RecyclerViewDataObserver extends AdapterDataObserver {
	 //...
    @Override
    public void onChanged() {
        assertNotInLayoutOrScroll(null);
        mState.mStructureChanged = true;
        setDataSetChangedAfterLayout();
        if (!mAdapterHelper.hasPendingUpdates()) {
	        //重新布局,视图就会更新。
            requestLayout();
        }
    }
    //...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

梳理一下流程：当给RecyclerView设置适配器的Adapter时候,RecyclerView会向Adapter注册一个观察者RecyclerViewDataObserver mObserver。当我们的数据发生变化调用Adapter的notifyDataSetChanged( )方法的时候，会调用每一个观察者的onChanged( )方法。在onChanged( )方法中会调用requestLayout()方法会导致RecyclerView重新布局从而达到更新视图的作用。

参考链接：

• 观察者模式
• 设计模式（五）观察者模式
• 从RecyclerView的源码了解观察者模式
• 《Head First 设计模式》