RxJava1.x的诞生

最新推荐文章于 2022-07-20 18:30:48 发布

二爽玩安卓

最新推荐文章于 2022-07-20 18:30:48 发布

阅读量315

点赞数

分类专栏： android 文章标签： Rxjava

原文链接：https://blog.csdn.net/jeasonlzy/article/details/74267803

版权

android 专栏收录该内容

6 篇文章 1 订阅

订阅专栏

转载请注明出处，https://blog.csdn.net/jeasonlzy。（这是根据大佬jeasonlzy的https://blog.csdn.net/jeasonlzy/article/details/74267803的文章及直播视频录像进行的再次自己敲并分析）

由于有幸加入489873144（android格调小窝） 看到群主的一次直播讲解rxjava的起源，现决定自己也边敲边总结一遍，好让自己留下深刻的学习印象。该大佬csdn: https://blog.csdn.net/jeasonlzy , 在此拜谢。

环境配置:加入该大佬的框架Okgo (非最新版本)

compile 'com.lzy.net:okgo:2.1.4'

场景描述:

1.联网获取新闻列表

2.找到最新一条的标题

3.保存最新的标题到文件

一、同步情况:

首先，我们进行这些操作肯定是需要对应的网络请求方法，所以我们需要创建一个NetApi:

public class NetApi {
    /**
     * 获取新闻列表
     * @param page      当前页数
     * @param itemCount 条目数量
     * @return          请求后的响应结果
     */
    public Response getNewsList(int page,int itemCount){
        //doSomething
        return null;
    }

    /**
     * 保存标题到文件
     * @param title 标题
     * @return      返回对应的uri
     */
    public Uri save(String title){
        //doSomething
        return null;
    }
}

然后根据这个基础api我们完成一下ApiHelper去实现具体的逻辑:这里findLatestTitle就不具体写了

public class ApiHelper {
    private NetApi netApi;
    public ApiHelper(){
        netApi = new NetApi();
    }

    /**
     * 获取并保存最近的title
     * @return
     */
    public Uri getAndSaveLatestTitle(){
        Response newsList = netApi.getNewsList(1, 20);
        String title = findLatestTitle(newsList);
        Uri uri = netApi.save(title);
        return uri;
    }

    /**
     * 找到最近的title
     * @param response
     * @return
     */
    private String findLatestTitle(Response response){
        System.out.println("----findLatestTitle----");
        return "----findLatestTitle----";
    }
}

通过上面这个apiHelper我们再在主函数中调用就可以获得保存下来的对应uri啦~

public class MainActivity extends AppCompatActivity {

    private ApiHelper helper;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        helper = new ApiHelper();
    }

    public void test(){
        Uri uri = helper.getAndSaveLatestTitle();
        System.out.println(uri);
    }
}

以上就是同步的存储获取方法的大概思路，有没有发现，都是直接操作某事直接就返回对应的结果（通过返回值不是void就可以看出）。这样是不是感觉很方便？

那么如果我们用异步的方法会怎样呢？

众说周至，比如访问网络都应该是异步请求然后进行回调的，在回调里处理服务端返回的相应结果。然后可以在处理结果时回调Activity传入的接口去回调Activity中的该接口回调里更新ui的方法。就像在mvp中，让Activity实现Iview接口然后在presenter中进行回调一样。

ps:开森~~无线鼠标到啦~~刚取了快递~哎。。不说了手感有点差

二、异步情况:

好，那我们先来看一下异步的NetApi的重写：

public class NetApi {
    public static final String URL = "";

    public interface NewsCallback{
        void onNewsSuccess(Response response);

        void onNewsError(Exception e);
    }
    public interface SaveCallback{
        void onNewsSuccess(Uri uri);

        void onNewsError(Exception e);
    }
    /**
     * 获取新闻列表
     * @param page      当前页数
     * @param itemCount 条目数量
     * @return          请求后的响应结果
     */
    public void getNewsList(int page,int itemCount,final NewsCallback callback){
        OkGo.get(URL)
                .execute(new StringCallback() {
                    @Override
                    public void onSuccess(String s, Call call, okhttp3.Response response) {
                        Response convert = new Gson().fromJson(s, Response.class);
                        callback.onNewsSuccess(convert);
                    }

                    @Override
                    public void onError(Call call, okhttp3.Response response, Exception e) {
                        super.onError(call, response, e);
                        callback.onNewsError(e);
                    }
                });
    }

    /**
     * 保存标题到文件
     * @param title 标题
     * @return      返回对应的uri
     */
    public void save(String title ,final SaveCallback callback){
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    //保存标题然后进行保存成功的回调，把保存好的uri传出去
                    callback.onNewsSuccess(Uri.parse("xxxxx"));
                }catch (Exception e){
                    callback.onNewsError(e);
                }
            }
        }
        ).start();

    }
}

这里我们加了两个接口，这样的话，当外界掉这个save方法的时候就可以在外界设置第二个参数callback，然后在收到网络响应后触发该callback的重写方法。

好，我们接下来看一下ApiHelper是怎么改的。

public class ApiHelper {
    private NetApi netApi;
    public ApiHelper(){
        netApi = new NetApi();
    }

    public interface Callback{
        void onSuccess(Uri uri);

        void onError(Exception e);
    }

    /**
     * 获取并保存最近的title
     * @return
     */
    public void getAndSaveLatestTitle(final Callback callback){
        netApi.getNewsList(1, 20, new NetApi.NewsCallback() {
            @Override
            public void onNewsSuccess(Response response) {
                String title = findLatestTitle(response);
                netApi.save(title, new NetApi.SaveCallback() {
                    @Override
                    public void onNewsSuccess(Uri uri) {
                        callback.onSuccess(uri);
                    }

                    @Override
                    public void onNewsError(Exception e) {
                        callback.onError(e);
                    }
                });
            }

            @Override
            public void onNewsError(Exception e) {
                callback.onError(e);
            }
        });
    }

    /**
     * 找到最近的title
     * @param response
     * @return
     */
    private String findLatestTitle(Response response){
        return response.toString();
    }
}

这里呢。。定义了一个callback，这个callback实际上是给外部调用getAndSaveLatestTitle方法时所用的回调，也就是说我外部掉了你这个方法得知道结果啊。所以在成功或者失败后调用改方法把结果向上传。

所以呢，这里就出现了嵌套callback，也就是用访问title的结果再给如save去保存然后再返回走save的callbak再返回走外部的callback回调：

上图中第二步实际是第一次回调，第三步是第二次回调，第四补是第三次回调。

所以有了很多冗余代码，我们为何不找到这些回调的共同点然后提取出来呢？

那么我们看下：

public interface NewsCallback{
        void onNewsSuccess(Response response);

        void onNewsError(Exception e);
    }
    public interface SaveCallback{
        void onNewsSuccess(Uri uri);

        void onNewsError(Exception e);
    }

public interface Callback{
        void onSuccess(Uri uri);

        void onError(Exception e);
    }

他们都是一个成功一个失败，由于都是异步回调的接口返回都是void(因为无法及时回传结果，需要在回调接口中得到数据)。那么区别是什么呢？成功的传参不一样。所以我们完全可以用泛型抽取。

public interface Callback <T>{
    void onSuccess(T t);

    void onError(Exception e);
}

那之后我们的NetApi就变为：

public class NetApi {
    public static final String URL = "";
    /**
     * 获取新闻列表
     * @param page      当前页数
     * @param itemCount 条目数量
     * @return          请求后的响应结果
     */
    public void getNewsList(int page,int itemCount,final Callback<Response> callback){
        OkGo.get(URL)
                .execute(new StringCallback() {
                    @Override
                    public void onSuccess(String s, Call call, okhttp3.Response response) {
                        Response convert = new Gson().fromJson(s, Response.class);
                        callback.onSuccess(convert);
                    }

                    @Override
                    public void onError(Call call, okhttp3.Response response, Exception e) {
                        super.onError(call, response, e);
                        callback.onError(e);
                    }
                });
    }

    /**
     * 保存标题到文件
     * @param title 标题
     * @return      返回对应的uri
     */
    public void save(String title ,final Callback<Uri> callback){
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    //保存标题然后进行保存成功的回调，把保存好的uri传出去
                    callback.onSuccess(Uri.parse("xxxxx"));
                }catch (Exception e){
                    callback.onError(e);
                }
            }
        }
        ).start();

    }
}

看，我们把几处的callback都换成了泛型。

然后我们再改一下apiHelper:

public class ApiHelper {
    private NetApi netApi;
    public ApiHelper(){
        netApi = new NetApi();
    }

    

    /**
     * 获取并保存最近的title
     * @return
     */
    public void getAndSaveLatestTitle(final Callback<Uri> callback){
        netApi.getNewsList(1, 20, new Callback<Response>() {
            @Override
            public void onSuccess(Response response) {
                String title = findLatestTitle(response);
                netApi.save(title, new Callback<Uri>() {
                    @Override
                    public void onSuccess(Uri uri) {
                        callback.onSuccess(uri);
                    }

                    @Override
                    public void onError(Exception e) {
                        callback.onError(e);
                    }
                });
            }

            @Override
            public void onError(Exception e) {
                callback.onError(e);
            }
        });
    }

    /**
     * 找到最近的title
     * @param response
     * @return
     */
    private String findLatestTitle(Response response){
        return response.toString();
    }
}

在这之后呢，我们改一下最外层的MainActivity。

MainActivity里的test就变为:

public void test(){
        helper.getAndSaveLatestTitle(new Callback<Uri>() {
            @Override
            public void onSuccess(Uri uri) {
                System.out.println(uri);
            }

            @Override
            public void onError(Exception e) {
                System.out.println(e);
            }
        });
    }

说白了，这个callback的泛型就是传入成功的参数，当得到上一步的结果后传入。然后在回调里就可以得到该参数。

那么下面我们怎么调整呢？

思路:那么上面的异步为什么会嵌套callback呢？还不是因为他不能及时有返回值，所以要用callback回调，所以如何能让他像同步那样有返回结果呢(代码更加清晰)？答案是我们虽然并做不到传回结果，但我们可以返回一得到该结果的步骤。就好像存储过程一样，返回一个存储过程，里面是如何根据网络请求的相应得到对应处理结果的代码逻辑。

那么首先我们创建一个AsyncJob类

public abstract class AsyncJob<T> {
    /**
     * 这个接口的目的是什么？就是为了用户调用start方法并传入对应的带不同泛型类的callback
     * 得到对应的结果。
     * @param callback
     */
    public abstract void start(Callback<T>callback);
}

那改完的getNewsList方法如下:

 public AsyncJob<Response> getNewsList(int page, int itemCount, final Callback<Response> callback){
        return new AsyncJob<Response>() {
            @Override
            public void start(final Callback<Response> callback) {
                OkGo.get(URL)
                        .execute(new StringCallback() {
                            @Override
                            public void onSuccess(String s, Call call, okhttp3.Response response) {
                                Response convert = new Gson().fromJson(s, Response.class);
                                callback.onSuccess(convert);
                            }

                            @Override
                            public void onError(Call call, okhttp3.Response response, Exception e) {
                                super.onError(call, response, e);
                                callback.onError(e);
                            }
                        });
            }
        };
    }

可以看到，我们的getNewsList返回了一个AsyncJob对象，而这个对象的作用就是你给我一个泛型类(Response),那么你随时都可以调用我这个对象的start方法并传入callback。然后你什么时候想调就start一下就会执行该网络请求，然后最后调用您start时传入的callback结果回调。

说白了，他就是把请求网络然后调用回调结果的逻辑储存起来了。当您调用AsyncJob对象的start方法时，他就会调用您之前已经设置好的start逻辑(请求网络)，然后根据成功与否回调您调用start方法时的回调。

我们做一下前后对比:

这样就更清晰了，也就是说之前是您调用getNewsList方法就要设置请求成功与否的callback，因为调用了getNewsList就会请求网络得到结果然后回调，所以要立即设置。

而改完呢。调用getNewsList就返回的是一个对象，什么时候您想调用这个对象的start了，就告诉他请求成功与否会怎样，然后调用。他就会进去请求服务器得到对应的结果执行您此时调用start方法时设置的回调callback了。。一个是现设置callback现调，一个是存起来调完的逻辑，然后什么时候调什么时候设置调完的回调结果再调。

所以达到的效果就是我们调用了start方法并传入设置的回调，最后又会回到这个方法传入的回调的重写方法里。

哎。。说了这么多其实就是个策略模式，做完一些逻辑后回调您传入的接口实现的回调方法。

但是问题的真正关键不是在这个回调。。(我想偏了) 问题的真正关键在于之前也设置了回调，但是是在调用getNewsList方法时就要设置回调的结果。而现在则是把请求网络逻辑存到一个对象的start方法里然后返回，在您想用的时候调用该对象的start方法并设置callback。他只不过是把调用网络请求的代码逻辑封装在了一个对象方法里，然后返回这个对象即可，用的时候您再调，在调的时候再现设置回调方法。

所以这种操作就是保留了固定代码，然后让非固定代码在调的时候用户自己设置。之前则是直接就调了，所以当时就要设置callback的这些可变代码。

之前是直接传进来一个callback就设置了，现在是相当于传进来一个对象，在你在外界调start的时候再传进来callback。

这让我想到以前我写的代码，都是直接写的实现参数。原来是可以不传进来，把里面的逻辑封装到一个对象的方法里。等掉这个对象的方法时我再传入这个callback。（感谢大佬~~之前我真的没有想到这种思路，致敬~jeasonlzy）

改完的netApi方法

public class NetApi {
    public static final String URL = "";
    /**
     * 获取新闻列表
     * @param page      当前页数
     * @param itemCount 条目数量
     * @return          请求后的响应结果
     */
    public AsyncJob<Response> getNewsList(int page, int itemCount){
        return new AsyncJob<Response>() {
            @Override
            public void start(final Callback<Response> callback) {
                OkGo.get(URL)
                        .execute(new StringCallback() {
                            @Override
                            public void onSuccess(String s, Call call, okhttp3.Response response) {
                                Response convert = new Gson().fromJson(s, Response.class);
                                callback.onSuccess(convert);
                            }

                            @Override
                            public void onError(Call call, okhttp3.Response response, Exception e) {
                                super.onError(call, response, e);
                                callback.onError(e);
                            }
                        });
            }
        };
    }

    /**
     * 保存标题到文件
     * @param title 标题
     * @return      返回对应的uri
     */
    public AsyncJob<Uri> save(String title){
        return new AsyncJob<Uri>() {
            @Override
            public void start(final Callback<Uri> callback) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            //保存标题然后进行保存成功的回调，把保存好的uri传出去
                            callback.onSuccess(Uri.parse("xxxxx"));
                        } catch (Exception e) {
                            callback.onError(e);
                        }
                    }
                }
                ).start();
            }
        };
    }
}

下面改ApiHelper:

public class ApiHelper {
    private NetApi netApi;
    public ApiHelper(){
        netApi = new NetApi();
    }



    /**
     * 获取并保存最近的title
     * @return
     */
    public AsyncJob<Uri> getAndSaveLatestTitle(){
        final AsyncJob<Response> newsList = netApi.getNewsList(1, 20);
        final AsyncJob<String> title = new AsyncJob<String>() {
            @Override
            public void start(final Callback<String> callback) {
                newsList.start(new Callback<Response>() {
                    @Override
                    public void onSuccess(Response response) {
                        String latestTitle = findLatestTitle(response);
                        callback.onSuccess(latestTitle);
                    }

                    @Override
                    public void onError(Exception e) {
                        callback.onError(e);
                    }
                });

            }
        };

        AsyncJob<Uri> save = new AsyncJob<Uri>() {
            @Override
            public void start(final Callback<Uri> callback) {
                title.start(new Callback<String>() {
                    @Override
                    public void onSuccess(String s) {
                        AsyncJob<Uri> saved = netApi.save(s);
                        saved.start(new Callback<Uri>() {
                            @Override
                            public void onSuccess(Uri uri) {
                                //已保存
                                callback.onSuccess(uri);
                            }

                            @Override
                            public void onError(Exception e) {
                                callback.onError(e);
                            }
                        });
                    }

                    @Override
                    public void onError(Exception e) {
                        callback.onError(e);
                    }
                });
            }
        };
        return save;


        /*netApi.getNewsList(1, 20, new Callback<Response>() {
            @Override
            public void onSuccess(Response response) {
                String title = findLatestTitle(response);
                netApi.save(title, new Callback<Uri>() {
                    @Override
                    public void onSuccess(Uri uri) {
                        callback.onSuccess(uri);
                    }

                    @Override
                    public void onError(Exception e) {
                        callback.onError(e);
                    }
                });
            }

            @Override
            public void onError(Exception e) {
                callback.onError(e);
            }
        });*/
    }

    /**
     * 找到最近的title
     * @param response
     * @return
     */
    private String findLatestTitle(Response response){
        return response.toString();
    }
}

这里我再也先贴出MainActivity的改变结果

public void test(){
        AsyncJob<Uri> andSaveLatestTitle = helper.getAndSaveLatestTitle();
        andSaveLatestTitle.start(new Callback<Uri>() {
            @Override
            public void onSuccess(Uri uri) {
                System.out.println(uri);
            }

            @Override
            public void onError(Exception e) {
                System.out.println(e);
            }
        });

       /* helper.getAndSaveLatestTitle(new Callback<Uri>() {
            @Override
            public void onSuccess(Uri uri) {
                System.out.println(uri);
            }

            @Override
            public void onError(Exception e) {
                System.out.println(e);
            }
        });*/
    }

那么这点儿我来形容一下调用思路:

正向:

我们需要得到保存title到本地后的结果，那么我们就需要先设置保存成功与否的回调并调用save的start方法。

save的start方法需要得到title的结果，所以我们需要先设置获取title成功与否的回调并调用title的start方法。

title的start的方法内我们需要通过接口返回title的话就需要先设置newsList的成功与否的回调并调用newsList的start方法。

newsList会去访问网络，然后调用title里的回调接口把从response里取出title赋值，然后再回调save里的callback把title给save并进行保存，然后最后把save成功与否的结果通过回调给MainActvity里的System.out.println(uri);

这是正向的我们看代码的。但是写的时候我们是反着写的，那怎么想到下面这一段呢？

final AsyncJob<String> title = new AsyncJob<String>() {
            @Override
            public void start(final Callback<String> callback) {
                newsList.start(new Callback<Response>() {
                    @Override
                    public void onSuccess(Response response) {
                        String latestTitle = findLatestTitle(response);
                        callback.onSuccess(latestTitle);
                    }

                    @Override
                    public void onError(Exception e) {
                        callback.onError(e);
                    }
                });

            }
        };

那是因为我们要调用newsList并获得对应的String title，那么我们就需要用newsList对象调newsList的start方法并写入回调。然而同时上面这个操作又是title的获取的start里的逻辑。所以我们要把这些放在title的start方法重写里。然后从别的地方调title对象的start方法并设置callback进来，所以titlte也要用AsyncJob.以此类推，后面的save也要用外部的start调起并传入callback好让save把结果回调出去，所以save也要用AsyncJob。

我感觉此时大佬总结的“保存动作”这个词很受用。title的start方法里保存了newsList的动作并调用，save里保存了title的动作，外面保存了save的动作。然后从外界就会调用save的动作并设置回调，然后save又会调用title的动作并设置回调，然后title又会调用newsList的动作并设置回调，然后newsList访问网络再一步步回调回来。

ps:好啦。。我去吃下饭。。。回来写后面的内容~~~~~

刚刚在吃饭的时候我反思了下为什么自己之前没有想到这种用对象存储动作然后再调的思路。那是因为之前比如一个方法我传入接口，那么哪里用我就哪里进行实现传入该参数。但是现在这种方法其实一样，就是哪儿用就在哪里掉start传入实现。其实都是要传入实现的，只是第一种是在调用的各位置都直接写实现，第二种是在各个位置都封装了个对象，然后把实现写在对象里在传入。其实就多了一层对象的封装。

那么大佬为什么要多封装一次这样的对象呢？个人理解是为了后面的代码提取。因为都提取出来一个对象调方法的话，这样就可以再进行抽象了。当然这只是我的猜测，我继续看下面的改动。

果然，大佬接着就回答了我的问题。基本上这三个start都是在里面调用了下一步的动作的start，并在设置start，然后在start里进行了数据转换，所以这样就可以提取泛型代码了。。试想一下，如果都是只是一个callback，还抽象出来个屁。。但是这个理由我觉得还不充足，后面继续看。

奥。。看完他的提取我明白为什么要都提出来用start调了，因为真的是这样才更容易提取内部的处理方法为接口。因为如果用之前的方法，那么返回的都是void，那么不方便在外部提取接口，我总不能每一个callback再多传入一个接口，这个接口就为了提取不同对数据的处理方法吧(对网络获取或者其他方式获取的数据的处理)？

所以这种把内部代码封装成对象在外部调用的思路，可以有效的让我们提取多个方法内部的不同代码处理逻辑到外面为接口。

好，下面看一下怎么提取的。加了个接口：

/**
 * 转换接口
 * @param <T>
 * @param <R>
 */
public interface Fun1<T,R>{
    R call(T t);
}

另一个是:在AcyncJob里加了个方法

public abstract class AsyncJob<T> {
    /**
     * 这个接口的目的是什么？就是为了用户调用start方法并传入对应的带不同泛型类的callback
     * 得到对应的结果。
     * @param callback
     */
    public abstract void start(Callback<T>callback);

    public <R> AsyncJob<R> map(final Fun1<T,R> fun1){
        final AsyncJob<T>source =this;
        return new AsyncJob<R>() {
            @Override
            public void start(final Callback<R> callback) {
                source.start(new Callback<T>() {
                    @Override
                    public void onSuccess(T t) {
                        R r = fun1.call(t);
                        callback.onSuccess(r);
                    }

                    @Override
                    public void onError(Exception e) {
                        callback.onError(e);
                    }
                });
            }
        };
    }
}

其中得到fun1就是提取出来的转换内部数据过程的接口。至于final AsyncJob<T>source =this;这句话的理解:有人会说，哇！抽象类里有了this！是的，此前我一直以为抽象类里不能有this，因为抽象类没有实例化对象，那么this代表什么呢？后来在看另外一个项目时发现，此处的this就是代表当前抽象类的子类的对象。。所以。。那我当前的map方法肯定是我当前的具有动作的AsyncJob实例调的啊，所以大佬用source存储了当前的AsyncJob实例并调用source.start(callback)方法。但是在返回结果的时候我们每次都是new了一个新的动作AsyncJob实例，所以return的就不能是source了而是new一个新的AsyncJob实例。

final AsyncJob<String> title = new AsyncJob<String>() {
            @Override
            public void start(final Callback<String> callback) {
                newsList.start(new Callback<Response>() {
                    @Override
                    public void onSuccess(Response response) {
                        String latestTitle = findLatestTitle(response);
                        callback.onSuccess(latestTitle);
                    }

                    @Override
                    public void onError(Exception e) {
                        callback.onError(e);
                    }
                });

            }
        };

那么我们看看上面的方法就可以抽成下面这样：

final AsyncJob<Response> newsList = netApi.getNewsList(1, 20);
        newsList.map(new Fun1<Response, String>() {
            @Override
            public String call(Response response) {
                return findLatestTitle(response);
            }
        });

那么save也能这么处理么？答案是no，因为save在转换后转换出来的是另外一个动作，这个动作是给MainActivity里用的。所以之前的在动作里返回R是不行的，那出的泛型要改成AsyncJob<R>。如下:

这里这样会报错的，因为返回的R并不是AsyncJob<R>

我们先写上我们需要的这样的结果然后通过快捷键创建flatMap方法(自动修复):

修复得到方法

然后进行修改为:

public <R> AsyncJob<R> flatMap(final Fun1<T, AsyncJob<R>> fun1) {
        final AsyncJob<T> source=this;
        return  new AsyncJob<R>() {
            @Override
            public void start(final Callback<R> callback) {
                source.start(new Callback<T>() {
                    @Override
                    public void onSuccess(T t) {
                        AsyncJob<R> call = fun1.call(t);
                        call.start(new Callback<R>() {
                            @Override
                            public void onSuccess(R r) {
                                callback.onSuccess(r);
                            }

                            @Override
                            public void onError(Exception e) {
                                callback.onError(e);
                            }
                        });
                    }

                    @Override
                    public void onError(Exception e) {

                    }
                });
            }
        };

然后apiHelper就变为:

public AsyncJob<Uri> getAndSaveLatestTitle(){
        final AsyncJob<Response> newsList = netApi.getNewsList(1, 20);
        AsyncJob<String> title = newsList.map(new Fun1<Response, String>() {
            @Override
            public String call(Response response) {
                return findLatestTitle(response);
            }
        });

        AsyncJob<Uri> save = title.flatMap(new Fun1<String, AsyncJob<Uri>>() {
            @Override  
            public AsyncJob<Uri> call(String s) {
                return netApi.save(s);
            }
        });

        return save;
        }

        /**
         * 找到最近的title
         * @param response
         * @return
         */
        private String findLatestTitle(Response response){
            return response.toString();
        }
}

那么最后我们就可以全部都直接拷的MainActivity里：

private NetApi netApi = new NetApi();
    public void test(){
        final AsyncJob<Response> newsList = netApi.getNewsList(1, 20);
        AsyncJob<String> title = newsList.map(new Fun1<Response, String>() {
            @Override
            public String call(Response response) {
                return findLatestTitle(response);
            }
        });

        AsyncJob<Uri> save = title.flatMap(new Fun1<String, AsyncJob<Uri>>() {
            @Override
            public AsyncJob<Uri> call(String s) {
                return netApi.save(s);
            }
        });

        save.start(new Callback<Uri>() {
            @Override
            public void onSuccess(Uri uri) {
                System.out.println(uri);
            }

            @Override
            public void onError(Exception e) {
                System.out.println(e);
            }
        });
    }
    /**
     * 找到最近的title
     * @param response
     * @return
     */
    private String findLatestTitle(Response response){
        return response.toString();
    }

由于上面的方法每一次返回的都是下一步直接可以用来接着打点调的，所以可以改为连续调:

public void test(){
        netApi.getNewsList(1, 20)
                .map(new Fun1<Response, String>() {
                    @Override
                    public String call(Response response) {
                        return findLatestTitle(response);
                    }
                })
                .flatMap(new Fun1<String, AsyncJob<Uri>>() {
                    @Override
                    public AsyncJob<Uri> call(String s) {
                        return netApi.save(s);
                    }
                })
                .start(new Callback<Uri>() {
                    @Override
                    public void onSuccess(Uri uri) {
                        System.out.println(uri);
                    }

                    @Override
                    public void onError(Exception e) {
                        System.out.println(e);
                    }
                });
}

所以呢此时就发现这已经是rxjava1.x的调用了，后面的是链式的倒数第二个是分开的。到此，模拟rxjava1.x的代码就写的差不多了。

但是我们能让他更像一些：我们改个名字：

AsyncJob改为Observable Callback改为Observer(观察者) onSuccess 改为 onNext start改为 subscribe

然后再看看我们的MainActivity:

netApi.getNewsList(1, 20)
                .map(new Fun1<Response, String>() {
                    @Override
                    public String call(Response response) {
                        return findLatestTitle(response);
                    }
                })
                .flatMap(new Fun1<String, Observable<Uri>>() {
                    @Override
                    public Observable<Uri> call(String s) {
                        return netApi.save(s);
                    }
                })
                .subscribe(new Observer<Uri>() {
                    @Override
                    public void onNext(Uri uri) {
                        System.out.println(uri);
                    }

                    @Override
                    public void onError(Exception e) {
                        System.out.println(e);
                    }
                });

看看，是不是差不多了。

因为Observable (AsyncJob)被观察者 subscribe(start) 订阅 observer(Callback) 观察者

所以就是：被观察者订阅一个观察者，然后最后回调该观察者里的回调方法，然后进行call转换。

好啦。。。后面还有具体的优化更改，明天跟进一下。。。。。

这里特地感谢一下jeasonlzy大佬，https://blog.csdn.net/jeasonlzy 这里是大佬博客，大佬的okgo也特别好用，再次再次像大佬致敬~~~

二爽玩安卓

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
RxJava1.x的诞生

转载请注明出处，https://blog.csdn.net/jeasonlzy。（这是根据大佬jeasonlzy的https://blog.csdn.net/jeasonlzy/article/details/74267803的文章及直播视频录像进行的再次自己敲并分析）由于有幸加入489873144（android格调小窝）看到群主的一次直播讲解rxjava的起源，现决定自己也边敲边总结一遍...
复制链接

扫一扫