SuperObservable

其实android源码里已经有观察者模式的封装了：

package android.database;
import java.util.ArrayList;
public abstract class Observable<T> {
   
   protected final ArrayList<T> mObservers = new ArrayList<T>();
   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);
       }
   }

   public void unregisterObserver(T observer) {
       if (observer == null) {
           throw new IllegalArgumentException("The observer is null.");
       }
       synchronized(mObservers) {
           int index = mObservers.indexOf(observer);
           if (index == -1) {
               throw new IllegalStateException("Observer " + observer + " was not registered.");
           }
           mObservers.remove(index);
       }
   }

   public void unregisterAll() {
       synchronized(mObservers) {
           mObservers.clear();
       }
   }
}

可以看到这是一个抽象类，主要提供了三个方法，用来注册和注销观察者。使用起来就是继承Observable，然后添加一些notify的方法来通知观察者。DataSetObservable就是这么做的：

package android.database;

public class DataSetObservable extends Observable<DataSetObserver> {

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

    public void notifyInvalidated() {
        synchronized (mObservers) {
            for (int i = mObservers.size() - 1; i >= 0; i--) {
                mObservers.get(i).onInvalidated();
            }
        }
    }
}

但是我也学着DataSetObservable这么用了一段时间，发现太麻烦了，

1488458379147.jpg

每次都要写一个类继承Observable,而且要要调用里面的方法都要写一段像

synchronized (mObservers) {
            for (int i = mObservers.size() - 1; i >= 0; i--) {
                mObservers.get(i).onInvalidated();
            }
        }

这样的代码，还有一个局限性就是传参，都要在notify里写一遍，所以势必要封装一下。

• 不用每次写一个类继承Observable

• 不用在调用Observer里的方法时都写一个notify方法

  顺着这个思路就是要 抽象类似mObservers.get(i).onChanged();的方法。
  于是便写了一个接口,拿到了observer想干什么就干什么。

public interface Dispatcher<T> {
    void call(T t);
}

SuperObservale类诞生了：

public class SuperObservable<T> extends Observable<T> {

    public void notifyMethod(Dispatcher<T> dispatcher){

        synchronized (mObservers){
            for (int i = mObservers.size()-1; i >= 0; i--) {
                T t = mObservers.get(i);
                    if(dispatcher!=null){
                        dispatcher.call(t);
                    }
                }
            }
        }
    }
}

这样只要在disatcher里写好要调用的方法，就可以notify T(观察者)中的任何方法了。每次只要new SuperObservable<T>便创建了一个被观察者，简单了不少。
考虑到有一个项目中会用到多次观察者模式，便写了一个SuperObservable的管理类：

public class SuperObservableManager {

    private static SuperObservableManager instance;

    private HashMap<Class,SuperObservable> mObservables;

    private SuperObservableManager() {
        mObservables = new HashMap<>();
    }

    public static SuperObservableManager getInstance(){
        if(instance==null){
            synchronized (SuperObservableManager.class){
                if(instance==null){
                    instance = new SuperObservableManager();
                }
            }
        }
        return instance;
    }

    /**
     * 添加被观察者
     * @param observableName
     * @param superObservable
     * @param <Observer>
     *  利用泛型约束被观察者superObservable:
     *  让其只受Observer类型的观察者观察
     */
    public <Observer> void addObservable(Class<Observer>observableName,SuperObservable<Observer>superObservable){
        if(mObservables.containsKey(observableName)){
            throw new IllegalStateException("已添加过"+observableName.getSimpleName()+"类型的被观察者！");
        }
        mObservables.put(observableName,superObservable);
    }
    /**
     * 获取被观察者
     * @param observableName
     * @return
     */
    public <Observer> SuperObservable<Observer> getObservable(Class<Observer> observableName){
        SuperObservable<Observer> superObservable = mObservables.get(observableName);

        if(superObservable==null){
            throw new IllegalStateException("未添加"+observableName.getSimpleName()+"类型的被观察者！");
        }
        return superObservable;
    }
    /**
     * 移除被观察者
     * @param observableName
     * @return
     */
    public SuperObservable removeObservable(Class observableName){
        return mObservables.remove(observableName);
    }
}

顺便说一下我对观察者模式的理解。观察者模式本质就是接口回调，不过平时我们常用的是回调给一个对象，而观察者一次性回调给多个对象。 可以解决 Activity与Fragment各种回调，例如app登录之后要把登录状态回调给诸多Activity与Fragment。

1488457866952.jpg

github 地址