RXAndroid2.0初学习一

于 2017-08-17 15:59:35 发布
阅读量265 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuhaihua529/article/details/77331129
版权

初次学习RXAndroid的demo时候感觉这个东西不太好理解，一遍上班一遍看这东西不是很好的事情，所以我抽出一天时间来查看整个demo中的运行过程，同时了解源码的实现逻辑。发现他功能强大，特别是看了给 Android 开发者的 RxJava 详解 ——扔物线 对RxJava的概念以及基本特性做了详细介绍，我感觉好像就是看了一点皮毛，没怎么理解，就是感觉这个就是这么用，感觉代码写的很高深；后面断断续续的看RXAndroid源码demo，跑题了。


第一眼感觉：这货是链式调用，感觉用起来很方便，理解起来需要踏实的看源码，需要调试，因为中间涉及到了主线程和工作线程，整个过程中需要对一些类进行整理，大概翻译一下方法的意思，帮助自己理解。言归正传。

RXAndroid源码：链接：http://pan.baidu.com/s/1cgyjs6 密码：ee5m

1、订阅者模式，说白了就是监听，就是你有变化通知我，观察这根据事件才取相应的动作。


2、源码查看：

1

@Override protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main_activity);
    findViewById(R.id.button_run_scheduler).setOnClickListener(new View.OnClickListener() {
        @Override public void onClick(View v) {
            onRunSchedulerExampleButtonClicked();
        }
    });
}

@Override protected void onDestroy() {
    super.onDestroy();
    disposables.clear();
}

void onRunSchedulerExampleButtonClicked() {
    disposables.add(sampleObservable()
        // Run on a background thread
        .subscribeOn(Schedulers.io())
        // Be notified on the main thread
        .observeOn(AndroidSchedulers.mainThread())
        .subscribeWith(new DisposableObserver<String>() {
            @Override public void onComplete() {
                Log.d(TAG, "onComplete()");
            }

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

            @Override public void onNext(String string) {
                Log.d(TAG, "onNext(" + string + ")");
            }
        }));
}

static Observable<String> sampleObservable() {
    return Observable.defer(new Callable<ObservableSource<? extends String>>() {
      @Override public ObservableSource<? extends String> call() throws Exception {
            // Do some long running operation
            SystemClock.sleep(5000);
            return Observable.just("one", "two", "three", "four", "five");
        }
    });
}

sampleObservable()这个方法返回的是一个ObservableDefer的一个对象，这个对象继承了Observable这个类，我们现在解读一下defer这个方法都干了哪些事情：
2
@SchedulerSupport(SchedulerSupport.NONE)
public static <T> Observable<T> defer(Callable<? extends ObservableSource<? extends T>> supplier) {
    ObjectHelper.requireNonNull(supplier, "supplier is null");
    return RxJavaPlugins.onAssembly(new ObservableDefer<T>(supplier));
}
3
 ObjectHelper.requireNonNull(supplier, "supplier is null");

这句就不用说了，判断非空的。
4
 

RxJavaPlugins.onAssembly(new ObservableDefer<T>(supplier));
}
这句是其实也没做什么，主要是new一个ObservableDefer对象，上面说过了，这个对象继承了Observable类。sampleObservable()这个方法返回一个ObservableDefer对象，然后
 

这个对象开始链式调用了。
 

ObservableDefer.subscribeOn(Schedulers.io())，这个方法的直白翻译是:默认的可以被观察的（可以被订阅的对象）订阅在线程Schedulers.io()中，继续看源码：
5
public final Observable<T> subscribeOn(Scheduler scheduler) {
    ObjectHelper.requireNonNull(scheduler, "scheduler is null");
    return RxJavaPlugins.onAssembly(new ObservableSubscribeOn<T>(this, scheduler));
}

大家又看到上述中熟悉的代码语句，代码实现都是一样的，就是判断RxJavaPlugins中有无设置onObservableAssembly，本文中这个对象为空。后面再细说这个方法的作用。
那么其实就是讲上面Schedulers.io()返回的对象整合成ObservableSubscribeOn，然后再调用下面observeOn方法。我们首先看一下Schedulers.io()都干了什么；
6
public static Scheduler io() {
    return RxJavaPlugins.onIoScheduler(IO);
}
他返回一个Schedule对象，大家都知道Schedule对象的作用吧，但是不是你想的那样，这Schedule是RXJava中自定义的一个类，继续
 

先看下IO，
 

7
 

IO = RxJavaPlugins.initIoScheduler(new IOTask());
8
 

public static Scheduler initIoScheduler(@NonNull Callable<Scheduler> defaultScheduler) {
    ObjectHelper.requireNonNull(defaultScheduler, "Scheduler Callable can't be null");
    Function<? super Callable<Scheduler>, ? extends Scheduler> f = onInitIoHandler;
    if (f == null) {
        return callRequireNonNull(defaultScheduler);
    }
    return applyRequireNonNull(f, defaultScheduler);
}
onInitIoHandler对象为空，，所以调用callRequireNonNull方法，defaultScheduler=new IOTask(),extends Callable<Scheduler>
9
 

static Scheduler callRequireNonNull(@NonNull Callable<Scheduler> s) {
    try {
        return ObjectHelper.requireNonNull(s.call(), "Scheduler Callable result can't be null");
    } catch (Throwable ex) {
        throw ExceptionHelper.wrapOrThrow(ex);
    }
}
10
 

static final class IOTask implements Callable<Scheduler> {
    @Override
    public Scheduler call() throws Exception {
        return IoHolder.DEFAULT;
    }
}
11
 

static final class IoHolder {
    static final Scheduler DEFAULT = new IoScheduler();
}

 

上述9代码中返回的时候一个IoScheduler的对象。
 

 

我们继续说明
 

ObservableDefer.subscribeOn(Schedulers.io())这段代码都做了什么，其实就是返回new ObservableSubscribeOn<T>(this, scheduler)对象；我们标记为
ObservableSubscribeOn然后
 

12
 

observeOn(AndroidSchedulers.mainThread())

 

13
 

 

/** Android-specific Schedulers. */
public final class AndroidSchedulers {

    private static final class MainHolder {

        static final Scheduler DEFAULT = new HandlerScheduler(new Handler(Looper.getMainLooper()));
    }

    private static final Scheduler MAIN_THREAD = RxAndroidPlugins.initMainThreadScheduler(
            new Callable<Scheduler>() {
                @Override public Scheduler call() throws Exception {
                    return MainHolder.DEFAULT;
                }
            });

    /** A {@link Scheduler} which executes actions on the Android main thread. */
    public static Scheduler mainThread() {
        return RxAndroidPlugins.onMainThreadScheduler(MAIN_THREAD);
    }

    /** A {@link Scheduler} which executes actions on {@code looper}. */
    public static Scheduler from(Looper looper) {
        if (looper == null) throw new NullPointerException("looper == null");
        return new HandlerScheduler(new Handler(looper));
    }

    private AndroidSchedulers() {
        throw new AssertionError("No instances.");
    }
 

 

根据上述代码我们注意查看一下，
 

14
 

static final Scheduler DEFAULT = new HandlerScheduler(new Handler(Looper.getMainLooper()));
15
 

HandlerScheduler(Handler handler) {
    this.handler = handler;
}

 

就获得一个主线程的schedule，这个schedule中包含了主线程的handle对象。
 

16
 

    private static final Scheduler MAIN_THREAD = RxAndroidPlugins.initMainThreadScheduler(
            new Callable<Scheduler>() {
                @Override public Scheduler call() throws Exception {
                    return MainHolder.DEFAULT;
                }
            });

 

这段代码就是返回一个主线程的scheduler，具体实现如下：
 

17
 

public static Scheduler initMainThreadScheduler(Callable<Scheduler> scheduler) {
    if (scheduler == null) {
        throw new NullPointerException("scheduler == null");
    }
    Function<Callable<Scheduler>, Scheduler> f = onInitMainThreadHandler;
    if (f == null) {
        return callRequireNonNull(scheduler);
    }
    return applyRequireNonNull(f, scheduler);
}

 

onInitMainThreadHandler这个对象没有进行设置过，所以为空，这里面直接调用callRequireNonNull(scheduler)，里面直接调用schedule.call()方法进行回调。
此时就将上面代码14获取到的schedule返回给16中的MAIN_THREAD，此时我们再回到12代码块中ObservableSubscribeOn.observeOn(scheduler)；
18
public final Observable<T> observeOn(Scheduler scheduler) {
    return observeOn(scheduler, false, bufferSize());
}
public final Observable<T> observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {
    ObjectHelper.requireNonNull(scheduler, "scheduler is null");
    ObjectHelper.verifyPositive(bufferSize, "bufferSize");
    return RxJavaPlugins.onAssembly(new ObservableObserveOn<T>(this, scheduler, delayError, bufferSize));
}

上述代码中的RxJavaPlugins.onAssembly的方法我们就不说了里面的判断有误初始化默认，本文中未进行设置初始化参数，所以都是RxJavaPlugins.onAssembly传的参数是什么，
返回就是什么，此时返回的是一个新的ObservableObserveOn对象，我们标记为ObservableObserveOn这个对象中包含了一个主线程的schedule，我们继续：
19
.subscribeWith(new DisposableObserver<String>() {
    @Override public void onComplete() {
        Log.d(TAG, "onComplete()");
    }

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

    @Override public void onNext(String string) {
        Log.d(TAG, "onNext(" + string + ")");
    }
}));

subscribeWith，从字面理解一下这个方法的意思：与XX进行订阅，其实就是与订阅者（观察者）进行绑定，ObservableObserveOn这个包含有主线程的schedule的可被订阅
订阅运行器与订阅者进行绑定，example：Button.setOnclickListener(new OnclickListner{ public void onclick(View view)}) 其中onclicklistner就是订阅者，button
所在的环境就是ObservableObserveOn；下面我们在看一下订阅者：
20
new DisposableObserver<String>() {
    @Override public void onComplete() {
        Log.d(TAG, "onComplete()");
    }

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

    @Override public void onNext(String string) {
        Log.d(TAG, "onNext(" + string + ")");
    }
})
ObservableObserveOn.subscribeWith（DisposableObserver），我们看下源码：
21
Observable中的方法

public final <E extends Observer<? super T>> E subscribeWith(E observer) {
    subscribe(observer);
    return observer;
}

22
路由执行：
Observable中的方法
public final void subscribe(Observer<? super T> observer) {
    ObjectHelper.requireNonNull(observer, "observer is null");
    try {
        observer = RxJavaPlugins.onSubscribe(this, observer);

        ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");

        subscribeActual(observer);
    } catch (NullPointerException e) { // NOPMD
        throw e;
    } catch (Throwable e) {
        Exceptions.throwIfFatal(e);
        // can't call onError because no way to know if a Disposable has been set or not
        // can't call onSubscribe because the call might have set a Subscription already
        RxJavaPlugins.onError(e);

        NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
        npe.initCause(e);
        throw npe;
    }
}
subscribeActual是Observable的抽象类，在ObservableObserveOn.subscribeActual(DisposerObserver),继续贴出源码：
23
protected void subscribeActual(Observer<? super T> observer) {
    if (scheduler instanceof TrampolineScheduler) {
        source.subscribe(observer);
    } else {
        Scheduler.Worker w = scheduler.createWorker();

        source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
    }
}

上述代码中的schedule是原来我们设置执行主线程的产生的那个HandlerScheduler，所以上述的代码执行一目了然。source对象我们在说明一下，source对象是在18代码块
中进行传入，其实就是new ObservableObserveon中传入的this，那这个this是谁那？就是ObservableSubscribeOn，此时创建了一个worker对象，后面使用worker对象的时
候在说明，然后继续
24
RxJavaPlugins.onAssembly(new ObservableObserveOn<T>(this, scheduler, delayError, bufferSize));
此时代码已经顺利的执行到了此处，source===ObservableSubscribeOn
25
source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));

我们继续贴源码：
26
public final void subscribe(Observer<? super T> observer) {
    ObjectHelper.requireNonNull(observer, "observer is null");
    try {
        observer = RxJavaPlugins.onSubscribe(this, observer);

        ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");

        subscribeActual(observer);
    } catch (NullPointerException e) { // NOPMD
        throw e;
    } catch (Throwable e) {
        Exceptions.throwIfFatal(e);
        // can't call onError because no way to know if a Disposable has been set or not
        // can't call onSubscribe because the call might have set a Subscription already
        RxJavaPlugins.onError(e);

        NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
        npe.initCause(e);
        throw npe;
    }
}

上述代码是在ObservableSubscribeOn类中，执行subscribeActual(observer),observer不是disposeObserver，是后面创建的
27
继续贴出源码：
ObservableSubscribeOn中
public void subscribeActual(final Observer<? super T> s) {
    final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(s);

    s.onSubscribe(parent);

    parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
}
执行s.onSubscribe(parent),其中s为ObservableObserveon.ObserveOnObserver,

由于过多的字发表不了，请关注第二篇
 

 


 

                

        

        

    

  


    

      

        

            

              
                
                  laugh_yu
                
              
            

            

                关注
              
            

        

        

          
      

      









              

  



          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值