RxJava 源码阅读笔记(一) 观察者模式

1.什么是Rxjava

 作者给他的概括是"a library for composing asynchronous and event-based programs using observable sequences for the Java VM"（一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库），通俗来讲就是一个采用观察者模式设计的响应式编程框架，灵魂在于他所拓展的观察者模式和异步操作。

2.什么是观察者模式

一般而言，实现对一组数据的实时监控，常用的有两种方式，一种采用setListener这样的回调机制，另一种则是写一个轮询2秒钟去查看一下这组数据是否变化。但，其实还有另一种方式即观察者模式，观察者模式强调当被观察者数据改变时，被观察者会告知观察者，然后进行你想要的操作。实现如下：

1.新建被观察者接口：

public interface Observerable {
    public void registerObserver(Observer o);
    public void removeObserver(Observer o);
    public void notifyObservers();
}

2.新建观察者接口：

public interface Observer {
    public void update(int edition,float cost);
}

3.实现被观察者接口：

public class MagazineData implements Observerable {

    private List mObservers;
    private int edition;
    private float cost;

    public MagazineData() {
        mObservers = new ArrayList<>();
    }

    @Override
    public void registerObserver(Observer o) {
        mObservers.add(o);
    }

    @Override
    public void removeObserver(Observer o) {
        int i = mObservers.indexOf(o);
        if(i >= 0)
            mObservers.remove(i);
    }

    @Override
    public void notifyObservers() {
        for(int i = 0; i < mObservers.size(); i++){
            Observer observer = mObservers.get(i);
            observer.update(edition, cost);
        }
    }

    public void setInfomation(int edition,float cost){
        this.edition = edition;
        this.cost = cost;
        //信息更新完毕，通知所有观察者
        notifyObservers();
    }

}

4.实现观察者接口：

public class Customer implements Observer {

    private String name;
    private int edition;
    private float cost;

    public Customer(String name){
        this.name = name;
    }

    @Override
    public void update(int edition, float cost) {
        this.edition = edition;
        this.cost = cost;
        buy();
    }

    public void buy(){
        System.out.println(name+"购买了第"+edition+"期的杂志，花费了"+cost+"元。");
    }

}

5.代码实现：

public class Test { public static void main(String[] args) {
        //创建被观察者
        MagazineData magazine = new MagazineData();
        //创建观察者
        Observer customerA = new Customer("A");

        //将观察者注册到被观察者中
        magazine.registerObserver(customerA);

        //更新被观察者中的数据，当数据更新后，会自动通知所有已注册的观察者
        magazine.setInfomation(5, 12);
    }

}

3.观察者Observer类介绍

1.Observer的创建：

Observer有两种创建方式一种是：

Observer observer = new Observer() {

         @Override

          public void onCompleted() {

          //onCompleted在没有onNext方法后调用 调用后事件队列的完成

          }

          @Override

           public void onError(Throwable e) {

          //onError在处理事件中发生意外时调用 调用后事件队列的完成

           }

           @Override

            public void onNext(String s) {

            //onNext用来发送事件

            }

};

第二种是：

Subscriber subscriber =new Subscriber() {

                @Override

                 public void onStart() {

                //在队列运行前进行数据的初始化，不包括UI部分

                 }

                 @Override

                  public void onCompleted() {

                  }

                  @Override

                  public void onError(Throwable e) {

                  }

                  @Override

                  public void onNext(String s) {

                  }

};

5.被观察者Observable类介绍*

1.创建被观察者

Observable Observable= Observable.create(newObservable.OnSubscribe() {

@Override

public void call(Subscriber subscriber) {

            subscriber.onNext("Hello");

            subscriber.onNext("World");

            subscriber.onCompleted();

            }

}); 

2.订阅观察者

Observable.subscribe(observer);

调用订阅后观察者就会根据被观察者call里的情况调用相应的方法

这里看一下subscribe的源码

public final Subscription subscribe(final Observer observer) {

           if(observer instanceof Subscriber) {

                      return subscribe((Subscriber)observer);

           }

           return subscribe(new Observer Subscriber(observer));

}

简单来说就是如果传过来的是个Observer类就会把它转化成Subscriber类，然后subscribe是什么呢？

static Subscription subscribe(Subscriber subscriber, Observable observable) {

              if (subscriber == null) {

                  throw new IllegalArgumentException("subscriber can not be null");

              }

               if (observable.onSubscribe == null) {

                   throw new IllegalStateException("onSubscribe function can not be null.");

               }

                //先调用onStart进行数据初始化

                subscriber.onStart();

                if (!(subscriber instanceof SafeSubscriber)) {

                //目测是确保onError与onCompletedliang两个方法调用后禁止调用其他方法

                     subscriber = new SafeSubscriber(subscriber);

                 }

                 try {

                        hook.onSubscribeStart(observable,               observable.onSubscribe).call(subscriber);

                       return hook.onSubscribeReturn(subscriber);

                  } catch (Throwable e) {

                          //catch内容先别管

                  }

                   return Subscriptions.unsubscribed();

   }

然后是try里的这两句

hook.onSubscribeStart(observable,observable.onSubscribe).call(subscriber);

return hook.onSubscribeReturn(subscriber);

发现hook.onSubscribeStart(observable,observable.onSubscribe)返回一个onSubscribe，

hook.onSubscribeReturn(subscriber)返回一个subscription所以可以简化为

onSubscribe.call(subscriber);

return subscription;

而这个call就是你new Observable时重写的方法。总结一下就是这部分的代码相当于最基础的观察者模式中的

magazine.registerObserver(customerA);

注册订阅部分，而新建观察者和被观察者的代码相当于之前实现接口的代码

---