RxAndroid 主/子线程切换配合的三种方式

我使用RxJava和RxAndroid的一个主要目的就是为了让逻辑复杂的业务需求在代码表现上不会特别混乱，以前在接手别人的项目的时候，经常碰到if else嵌套好几层的情况，还有当同一页面上出现好多异步任务的时候，会出现大量的回调的嵌套，程序员往往分了很多的函数东一笔西一笔的，读起来非常困难。

而RxJava解决这类问题就很得心应手，RxJava可以把复杂的业务逻辑用一条线串连起来，没有复杂的回调嵌套，也不会出现大型项目中常见的“谜之缩进”的代码，更可贵的是RxJava在处理异常上比传统try catch好的多，让代码更整洁和逻辑清晰。尤其在一项业务涉及到好多个网络接口，数据库查询，和一些耗时的计算操作，非常适合使用RxJava的方式将主线程和子线程执行的动作串联在一张页面上，通过自上而下的阅读代码就可以理清楚整个业务流程，对于大型项目来说非常实用。

这里写一个小demo来演示RxAndroid在碰到很多异步任务的情况下，在主线程和子线程之间灵活切换的案例。

比如现在有这样一个需求，给出一个url，如http://qduxsh.zz.vc/html/article.php?id=33，取出这个url中的协议名“http”，域名“qduxsh.zz.vc”,和api地址“/html/article.php”和全部的get请求参数“id=33”

方式一：异步任务式调用

现在我们假设从url中解析出这些信息是一个非常耗时的操作，需要放在子线程中执行，并在全部结果均获取完毕后显示在UI上，那么使用RxJava可以像下面一样，使用有点像AsynTask的写法实现不同线程的异步回调

/**
     * 一个简单的封装类
     */
    public class UrlEntity{
        public String protocol;
        public String host;
        public String api;
        public String params;
    }

final String url = "http://qduxsh.zz.vc/html/article.php?id=33";
        Observable.create(new Observable.OnSubscribe<UrlEntity>() {
            @Override
            public void call(Subscriber<? super UrlEntity> subscriber) {//子线程执行的方法
                Log.i("Alex", "call()执行线程是" + Thread.currentThread().getName() + "线程优先级=" + Thread.currentThread().getPriority() + "  线程id=" + Thread.currentThread().getId());
                //假设一下几行处理都是耗时操作
                Uri uri = Uri.parse(url);
                String protocol = uri.getScheme();
                String host = uri.getHost();
                String api = uri.getPath();
                String params = url.substring(url.lastIndexOf('?')+1,url.length());
                UrlEntity entity = new UrlEntity();
                entity.protocol = protocol;
                entity.host = host;
                entity.api = api;
                entity.params = params;
                //以上内容均在子线程执行
                //现在开始触发主线程的回调
                subscriber.onNext(entity);

                subscriber.onCompleted();
            }
        })
                .subscribeOn(Schedulers.computation()) // 指定 subscribe() 发生在 运算 线程
                .observeOn(AndroidSchedulers.mainThread()) // 指定 Subscriber 的回调发生在主线程
                .subscribe(new Observer<UrlEntity>() {

                    @Override
                    public void onNext(UrlEntity entity) {//主线程执行的方法
                        Log.i("Alex", "onNext()执行线程是" + Thread.currentThread().getName() + "线程优先级=" + Thread.currentThread().getPriority() + "  线程id=" + Thread.currentThread().getId());
                        TextView tv_protocol = (TextView) findViewById(R.id.tv_protocol);
                        tv_protocol.setText(entity.protocol);
                        TextView tv_host = (TextView) findViewById(R.id.tv_host);
                        tv_host.setText(entity.host);
                        TextView tv_api = (TextView) findViewById(R.id.tv_api);
                        tv_api.setText(entity.api);
                        TextView tv_param_list = (TextView) findViewById(R.id.tv_param_list);
                        tv_param_list.setText(entity.params);
                    }

                    @Override
                    public void onCompleted() {
                        Log.i("Alex", "onCompleted");
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.i("ALex", "出现了异常", e);
                        Toast.makeText(MainActivity.this, "Error!", Toast.LENGTH_SHORT).show();
                    }
                });

那么现在肯定有人会说了，AsynTask也可以实现同样的效果，而且代码比这个更简洁易懂，那么我们还要RxJava干什么，但是假如我们现在修改一下需求，不要等协议，域名，api，参数都解析完毕才显示在UI上，而是这几个需求同时解析，谁先解析完谁就先显示，让用户尽快的看到页面的变化，那么用RxJava写应该如何呢？

方式二：子线程分步任务逐个回调

public enum Type {
        host,
        protocol,
        api,
        params
    }
    public static class KeyValue{
        public Type type;
        public String value;
        public KeyValue(Type type, String value) {
            this.type = type;