Rxjava源码分析

1.Rxjava基本使用

1.Rxjava基本概念

• 进行耗时任务
• Rxjava本质是一个异步操作库

2.传统的观察者模式，举例RNG VS SKT

• 首先定义粉丝，就是观察者

//首先每个粉丝都会时时收到最新消息，所以提取公共接口
public interface Observer {
    public void update(int edition, float cost);
}
public class ConcreateObserver implements Observer {

    private String name;//名字
    private int edition;//第几场
    private float cost;//话费

    public ConcreateObserver(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+"购买了RNG VS SKT第"+edition+"场的比赛的门票，花费了"+cost+"元。");
    }

}

• 被观察者模式，即RNG VS SKT

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

    private List<Observer> mObservers;//RNG VS SKT场地里面的所有粉丝
    private int edition;//打到第几场
    private float cost;//门票多少

    public ConcreteObserverable() {
        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();
    }

}

• 真正粉丝和比赛

  //创建被观察者 RNG VS SKT的比赛
        ConcreteObserverable concreteObserverable = new ConcreteObserverable();

        //创建三个不同的观察者  RNG粉丝三名
        Observer observerA = new ConcreateObserver("A");
        Observer observerB = new ConcreateObserver("B");
        Observer observerC = new ConcreateObserver("C");

        //将观察者注册到被观察者中 ，粉丝进场
        concreteObserverable.registerObserver(observerA);
        concreteObserverable.registerObserver(observerB);
        concreteObserverable.registerObserver(observerC);

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

3.rxjava被观察者模式和基本用法

• rxjava四大要素

  被观察者，观察者，订阅，事件

• 事件

  响应式编程:如:我饿了
  对应：如：去吃饭

GitHub官网：https://github.com/ReactiveX/RxJava
**添加依赖：

compile 'io.reactivex.rxjava2:rxjava:2.0.1'
compile 'io.reactivex:rxandroid:1.1.0'**

Rxjava源码分析

1.Observable(被观察者)
2.onSubscribe(可以理解为被观察者通知观察者)
3.Subscriber(观察者)
4.subscribe()

测试订阅

public class RxjavaCreateDemo {

    //第一步：创建被观察者：create
    Observable observable = Observable.create(new Observable.OnSubscribe<String>() {
        @Override
        public void call(Subscriber<? super String> subscriber) {
            subscriber.onNext("Hello");
            subscriber.onNext("Peakmain");
            subscriber.onCompleted();
        }
    });

    //通过just方法来创建被观察者
    Observable observableJust = Observable.just("hello", "Peakmain");

    //通过from方法来创建被观察者
    String[] parameters = {"hello", "Peakmain"};
    Observable observableFrom = Observable.from(parameters);

    //第二步：创建观察者
    Observer<Object> observer = new Observer<Object>() {

        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onNext(Object s) {

        }
    };
Subscriber subscribe=new Subscriber(){

    @Override
    public void onCompleted() {

    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onNext(Object object) {

    }
};
    public void doRxjava(){
        //第三步：订阅
        observable.subscribe(observer);
        observable.subscribe(subscribe);
    }

}

Observable.create源码分析

   //hook代理类，返回一个被观察者模式
  public final static <T> Observable<T> create(OnSubscribe<T> f) {
        return new Observable<T>(hook.onCreate(f));
    }

observable.subscribe(observer)源码分析

    //由此可见observable.subscribe(observer)只是observable.subscribe(subscribe)的一个封装
          public final Subscription subscribe(final Observer<? super T> observer) {
        if (observer instanceof Subscriber) {
            return subscribe((Subscriber<? super T>)observer);
        }
        return subscribe(new Subscriber<T>() {

            @Override
            public void onCompleted() {
                observer.onCompleted();
            }

            @Override
            public void onError(Throwable e) {
                observer.onError(e);
            }

            @Override
            public void onNext(T t) {
                observer.onNext(t);
            }

        });
    }

Subscriber源码解析

public abstract class Subscriber<T> implements Observer<T>, Subscription {
        private final SubscriptionList subscriptions;//订阅事件的集合
}

public interface Subscription {
   //解绑
    void unsubscribe();
    //是否已经解绑
    boolean isUnsubscribed();

}

subscribe源码解析

 public final Subscription subscribe(Subscriber<? super T> subscriber) {
        return Observable.subscribe(subscriber, this);
    }

    static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> 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.");
      }

       //空方法
        subscriber.onStart();
         //SafeSubscriber实际是对subscriber的一个封装
        if (!(subscriber instanceof SafeSubscriber)) {
            subscriber = new SafeSubscriber<T>(subscriber);
        }
        try {
          //完成订阅
           hook.onSubscribeStart(observable, observable.onSubscribe).call(subscriber);
            return hook.onSubscribeReturn(subscriber);
        } 
     }
 }

操作符

• 变换：就是将事件序列中的对象或整个序列进行加工处理
• map:将一个事件转换成另一个事件

map操作的基本使用

private void map() {
        Observable.just("map/image/map.png")
                //第一个参数原本的类型，第二个参数代表要转换的类型
                .map(new Func1<String, Bitmap>() {
                    @Override
                    public Bitmap call(String filePath) {
                        return getBitmap(filePath);
                    }
                })
                .subscribe(new Action1<Bitmap>() {
                    @Override
                    public void call(Bitmap bitmap) {
                        showBitmap(bitmap);
                    }
                });
    }

    private void showBitmap(Bitmap bitmap) {

    }

    private Bitmap getBitmap(String filePath) {
        return null;
    }

map操作源码解析

Observable.just(“map/image/map.png”)源码解析

    public static <T> Observable<T> just(final T value) {
        return ScalarSynchronousObservable.create(value);
    }

    public static <T> ScalarSynchronousObservable<T> create(T t) {
        return new ScalarSynchronousObservable<T>(t);
    }

    protected ScalarSynchronousObservable(final T t) {
        super(new OnSubscribe<T>() {

            @Override
            public void call(Subscriber<? super T> s) {
                s.onNext(t);
                s.onCompleted();
            }

        });
        this.t = t;
    }
    protected Observable(OnSubscribe<T> f) {
       //onSubscribe 用来通知观察者产生不同的行为
        this.onSubscribe = f;
    }

map操作符源码分析

    public final <R> Observable<R> map(Func1<? super T, ? extends R> func) {
        return lift(new OperatorMap<T, R>(func));
    }

OperatorMap源码解析

  public OperatorMap(Func1<? super T, ? extends R> transformer) {
        this.transformer = transformer;
    }
@Override
    public Subscriber<? super T> call(final Subscriber<? super R> o) {
        return new Subscriber<T>(o) {

            @Override
            public void onCompleted() {
                o.onCompleted();
            }

            @Override
            public void onError(Throwable e) {
                o.onError(e);
            }

            @Override
            public void onNext(T t) {
                try {
                    o.onNext(transformer.call(t));
                } catch (Throwable e) {
                    Exceptions.throwOrReport(e, this, t);
                }
            }

        };
    }

lift源码解析

 public final <R> Observable<R> lift(final Operator<? extends R, ? super T> operator) {
       //new被观察者
        return new Observable<R>(new OnSubscribe<R>() {
            @Override
            public void call(Subscriber<? super R> o) {
                try {

                    Subscriber<? super T> st = hook.onLift(operator).call(o);
                    try {

                        st.onStart();
                          //完成订阅操作
                        onSubscribe.call(st);
                    } catch (Throwable e) {

                        Exceptions.throwIfFatal(e);
                        st.onError(e);
                    }
                } catch (Throwable e) {
                    Exceptions.throwIfFatal(e);

                    o.onError(e);
                }
            }
        });
    }

rxjava操作符之flatmap：所有操作符的最终源码和map源码一样就不阐述了

基本使用

  private Subscription processNetAddress() {
        return Observable.just(
                "http://www.baidu.com/",
                "https://www.sina.com/",
                "https://www.sohu.com/")
                //将string类型转换成Observable类型
                .flatMap(new Func1<String, Observable<String>>() {
                    @Override
                    public Observable<String> call(String s) {
                        return createObservable(s);
                    }
                })
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                    }
                });
    }

    private Observable<String> createObservable(String s) {
        return null;
    }

将传入的事件对象装换成一个Observable对象
这是不会直接发送这个Observable,而是将这个Observable激活让它自己开始发送事件
每一个创建出来的Observable发送的事件，都被汇入同一个Observerable

Rxjava线程控制

• 场景：从网络获取数据

Android多线程编程原则

• 第一、不要阻塞UI线程
• 第二、不要在UI线程之外访问UI组件

rxjava:控制线程
- Rxjava遵循的是线程不变的原则
- Schedulers

rxjava线程Schedulers

• Schedulers.immediate()——不切换任何线程,默认线程
• Schedulers.newInstance——开启新的
• Schedulers.io()-无数量上限
• Schedulers.computation-计算,使用场景不多
• AndroidSchedulers.mainThread()-切换主线程

rxjava如何进行线程控制

• subscribeOn
• observeOn

基本使用

 public void doThread() {
        Observable.create(new Observable.OnSubscribe<Object>() {
            @Override
            public void call(Subscriber<? super Object> subscriber) {
                subscriber.onNext("start");
                SystemClock.sleep(2000);
                subscriber.onNext("sleep 200 start");
                SystemClock.sleep(3000);
                subscriber.onNext("sleep 300 start");
                subscriber.onCompleted();
            }
        })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<Object>() {
                    @Override
                    public void onCompleted() {
                        Log.d("RxjavaThreadControlDemo", "onCompleted()" );
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d("RxjavaThreadControlDemo", "onError()" );
                    }

                    @Override
                    public void onNext(Object object) {
                        Log.d("RxjavaThreadControlDemo", "onNext()" );
                    }
                });

    }

    public void doThreadWithScheduler() {
        Observable.just("小明", "小张", "小周")
                //只能调用一次
                .subscribeOn(Schedulers.io())//小明，小张的内容发出是io发出的
                //可以调用多次
                .observeOn(AndroidSchedulers.mainThread())//下面发生的事件发生在主线程中
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String number) {
                        Log.d("RxjavaThreadControlDemo", "number:" + number);
                    }
                });
    }

subscribeOn源码分析

   public final Observable<T> subscribeOn(Scheduler scheduler) {
        if (this instanceof ScalarSynchronousObservable) {
            return ((ScalarSynchronousObservable<T>)this).scalarScheduleOn(scheduler);
        }
        return nest().lift(new OperatorSubscribeOn<T>(scheduler));
    }

OperatorSubscribeOn源码分析

   public OperatorSubscribeOn(Scheduler scheduler) {
        this.scheduler = scheduler;
    }

//这里要非常注意OperatorSubscribeOn中的call的方法
 public Subscriber<? super Observable<T>> call(final Subscriber<? super T> subscriber) {
       //用于线程控制的
        final Worker inner = scheduler.createWorker();
        subscriber.add(inner);
        return new Subscriber<Observable<T>>(subscriber) {

            @Override
            public void onCompleted() {
            }

            @Override
            public void onError(Throwable e) {
                subscriber.onError(e);
            }

            @Override
            public void onNext(final Observable<T> o) {
                inner.schedule(new Action0() {

                    @Override
                    public void call() {
                        final Thread t = Thread.currentThread();
                        o.unsafeSubscribe(new Subscriber<T>(subscriber) {

                            @Override
                            public void onCompleted() {
                                subscriber.onCompleted();
                            }

                            @Override
                            public void onError(Throwable e) {
                                subscriber.onError(e);
                            }

                            @Override
                            public void onNext(T t) {
                                subscriber.onNext(t);
                            }
                           //对我们线程进行判断
                            @Override
                            public void setProducer(final Producer producer) {
                                subscriber.setProducer(new Producer() {

                                    @Override
                                    public void request(final long n) {
                                        if (Thread.currentThread() == t) {
                                                 producer.request(n);
                                        } else {
                                          //线程控制
                                            inner.schedule(new Action0() {

                                                @Override
                                                public void call() {
                                                    producer.request(n);
                                                }
                                            });
                                        }
                                    }

createWorker源码分析

 public abstract Worker createWorker()

 //看下实现，这里举NewThreadScheduler
  @Override
    public Worker createWorker() {
        return new NewThreadWorker(THREAD_FACTORY);
    }
    public NewThreadWorker(ThreadFactory threadFactory) {
        ScheduledExecutorService exec = Executors.newScheduledThreadPool(1, threadFactory);
        boolean cancelSupported = tryEnableCancelPolicy(exec);
        if (!cancelSupported && exec instanceof ScheduledThreadPoolExecutor) {
            registerExecutor((ScheduledThreadPoolExecutor)exec);
        }
        schedulersHook = RxJavaPlugins.getInstance().getSchedulersHook();
        executor = exec;
    }

inner.schedule源码分析

public abstract Subscription schedule(Action0 action);

//看实现NewThreadWorker
    @Override
    public Subscription schedule(final Action0 action) {
        return schedule(action, 0, null);
    }

    public Subscription schedule(final Action0 action, long delayTime, TimeUnit unit) {
        if (isUnsubscribed) {
            return Subscriptions.unsubscribed();
        }
        return scheduleActual(action, delayTime, unit);
    }

  //scheduleActual(action, delayTime, unit)源码分析
    public ScheduledAction scheduleActual(final Action0 action, long delayTime, TimeUnit unit) {
        Action0 decoratedAction = schedulersHook.onSchedule(action);
        ScheduledAction run = new ScheduledAction(decoratedAction);
        Future<?> f;
        if (delayTime <= 0) {
            f = executor.submit(run);
        } else {
            f = executor.schedule(run, delayTime, unit);
        }
        run.add(f);

        return run;
    }

observeOn源码分析

   public final Observable<T> observeOn(Scheduler scheduler) {
        if (this instanceof ScalarSynchronousObservable) {
            return ((ScalarSynchronousObservable<T>)this).scalarScheduleOn(scheduler);
        }
        return lift(new OperatorObserveOn<T>(scheduler));
    }

    //实现于操作符
    public OperatorObserveOn(Scheduler scheduler) {
        this.scheduler = scheduler;
    }
    //看下其中call方法
     @Override
    public Subscriber<? super T> call(Subscriber<? super T> child) {
        if (scheduler instanceof ImmediateScheduler) {
            // avoid overhead, execute directly
            return child;
        } else if (scheduler instanceof TrampolineScheduler) {
            // avoid overhead, execute directly
            return child;
        } else { 
               //线程调度肯定在这里面 
            ObserveOnSubscriber<T> parent = new ObserveOnSubscriber<T>(scheduler, child);
            parent.init();
            return parent;
        }
    }

    private static final class ObserveOnSubscriber<T> extends Subscriber<T> {
        final Subscriber<? super T> child;
        final Scheduler.Worker recursiveScheduler;
        final ScheduledUnsubscribe scheduledUnsubscribe;
        final NotificationLite<T> on = NotificationLite.instance();

        final Queue<Object> queue;


        volatile boolean finished = false;

        final AtomicLong requested = new AtomicLong();

        final AtomicLong counter = new AtomicLong();

        volatile Throwable error;
         public ObserveOnSubscriber(Scheduler scheduler, Subscriber<? super T> child) {
            this.child = child;
            //看这个源码
            this.recursiveScheduler = scheduler.createWorker();
            if (UnsafeAccess.isUnsafeAvailable()) {
                queue = new SpscArrayQueue<Object>(RxRingBuffer.SIZE);
            } else {
                queue = new SynchronizedQueue<Object>(RxRingBuffer.SIZE);
            }
            this.scheduledUnsubscribe = new ScheduledUnsubscribe(recursiveScheduler);
        }

 public abstract Worker createWorker();
 //看下这个实现
    @Override
    public Worker createWorker() {
        return new NewThreadWorker(THREAD_FACTORY);
    }

    public NewThreadWorker(ThreadFactory threadFactory) {
        ScheduledExecutorService exec = Executors.newScheduledThreadPool(1, threadFactory);
          boolean cancelSupported = tryEnableCancelPolicy(exec);
        if (!cancelSupported && exec instanceof ScheduledThreadPoolExecutor) {
            registerExecutor((ScheduledThreadPoolExecutor)exec);
        }
        schedulersHook = RxJavaPlugins.getInstance().getSchedulersHook();
        executor = exec;
    }

subscribeOn是通过Observable的方式，使用OnSubscribe类的方式去做到线程切换的
obscribeOn是通过操作符的形式去完成线程切换的，所以它的作用域和其他操作符一样，是调用observeon之后的调用