Retrofit和RxJava结合使用例子分析

最新推荐文章于 2022-10-20 16:50:57 发布
最新推荐文章于 2022-10-20 16:50:57 发布
阅读量1.7k 收藏 1
点赞数 1
分类专栏： Android框架 文章标签： Retrofit Rxjava flatmap retrywhen behaviorsubject
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hzl9966/article/details/51303647
版权

以GitHub上的一个例子进行分析一下

https://github.com/rengwuxian/RxJavaSamples

先讲下总体架构

分为基本、转换（MAP）、压合（ZIP）、TOKEN（FLATMAP）、TOKEN_高级（RETRYWHEN）、缓存（BEHAVIORSUBJECT）。

整体是通过viewpager+fragment进行实现，通过Tablayout和viewpager进行关联，进行网络请求展示相关数据。

定义接口API

<span style="font-size:18px;">public interface ZhuangbiApi {
    @GET("search")
    Observable<List<ZhuangbiImage>> search(@Query("q") String query);
}</span>

定义NetWork类返回API接口的实现类。 

<span style="font-size:18px;">public class Network {
    private static ZhuangbiApi zhuangbiApi;
    private static GankApi gankApi;
    private static FakeApi fakeApi;
    private static OkHttpClient okHttpClient = new OkHttpClient();
    private static Converter.Factory gsonConverterFactory = GsonConverterFactory.create();
    private static CallAdapter.Factory rxJavaCallAdapterFactory = RxJavaCallAdapterFactory.create();

    public static ZhuangbiApi getZhuangbiApi() {
        if (zhuangbiApi == null) {
            Retrofit retrofit = new Retrofit.Builder()
                    .client(okHttpClient)
                    .baseUrl("http://zhuangbi.info/")
                    .addConverterFactory(gsonConverterFactory)
                    .addCallAdapterFactory(rxJavaCallAdapterFactory)
                    .build();
            zhuangbiApi = retrofit.create(ZhuangbiApi.class);
        }
        return zhuangbiApi;
    }

    public static GankApi getGankApi() {
        if (gankApi == null) {
            Retrofit retrofit = new Retrofit.Builder()
                    .client(okHttpClient)
                    .baseUrl("http://gank.io/api/")
                    .addConverterFactory(gsonConverterFactory)
                    .addCallAdapterFactory(rxJavaCallAdapterFactory)
                    .build();
            gankApi = retrofit.create(GankApi.class);
        }
        return gankApi;
    }

    public static FakeApi getFakeApi() {
        if (fakeApi == null) {
            fakeApi = new FakeApi();
        }
        return fakeApi;
    }
}</span>

基本使用 

  <span style="font-size:18px;">Observer<List<ZhuangbiImage>> observer = new Observer<List<ZhuangbiImage>>() {
        @Override
        public void onCompleted() {
        }

        @Override
        public void onError(Throwable e) {
            swipeRefreshLayout.setRefreshing(false);
            Toast.makeText(getActivity(), R.string.loading_failed, Toast.LENGTH_SHORT).show();
        }

        @Override
        public void onNext(List<ZhuangbiImage> images) {
            swipeRefreshLayout.setRefreshing(false);
            adapter.setImages(images);
        }
    };</span>

在onNext方法执行完成后进行数据的展示。

网络请求

<span style="font-size:18px;"> subscription = Network.getZhuangbiApi()
                .search(key)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(observer);</span>

转换（MAP）

有些服务端的接口设计，会在返回数据外层包裹一些额外信息，这些信息对于调试很有用，但本地显示是用不到的，使用map()可以把外层的格式去掉，只留下需要显示的数据格式。

以下是网络请求代码

 <span style="font-size:18px;">unsubscribe();//当点击按钮进行网络请求时，先取消然后在进行网络请求
        subscription = Network.getGankApi()
                .getBeauties(10, page)
                .map(GankBeautyResultToItemsMapper.getInstance())
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(observer);</span>


map的功能类似下图所示：


下面是Func1的实现类

<span style="font-size:18px;">public class GankBeautyResultToItemsMapper implements Func1<GankBeautyResult, List<Item>> {
    private static GankBeautyResultToItemsMapper INSTANCE = new GankBeautyResultToItemsMapper();

    private GankBeautyResultToItemsMapper() {
    }

    public static GankBeautyResultToItemsMapper getInstance() {
        return INSTANCE;
    }

    @Override
    public List<Item> call(GankBeautyResult gankBeautyResult) {
        List<GankBeauty> gankBeauties = gankBeautyResult.beauties;
        List<Item> items = new ArrayList<>(gankBeauties.size());
        SimpleDateFormat inputFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SS'Z'");
        SimpleDateFormat outputFormat = new SimpleDateFormat("yy/MM/dd HH:mm:ss");
        for (GankBeauty gankBeauty : gankBeauties) {
            Item item = new Item();
            try {
                Date date = inputFormat.parse(gankBeauty.createdAt);
                item.description = outputFormat.format(date);
            } catch (ParseException e) {
                e.printStackTrace();
                item.description = "unknown date";
            }
            item.imageUrl = gankBeauty.url;
            items.add(item);
        }
        return items;
    }
}</span>


http://reactivex.io/documentation/operators/map.html  这篇文章对map进行了介绍。


压合（ZIP）

有时候，app中会需要同时访问不同接口，然后将结果糅合后转为统一的格式后输出。这种并行的异步处理比较麻烦，不过用了zip()之后就会简单得多。

下面是网络请求的代码

 <span style="font-size:18px;">unsubscribe();
        subscription = Observable.zip(Network.getGankApi().getBeauties(200, 1).map(GankBeautyResultToItemsMapper.getInstance()),
                Network.getZhuangbiApi().search("装逼"),
                new Func2<List<Item>, List<ZhuangbiImage>, List<Item>>() {
                    @Override
                    public List<Item> call(List<Item> gankItems, List<ZhuangbiImage> zhuangbiImages) {
                        List<Item> items = new ArrayList<Item>();
                        for (int i = 0; i < gankItems.size() / 2 && i < zhuangbiImages.size(); i++) {
                            items.add(gankItems.get(i * 2));
                            items.add(gankItems.get(i * 2 + 1));
                            Item zhuangbiItem = new Item();
                            ZhuangbiImage zhuangbiImage = zhuangbiImages.get(i);
                            zhuangbiItem.description = zhuangbiImage.description;
                            zhuangbiItem.imageUrl = zhuangbiImage.image_url;
                            items.add(zhuangbiItem);
                        }
                        return items;
                    }
                })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(observer);</span>
zip就是将多个Observable糅合成一个Observable。然后在进行数据的展示。

如下图例所示





Token(flatMap)

多余安全性、性能等方面的考虑，多数服务器会有一些接口需要传入token才能正确返回结果，而token是需要从另一个接口获取的，这就需要使用两步连续的请求才能获取数据。使用flatMap（）可以用较为清晰的代码实现这种连续请求，避免Callback嵌套的结构。


API是这样定义的：

<span style="font-size:18px;">public class FakeApi {
    Random random = new Random();

    public Observable<FakeToken> getFakeToken(@NonNull String fakeAuth) {
        return Observable.just(fakeAuth)
                .map(new Func1<String, FakeToken>() {
                    @Override
                    public FakeToken call(String fakeAuth) {
                        // Add some random delay to mock the network delay
                        int fakeNetworkTimeCost = random.nextInt(500) + 500;
                        try {
                            Thread.sleep(fakeNetworkTimeCost);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }

                        FakeToken fakeToken = new FakeToken();
                        fakeToken.token = createToken();
                        return fakeToken;
                    }
                });
    }

    private static String createToken() {
        return "fake_token_" + System.currentTimeMillis() % 10000;
    }

    public Observable<FakeThing> getFakeData(FakeToken fakeToken) {
        return Observable.just(fakeToken)
                .map(new Func1<FakeToken, FakeThing>() {
                    @Override
                    public FakeThing call(FakeToken fakeToken) {
                        // Add some random delay to mock the network delay
                        int fakeNetworkTimeCost = random.nextInt(500) + 500;
                        try {
                            Thread.sleep(fakeNetworkTimeCost);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }

                        if (fakeToken.expired) {
                            throw new IllegalArgumentException("Token expired!");
                        }

                        FakeThing fakeData = new FakeThing();
                        fakeData.id = (int) (System.currentTimeMillis() % 1000);
                        fakeData.name = "FAKE_USER_" + fakeData.id;
                        return fakeData;
                    }
                });
    }
}</span>


网络请求是这样的：


<strong> </strong> <span style="font-size:18px;">unsubscribe();
        final FakeApi fakeApi = Network.getFakeApi();
        subscription = fakeApi.getFakeToken("fake_auth_code")
                .flatMap(new Func1<FakeToken, Observable<FakeThing>>() {
                    @Override
                    public Observable<FakeThing> call(FakeToken fakeToken) {
                        return fakeApi.getFakeData(fakeToken);
                    }
                })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<FakeThing>() {
                    @Override
                    public void call(FakeThing fakeData) {
                        swipeRefreshLayout.setRefreshing(false);
                        tokenTv.setText(getString(R.string.got_data, fakeData.id, fakeData.name));
                    }
                }, new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        swipeRefreshLayout.setRefreshing(false);
                        Toast.makeText(getActivity(), R.string.loading_failed, Toast.LENGTH_SHORT).show();
                    }
                });</span>

TOKEN_高级（RETRYWHEN）

有的token并非一次性的，而是可以多次使用，直到它超时或被销毁。这样的token处理起来比较麻烦：需要把他保存起来，并且在发现它失效的时候要能够自动重新获取新的token并继续访问之前由于token失效而失败的请求。用传统的Callback请求会写出非常复杂的代码，而RxJava的RetryWhen可以轻松的处理这样的问题。


  <span style="font-size:18px;">final FakeApi fakeApi = Network.getFakeApi();
        subscription = Observable.just(null)
                .flatMap(new Func1<Object, Observable<FakeThing>>() {
                    @Override
                    public Observable<FakeThing> call(Object o) {
                        return cachedFakeToken.token == null
                                ? Observable.<FakeThing>error(new NullPointerException("Token is null!"))
                                : fakeApi.getFakeData(cachedFakeToken);
                    }
                })
                .retryWhen(new Func1<Observable<? extends Throwable>, Observable<?>>() {
                    @Override
                    public Observable<?> call(Observable<? extends Throwable> observable) {
                        return observable.flatMap(new Func1<Throwable, Observable<?>>() {
                            @Override
                            public Observable<?> call(Throwable throwable) {
                                if (throwable instanceof IllegalArgumentException || throwable instanceof NullPointerException) {
                                    return fakeApi.getFakeToken("fake_auth_code")
                                            .doOnNext(new Action1<FakeToken>() {
                                                @Override
                                                public void call(FakeToken fakeToken) {
                                                    tokenUpdated = true;
                                                    cachedFakeToken.token = fakeToken.token;
                                                    cachedFakeToken.expired = fakeToken.expired;
                                                }
                                            });
                                }
                                return Observable.error(throwable);
                            }
                        });
                    }
                })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<FakeThing>() {
                    @Override
                    public void call(FakeThing fakeData) {
                        swipeRefreshLayout.setRefreshing(false);
                        String token = cachedFakeToken.token;
                        if (tokenUpdated) {
                            token += "(" + getString(R.string.updated) + ")";
                        }
                        tokenTv.setText(getString(R.string.got_token_and_data, token, fakeData.id, fakeData.name));
                    }
                }, new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        swipeRefreshLayout.setRefreshing(false);
                        Toast.makeText(getActivity(), R.string.loading_failed, Toast.LENGTH_SHORT).show();
                    }
                });</span>


缓存（BehaviorSubject）

RxJava中有一个很少被人用到的类叫做Subject,它是一种{既是Observable又是Obsver}的东西，因此可以被用做中间件来做数据传递。可以用他的子类BehaviorSubject来进行缓存。

下面是网络请求

  <span style="font-size:18px;">Network.getGankApi()
                .getBeauties(100, 1)
                .subscribeOn(Schedulers.io())
                .map(GankBeautyResultToItemsMapper.getInstance())
                .doOnNext(new Action1<List<Item>>() {
                    @Override
                    public void call(List<Item> items) {
                        Database.getInstance().writeItems(items);
                    }
                })
                .subscribe(new Action1<List<Item>>() {
                    @Override
                    public void call(List<Item> items) {
                        cache.onNext(items);//cache是BehaviorSubject的对象

                    }
                }, new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        throwable.printStackTrace();
                    }
                });</span>


和平world
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Retrofit2和RxJava结合使用例子
11-09
前段时间花了点时间学了一下RxJava和Retrofit2，后面在实践中被没有用到，今天一看，呃，都基本上忘掉了。 在这里总结记录一下。
android——retrofit+rxjava超级详细讲解与使用
weixin_45552475的博客
05-22 7745
在自我学习的过程中，和项目中，使用到了retrofit+rxjava访问接口，记录一下自己的学习过程，可能有不准确或者不到位的地方，请指正，嘻嘻！！！
Retrofit+RxJava原理浅析
wiseyue的博客
04-23 473
Retrofit: 核心：返回一个对象 new ISharedListService() 动态代理：代理所有的。动态生成一个类：一个你对应的.class文件的对象–>反射 代理的是一个object。看不见的类：代理类 拓展类的行为和静态的是一样的 主要方法： invoke。所有对接口类型的方法的调用都会执行到invoke方法里面 代理对象在内存中，而不在外存中。看不见的。所有对接口的调用都会去执行到代理类的invoke函数中。一旦访问到了invoke，就形成了一个功能的拦截 获取到你所有.
RxJava 实例
xiaowang_lj的博客
10-20 530
三种方式：Observable.create、Observable.just、Observable.fromArray@Override}});}使用observer或者subscriber@Override}@Override}@Override}@Override}};特别注意：2种方法的区别，即Subscriber 抽象类与Observer 接口的区别。
RxJava简单示例
yytree123的博客
09-06 727
RxJava - JVM响应式扩展Reactive Extensions 用于使用Java VM的可观察序列编写异步和基于事件的程序的库。 Rxjava由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点。 简单示例： 首先创建一个被观察者Observable，之后创建一个观察者（订阅者），接着建立订阅关系。 public static void main(String[] args) { Observable ob = Observable.create(new
Retrofit源码解读(三)--RxJavaCallAdapterFactory讲解
cpongo5
12-10 215
Retrofit源码解读(三)--RxJavaCallAdapterFactory讲解 标签（空格分隔）：Retrofit源码 前言 以下的相关知识总结是通过慕课网的相关学习和自己的相关看法,如果有需要的可以去查看一下慕课网的相关教学,感觉还可以。 父类 which uses RxJava for creating observables fina...
Retrofit和RxJava结合实现网络请求
03-16
Retrofit和RxJava结合，实现网络请求处理。。。。。。
Retrofit+Rxjava实现文件上传和下载功能
08-28
主要介绍了Retrofit+Rxjava实现文件上传和下载功能，文中提到了单文件上传和多文件上传及相关参数的请求，需要的朋友参考下吧
Retrofit和Rxjava的结合使用
12-29
Retrofit和Rxjava的结合使用，还有Retrofit的单独使用，实际接口演示。封装了Rxjava让代码更加简洁。如果还有不完善的地方希望指出。
Retrofit和Rxjava集成
07-31
Retrofit和Rxjava集成内容，内含代码、依赖、请求方式及相关demo
RxJava之BehaviorSubject使用
09-07
RxJava中BehaviorSubject适合的使用场景代码
RxJava-Android-Samples
02-04
rxAndroid开发实例，RxJava-Android-Samples-master
RxJava+Retrofit+mvp案例
11-25
RxJava+Retrofit+mvp案例
超详细的Rxjava文档（包括Rxjava1,Rxjava2,中文官方文档，实战实例，博客详文等）
03-31
超详细的Rxjava文档（包括Rxjava1,Rxjava2,中文官方文档，实战实例，博客详文等多个pdf）
RxJavaSamples
08-18
RxJava 和 Retrofit 结合使用的几个最常见使用方式举例。 实现最基本的网络请求和结果处理。 把返回的数据转换成更方便处理的格式再交给 Observer。 将不同接口并行请求获取到的数据糅合在一起后再处理。
Retrofit源码解读(三) RxJavaCallAdapterFactory讲解
weixin_34006965的博客
01-03 709
Retrofit源码解读(三)--RxJavaCallAdapterFactory讲解 标签（空格分隔）：Retrofit源码 前言 以下的相关知识总结是通过慕课网的相关学习和自己的相关看法,如果有需要的可以去查看一下慕课网的相关教学,感觉还可以。 父类 which uses RxJava for creating observables final class RxJavaCallAda...
RxJava使用实例——在开发中使用rxjava
家驹六月天的博客
12-09 553
在学习rxjava的过程中，总结了在实际应用中rxjava的运用！下面会将学到的rxjava操作符用于实际运用！ （一）循环+过滤 io.reactivex.Observable.fromIterable(users) .filter(new Predicate<User>() { @Override ...
RxJava简单例子
weixin_53238530的博客
06-22 196
RxJava简单例子 二、构建被观察者 Observable（被观察者）拥有很多工厂方法和各式各样的操作符。每个Observable里面都维护了一个OnSubscribe对象，并通过subscribe()里面的call(Subscriber
rxjava 常用用法实例
p1522780457的博客
12-22 337
具体怎么用我就不说了 你们都懂 我直接上传事例吧 package com.demo.testRxjava; import android.app.Activity; import android.os.Bundle; import android.support.annotation.Nullable; import android.view.View; import com.demo.
Android用okhttp+retrofit+rxjava的例子
最新发布
04-26
好的，以下是一个使用 OkHttp、Retrofit 和 RxJava 的简单 Android 示例。 首先，你需要在你的 build.gradle 文件中添加以下依赖： ``` dependencies { implementation 'com.squareup.okhttp3:okhttp:4.9.1' implementation 'com.squareup.retrofit2:retrofit:2.9.0' implementation 'com.squareup.retrofit2:converter-gson:2.9.0' implementation 'io.reactivex.rxjava2:rxjava:2.2.19' implementation 'io.reactivex.rxjava2:rxandroid:2.1.1' } ``` 这样就可以使用 OkHttp、Retrofit 和 RxJava 的类和方法了。 接下来，你可以在你的代码中定义一个 Retrofit 接口： ``` public interface ApiService { @GET("users/{username}") Observable<User> getUser(@Path("username") String username); } ``` 在这个接口中，我们定义了一个 GET 请求，用于获取一个用户的信息。该请求的 URL 是 "https://api.github.com/users/{username}"，其中 {username} 参数将会被替换为实际的用户名。接口返回的数据类型是 User，这是一个简单的类，如下所示： ``` public class User { public final String login; public final int id; public final String avatarUrl; public final String htmlUrl; public User(String login, int id, String avatarUrl, String htmlUrl) { this.login = login; this.id = id; this.avatarUrl = avatarUrl; this.htmlUrl = htmlUrl; } } ``` 现在，你可以在你的 Activity 或 Fragment 中调用这个接口： ``` ApiService apiService = RetrofitClient.getInstance().create(ApiService.class); apiService.getUser("octocat") .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(user -> { // 在这里处理获取到的用户信息 }, throwable -> { // 在这里处理请求失败的情况 }); ``` 该示例将会获取一个名为 "octocat" 的用户的信息，并在获取到数据后将其打印出来。需要注意的是，这个网络请求是在一个新的线程中执行的，以避免阻塞主线程。获取到数据后，我们转换到主线程中，并在观察者的 onNext 回调中处理数据。如果请求失败，则在观察者的 onError 回调中处理错误情况。 希望这个简单的示例可以帮助你理解如何在 Android 中使用 OkHttp、Retrofit 和 RxJava。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值