Android 观察者模式

观察者模式，定义了对象间一种一对多的依赖关系，当被观察者状态发生变化时，它的观察者们会收到通知并自动更新。

应用
在java语言的java.util库里面，提供了一个Observable类以及一个Observer接口，构成Java语言对观察者模式的支持。

Android 观察者最常见有addTextChangedListener等。

Observable/Observer示例
Oservable被观察者
被观察者，一个被观察者对象可以有数个观察者对象

public class ConcreteObservable extends Observable {
  private int data = 0;

public int getData() {
    return data;
}

public void setData(int i) {
    //具体逻辑按需
    if (data != i) {
        this.data = i;
        setChanged();
    }
}

private static ConcreteObservable observable;

public static synchronized ConcreteObservable getInstance() {
    if (observable == null) {
        observable = new ConcreteObservable();
    }
    return observable;
}

public ConcreteObservable post() {
    //只有在setChange()被调用后，notifyObservers()才会去调用update()，否则什么都不干。
    notifyObservers();
    return observable;
}

public ConcreteObservable post(Object arg) {
    setChanged();
    //只有在setChange()被调用后，notifyObservers()才会去调用update()，否则什么都不干。
    notifyObservers(arg);
    return observable;
}}

Observable 源码：

public class Observable {

  private boolean changed = false;
  private final ArrayList<Observer> observers;

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

public Observable() {
    observers = new ArrayList<>();
}

/**     
 * 将一个观察者添加到观察者集合     
 */
public synchronized void addObserver(Observer o) {
    if (o == null)
        throw new NullPointerException();
    if (!observers.contains(o)) {
        observers.add(o);
    }
}

/**     
 * 删除观察者     
 */
public synchronized void deleteObserver(Observer o) {
    observers.remove(o);
}

/**     
 * 如果该对象发生了变化，由所指示的 hasChanged方法，则通知其所有观察者，并调用clearChanged方法来指示该对象不再改变     
 */
public void notifyObservers() {
    notifyObservers(null);
}

/**     
 * 如果该对象发生了变化，由所指示的 hasChanged方法，则通知其所有观察者，并调用clearChanged方法来指示该对象不再改变     
 */
public void notifyObservers(Object arg) {

    Observer[] arrLocal;

    synchronized (this) {

        if (!hasChanged())
            return;

        arrLocal = observers.toArray(new Observer[observers.size()]);
        clearChanged();
    }

    for (int i = arrLocal.length-1; i>=0; i--)
        arrLocal[i].update(this, arg);
}

/**     
 * 清除观察者列表，不再有任何观察者     
 */
public synchronized void deleteObservers() {
    observers.clear();
}

/**     
 * 观测对象为已改变     
 */
protected synchronized void setChanged() {
    changed = true;
}

/**     
 * 指示对象不再改变，或者说，它已通知其所有最近改变其观察员     
 */
protected synchronized void clearChanged() {
    changed = false;
}

/**     
 * 测试此对象已经改变     
 */
public synchronized boolean hasChanged() {
    return changed;
}

/**     
 * 返回观察者人数     
 */
public synchronized int countObservers() {
    return observers.size();
}}

Observer 观察者

Observer 是个接口，在需要观察的地方实现：

  public class ObserverActivity extends AppCompatActivity implements Observer {
   ConcreteObservable observable;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_observer);
    observable = ConcreteObservable.getInstance();
    observable.addObserver(this);
    observable.setData(1);
    observable.post();
    observable.setData(1);
    observable.post();
    observable.post(2);
}

@Override
public void update(Observable o, Object arg) {
    ConcreteObservable concreteObservable = (ConcreteObservable) o;
    Log.d("wxl", "ObserverActivity=" + concreteObservable.getData() + ",arg=" + arg);
}

@Override
protected void onDestroy() {
    super.onDestroy();
    //删除观察者
    observable.deleteObserver(this);
}}

Observer源码：

public interface Observer {
/**
* 当被观察者对象的状态发生变化时，被观察者对象的notifyObservers()方法就会* 调用这一方法。
*/
void update(Observable o, Object arg);}

最后打印：

ObserverActivity=1,arg=null
ObserverActivity=1,arg=2