1、概述

  • 观察者模式定义了对象之间的一对多依赖关系，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并且自动更新。
  • 在这里，发生改变的对象称之为观察目标，而被通知的对象称之为观察者。一个观察目标可以对应多个观察者，而且这些观察者之间没有相互联系，所以么可以根据需要增加和删除观察者，使得系统更易于扩展。所以观察者提供了一种对象设计，让主题和观察者之间以松耦合的方式结合。

1、观察者模式 - 图1

  • 观察者模式包含如下角色：

    • Subject: 目标
    • ConcreteSubject: 具体目标
    • Observer: 观察者
    • ConcreteObserver: 具体观察者

      2、代码例子

  • 实现一个植物（目标）开花后会通知昆虫（观察者）来采蜜，关闭后昆虫回家的例子

  • Observer ```html package com.company;

public interface Insect { void work(); void home(); }

  2. - ConcreteObserver
  3. ```html
  4. package com.company;
  6. public class Bee implements Insect {
  8.     private int id;
  10.     public Bee(int id) {
  11.         this.id = id;
  12.     }
  14.     @Override
  15.     public void work() {
  16.         System.out.println("蜜蜂" + id + "工作");
  17.     }
  19.     @Override
  20.     public void home() {
  21.         System.out.println("蜜蜂" + id + "回家");
  22.     }
  23. }
  • Subject ```java package com.company;

public interface Plant { void registerInsect(Insect insect); void unregisterInsect(Insect insect); void notifyInsect(boolean isOpen); }

  2. - ConcreteSubject
  3. ```java
  4. package com.company;
  6. import java.util.ArrayList;
  7. import java.util.List;
  9. public class Flower implements Plant {
  11.     private List<Insect> insects = new ArrayList<>();
  13.     @Override
  14.     public void registerInsect(Insect insect) {
  15.         insects.add(insect);
  16.     }
  18.     @Override
  19.     public void unregisterInsect(Insect insect) {
  20.         insects.remove(insect);
  21.     }
  23.     @Override
  24.     public void notifyInsect(boolean isOpen) {
  25.         for (int i = 0; i < insects.size(); i++) {
  26.             if (isOpen){
  27.                 insects.get(i).work();
  28.             } else {
  29.                 insects.get(i).home();
  30.             }
  31.         }
  32.     }
  33. }
  • 测试 ```java package com.company;

public class Main {

  1. public static void main(String[] args) {
  3.     // 一个Subject
  4.     Plant flower = new Flower();
  6.     // 多个Observe
  7.     Insect insect1 = new Bee(1);
  8.     Insect insect2 = new Bee(2);
  9.     Insect insect3 = new Bee(3);
  11.     flower.registerInsect(insect1);
  12.     flower.registerInsect(insect2);
  13.     flower.registerInsect(insect3);
  15.     flower.notifyInsect(true);
  16.     flower.notifyInsect(false);
  18.     flower.unregisterInsect(insect1);
  19.     flower.unregisterInsect(insect2);
  20.     flower.unregisterInsect(insect3);
  21. }

}

  2. - 主要思路：Subject提供注册（添加Observer）、注销（移除Observer）、通知（当Subject发生某种变化后，调用notify方法，通知所有的Observer对象）
  3. - RxJava的是拓展的观察者模式，A对象的行为影响B对象，B对象影响C对象，可以使用观察者模式创建一种链式触发机制。
  4. <a name="QhAUR"></a>
  5. ## 3、Android自带的观察者
  6. <a name="qRQNa"></a>
  7. ### 3-1、观察者Observer源码
  9. - 位于java.util目录下
  10. ```json
  11. public interface Observer {
  12.     void update(Observable o, Object arg);
  13. }

3-2、被观察者Observable源码

  • 位于java.util目录下 ```json public class Observable {

    /**

    • 被观察者的数据是否改变 */
      private boolean changed = false;

      /**

    • 保存观察者的集合 */
      private Vector obs;

      public Observable() { obs = new Vector<>(); }

      /**

    • 添加观察者 */
      public synchronized void addObserver(Observer o) { if (o == null)

      1.  throw new NullPointerException();

      if (!obs.contains(o)) {

      1.  obs.addElement(o);

      } }

      /**

    • 删除观察者 */
      public synchronized void deleteObserver(Observer o) { obs.removeElement(o); }
  1. public void notifyObservers() {
  2.     notifyObservers(null);
  3. }
  5. /**
  6.  * 通知观察者，hasChanged为true才真真通知观察者
  7.  */  
  8. public void notifyObservers(Object arg) {
  10.     Object[] arrLocal;
  12.     synchronized (this) {
  13.         if (!hasChanged())
  14.             return;
  15.         arrLocal = obs.toArray();
  16.         clearChanged();
  17.     }
  19.     for (int i = arrLocal.length-1; i>=0; i--)
  20.         ((Observer)arrLocal[i]).update(this, arg);
  21. }
  23. public synchronized void deleteObservers() {
  24.     obs.removeAllElements();
  25. }
  27. protected synchronized void setChanged() {
  28.     changed = true;
  29. }
  31. protected synchronized void clearChanged() {
  32.     changed = false;
  33. }
  36. public synchronized boolean hasChanged() {
  37.     return changed;
  38. }
  40. /**
  41.  * 观察者数量
  42.  */
  43. public synchronized int countObservers() {
  44.     return obs.size();
  45. }

}

  1. <a name="ZvwrQ"></a>
  2. ## 4、观察者模式的推\拉模型
  4. - 推拉模型本质区别只是在于update传入的参数是一个属性还是对象本身
  5. - 推模型是假定被观察者知道观察者需要的数据
  6. - 拉模型是被观察者 不知道观察者具体需要什么数据，没有办法的情况下，干脆把自身传递给观察者，让观察者自己去按需要取值
  7. - 优缺点
  8.    - 推模型可能会使得观察者对象难以复用，因为观察者的update()方法是按需要定义的参数，可能无法兼顾没有考虑到的使用情况。这就意味着出现新情况的时候，就可能提供新的update()方法，或者是干脆重新实现观察者；
  9.    - 而拉模型就不会造成这样的情况，因为拉模型下，update()方法的参数是主题对象本身，这基本上是主题对象能传递的最大数据集合了，基本上可以适应各种情况的需要
  10. <a name="eHKDJ"></a>
  11. ### 4-1、推模型
  13. - Observer：观察者
  14. ```java
  15. package com.xinhe.testandroid.observe;
  17. import java.util.Observable;
  18. import java.util.Observer;
  20. public class Bee implements Observer {
  22.     private static final String TAG = "Bee";
  24.     private int id;
  26.     public Bee(int id) {
  27.         this.id = id;
  28.     }
  30.     @Override
  31.     public void update(Observable o, Object arg) {
  32.         if ((Boolean)arg){
  33.             System.out.println("update: true"+id);
  34.         } else {
  35.             System.out.println("update: false"+id);
  36.         }
  37.     }
  38. }

  • Observable：被观察者

    1. public class Flower extends Observable {
    3.   public void notifyInsect(boolean isOpen){
    5.       // 通知改变
    6.       this.setChanged();
    7.       // 通知所有观察者
    8.       this.notifyObservers(isOpen);
    9.   }
    10. }

  • 验证

    1.       // 一个Subject
    2.       Flower flower = new Flower();
    4.       // 多个Observe
    5.       Bee insect1 = new Bee(1);
    6.       Bee insect2 = new Bee(2);
    7.       Bee insect3 = new Bee(3);
    9.       flower.addObserver(insect1);
    10.       flower.addObserver(insect2);
    11.       flower.addObserver(insect3);
    13.       flower.notifyInsect(true);
    14.       flower.notifyInsect(false);
    16.       flower.deleteObserver(insect1);
    17.       flower.deleteObserver(insect2);
    18.       flower.deleteObserver(insect3);

    4-2、拉模型

  • 再写个拉模型例子 ```java package com.xinhe.testandroid.observe;

import java.util.Observable;

public class Flower extends Observable {

  1. private boolean isOpen;
  3. public boolean getOpen(){
  4.     return isOpen;
  5. }
  7. public void notifyInsect(boolean isOpen){
  9.     this.isOpen = isOpen;
  11.     // 通知改变
  12.     this.setChanged();
  13.     // 通知所有观察者
  14.     this.notifyObservers(this);
  15. }

}

  2. - Bee
  3. ```java
  4. package com.xinhe.testandroid.observe;
  6. import java.util.Observable;
  7. import java.util.Observer;
  9. public class Bee implements Observer {
  11.     private static final String TAG = "Bee";
  13.     private int id;
  15.     public Bee(int id) {
  16.         this.id = id;
  17.     }
  19.     @Override
  20.     public void update(Observable o, Object arg) {
  22.         Flower flower = (Flower) arg;
  24.         if (flower.getOpen()){
  25.             System.out.println("update: true"+id);
  26.         } else {
  27.             System.out.println("update: false"+id);
  28.         }
  29.     }
  30. }