【转载】RxJava2+Retrofit2+OkHttp3的基础、封装和项目中的使用
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了【转载】RxJava2+Retrofit2+OkHttp3的基础、封装和项目中的使用，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含15664字，纯文字阅读大概需要23分钟。
内容图文
前言：
近些年很火的Retrofit+RxJava+OkHttp网络请求框架，功能强大，结构合理，使用简单方便。后面还会给大家发自己整理过的Retrofit和RxJava、RxAndroid和RxBus。希望大家点一下关注，让我这个懒癌患者有动力继续写下去！
本篇分三个部分：基础篇、封装篇和自己项目使用篇，项目是自己公司的APP提取的，文章偏长可以分三部分一点点看，当初看了很多优秀的文章然后自己在整理写在印象笔记中。
感谢大佬们的学习参考文章：
扔物线:http://gank.io/post/560e15be2dca930e00da1083
依然范特西 ：https://www.jianshu.com/p/5bc866b9cbb9
拉丁吴:https://juejin.im/post/580103f20e3dd90057fc3e6d
玉刚说：https://juejin.im/post/5b17560e6fb9a01e2862246f
最新更新：7.11，更新内容是升级版本替换成RxJava2，修改了一些语法。
Github地址：https://github.com/bigeyechou/NetWorkFrame
简单介绍Retrofit、OKHttp和RxJava之间的关系：
- Retrofit：Retrofit是Square公司开发的一款针对Android 网络请求的框架（底层默认是基于OkHttp 实现）。
- OkHttp：也是Square公司的一款开源的网络请求库。
- RxJava ："a library for composing asynchronous and event-based programs using observable sequences for the Java VM"（一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库）。RxJava使异步操作变得非常简单。
各自职责：Retrofit 负责 请求的数据 和 请求的结果，使用 接口的方式 呈现，OkHttp 负责请求的过程，RxJava 负责异步，各种线程之间的切换。
基础篇：
一、Retrofit写一个网络请求：
1.引入Retrofit的包，在build.gradle文件中添加如下配置：
compile 'com.squareup.retrofit2:retrofit:2.3.0'//导入retrofit
compile 'com.google.code.gson:gson:2.6.2'//Gson 库
//下面两个是RxJava 和 RxAndroid
compile 'io.reactivex.rxjava2:rxandroid:2.0.2'
compile 'io.reactivex.rxjava2:rxjava:2.x.y'
compile 'com.squareup.retrofit2:converter-gson:2.3.0'//转换器，请求结果转换成Model
compile 'com.squareup.retrofit2:adapter-rxjava2:2.3.0'//配合Rxjava 使用
2.创建一个Retrofit 实例，并且完成相关的配置：
配置了接口的 BASE_URL 和一个 converter , GsonConverterFactory 是默认提供的 Gson转换器。
public static final String BASE_URL = "https://api.douban.com/v2/movie/";
Retrofit retrofit = new Retrofit.Builder()
.baseUrl(BASE_URL)
.addConverterFactory(GsonConverterFactory.create())
.build();
3.创建一个接口：
定义了一个方法 getTop250 ,使用 get请求方式，加上@GET 标签，标签后面是这个接口的 尾址top250，完整的地址应该是 baseUrl+尾址 ，参数 使用@Query标签，如果参数多的话可以用@QueryMap标 签，接收一个Map。
使用 POST 请求方式时，只需要更改方法定义的标签，用 @POST 标签，参数标签用 @Field 或者 @Body 或者 FieldMap
public interface MovieService {
//获取豆瓣Top250 榜单
@GET("top250")
Call<MovieSubject> getTop250 (@Query("start") int start , @Query("count") int count);
@FormUrlEncoded
@POST(“top250”)
Call<MovieSubject> getTop250 (@Field(“start”) int start , @Field(“count”) int count);
}
使用 POST 方式时需要注意两点：
- 必须加上 @FormUrlEncoded标签，否则会抛异常。
- 必须要有参数，否则会抛异常, 源码抛异常的地方如下：
if (isFormEncoded && !gotField) {
throw methodError("Form-encoded method must contain at least one @Field.");
}
4.用 Retrofit 创建 接口实例 MoiveService 并且调用接口中的方法进行网络请求：
异步方式请求：
//获取接口实例
MovieService movieService = retrofit.create(MovieService.class);
//调用方法得到一个Call
Call<MovieSubject> call = movieService.getTop250(0,20);
//进行网络请求
call.enqueue(new Callback<MovieSubject>() {
@Override
public void onResponse(Call<MovieSubject> call, Response<MovieSubject> response) {
mMovieAdapter.setMovies(response.body().subjects);
mMovieAdapter.notifyDataSetChanged();
}
@Override
public void onFailure(Call<MovieSubject> call, Throwable t) {
t.printStackTrace();
}
});
同步方式请求： 返回一个Response
Response<MovieSubject> response = call.execute();
二，配合RxJava 使用：
- 更改定义的接口，返回值不再是一个 Call ,而是返回的一个 Observble：
public interface MovieService {
//获取豆瓣Top250 榜单
@GET("top250")
Observable<MovieSubject> getTop250(@Query("start") int start, @Query("count")int count);
}
2.创建 Retrofit 的时候添加如下代码：
addCallAdapterFactory(RxJava2CallAdapterFactory.create())
3.添加转换器Converter(将 json 转为 JavaBean)：
addConverterFactory(GsonConverterFactory.create())
举实际项目中使用的例子：
retrofit = new Retrofit.Builder()
.client(okHttpBuilder.build())
.addConverterFactory(GsonConverterFactory.create())
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.baseUrl(BASE_URL)
.build();
4.Activity 或者 Fragment 中传入 DisposableObserver 建立订阅关系：
Subscription subscription = movieService.getTop250(0,20)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new DisposableObserver<MovieSubject>() {
@Override
public void onComplete() {
}
@Override
public void one rror(Throwable e) {
}
@Override
public void onNext(MovieSubject movieSubject) {
mMovieAdapter.setMovies(movieSubject.subjects);
mMovieAdapter.notifyDataSetChanged();
}
});
5.加入RxJava的好处：
- 加入 RxJava 后的网络请求，返回不再是一个 Call ，而是一个 Observable。
- 在Activity / Fragment 中传入一个Subscriber 建立订阅关系，就可以在 onNext 中处理结果了。
- RxJava 的好处是帮我处理 线程之间的切换，我们可以在指定 订阅的在哪个线程，观察在哪个线程。
- 可以 通过操作符 进行数据变换。
- 整个过程都是链式的，简化逻辑。其中FlatMap 操作符 还可以解除多层嵌套的问题。
RxJava 很强大，能帮我处理很多复杂的场景，如果熟练使用的话，那么能提升我们的开发效率。
三，加入 OkHttp 配置：
通过OkHttpClient 可以配置很多东西，比如 链接超时时间，缓存，拦截器 等等。代码如下：
OkHttpClient.Builder builder = new OkHttpClient.Builder();
builder.connectTimeout(DEFAULT_TIME_OUT, TimeUnit.SECONDS);//连接 超时时间
builder.writeTimeout(DEFAULT_TIME_OUT,TimeUnit.SECONDS);//写操作 超时时间
builder.readTimeout(DEFAULT_TIME_OUT,TimeUnit.SECONDS);//读操作 超时时间
builder.retryOnConnectionFailure(true);//错误重连
// 添加公共参数拦截器
BasicParamsInterceptor basicParamsInterceptor = new BasicParamsInterceptor.Builder()
.addHeaderParam(“userName”,"")//添加公共参数
.addHeaderParam(“device”,"")
.build();
builder.addInterceptor(basicParamsInterceptor);
// 创建Retrofit
mRetrofit = new Retrofit.Builder()
.client(builder.build())
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.addConverterFactory(GsonConverterFactory.create())
.baseUrl(ApiConfig.BASE_URL)
.build();
列举项目中用到的如下：
//项目中设置头信息
Interceptor headerInterceptor = new Interceptor() {
@Override
public Response intercept(Chain chain) throws IOException {
Request originalRequest = chain.request();
Request.Builder requestBuilder = originalRequest.newBuilder()
.addHeader("Accept-Encoding", "gzip")
.addHeader("Accept", "application/json")
.addHeader("Content-Type", "application/json; charset=utf-8")
.method(originalRequest.method(), originalRequest.body());
requestBuilder.addHeader("Authorization", "Bearer " + BaseConstant.TOKEN);//添加请求头信息，服务器进行token有效性验证
Request request = requestBuilder.build();
return chain.proceed(request);
}
};
okHttpBuilder.addInterceptor(headerInterceptor);
//项目中创建Retrofit
retrofit = new Retrofit.Builder()
.client(okHttpBuilder.build())
.addConverterFactory(GsonConverterFactory.create())
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.baseUrl(BASE_URL)
.build();
httpService = retrofit.create(HttpService.class);
封装篇
一，创建一个 统一生成接口实例的管理类 RetrofitServiceManager
创建了一个 RetrofitServiceManager 类，该类采用 单例模式，在 私有的 构造方法中，生成了 Retrofit 实例，并配置了OkHttpClient 和一些 公共配置。
提供了一个create（）方法，生成 接口实例，接收 Class泛型。
代码如下：
public class RetrofitServiceManager {
private static final int DEFAULT_TIME_OUT = 5;//超时时间 5s
private static final int DEFAULT_READ_TIME_OUT = 10;
private Retrofit mRetrofit;
private RetrofitServiceManager(){
// 创建 OKHttpClient
OkHttpClient.Builder builder = new OkHttpClient.Builder();
builder.connectTimeout(DEFAULT_TIME_OUT, TimeUnit.SECONDS);//连接超时时间
builder.writeTimeout(DEFAULT_READ_TIME_OUT,TimeUnit.SECONDS);//写操作 超时时间
builder.readTimeout(DEFAULT_READ_TIME_OUT,TimeUnit.SECONDS);//读操作超时时间
<span class="hljs-comment">// 添加公共参数拦截器 </span>
HttpCommonInterceptor commonInterceptor = <span class="hljs-keyword">new</span> HttpCommonInterceptor.Builder()
.addHeaderParams(<span class="hljs-string">"paltform"</span>,<span class="hljs-string">"android"</span>)
.addHeaderParams(<span class="hljs-string">"userToken"</span>,<span class="hljs-string">"1234343434dfdfd3434"</span>)
.addHeaderParams(<span class="hljs-string">"userId"</span>,<span class="hljs-string">"123445"</span>)
.build();
builder.addInterceptor(commonInterceptor);
<span class="hljs-comment">// 创建Retrofit </span>
mRetrofit = <span class="hljs-keyword">new</span> Retrofit.Builder()
.client(builder.build())
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.addConverterFactory(GsonConverterFactory.create())
.baseUrl(ApiConfig.BASE_URL)
.build();
}
private static class SingletonHolder{
private static final RetrofitServiceManager INSTANCE = new RetrofitServiceManager();
}
<span class="hljs-comment">/**
* 获取RetrofitServiceManager
* <span class="hljs-doctag">@return</span>
*/</span>
public static RetrofitServiceManager getInstance(){
return SingletonHolder.INSTANCE;
}
/**
* 获取对应的Service
* @param service Service 的 class
* @param <T>
* @return
*/
public <T> T create(Class<T> service){
return mRetrofit.create(service);
}
}
接口实例Service都可以用这个来生成，代码如下：
mMovieService = RetrofitServiceManager.getInstance().create(MovieService.class);
二，创建接口，通过第一步获取实例
有了可以获取接口实例的方法，然后创建一个接口，代码如下：
public interface MovieService{
//获取豆瓣Top250 榜单
@GET("top250")
Observable<MovieSubject> getTop250(@Query("start") int start, @Query("count") int count);
@FormUrlEncoded
@POST("/x3/weather")
Call<String> getWeather(@Field(“cityId”) String cityId, @Field(“key”) String key);
}
三，创建一个业务Loader ，如XXXLoder,获取Observable并处理相关业务
创建 Loader 的原因：每一个Api 都写一个接口很麻烦，因此就把 请求逻辑 封装在 一个业务Loader 里面，一个 Loader 里面可以处理多个Api 接口。代码如下：
public class MovieLoader extends ObjectLoader {
private MovieService mMovieService;
public MovieLoader(){
mMovieService = RetrofitServiceManager.getInstance().create(MovieService.class);
}
/**
* 获取电影列表
* @param start
* @param count
* @return
*/
public Observable<List<Movie>> getMovie(int start, int count){
return observe(mMovieService.getTop250(start , count)).map(new Func1<MovieSubject, List<Movie>>() {
@Override
public List<Movie> call(MovieSubject movieSubject) {
return movieSubject.subjects;
}
});
}
public Observable<String> getWeatherList(String cityId,String key){
return observe(mMovieService.getWeather(cityId , key)).map(new Func1<String , String>() {
@Override
public String call(String s) {
//可以处理对应的逻辑后在返回
return s;
}
});
}
public interface MovieService{
//获取豆瓣Top250 榜单
@GET(“top250”)
Observable<MovieSubject> getTop250(@Query(“start”) int start, @Query(“count”)int count);
<span class="hljs-meta">@FormUrlEncoded</span>
<span class="hljs-meta">@POST</span>(<span class="hljs-string">"/x3/weather"</span>)
<span class="hljs-function">Call<String> <span class="hljs-title">getWeather</span><span class="hljs-params">(@Field(<span class="hljs-string">"cityId"</span>)</span> String cityId, @<span class="hljs-title">Field</span><span class="hljs-params">(<span class="hljs-string">"key"</span>)</span> String key)</span>;
}
}
创建一个MovieLoader,构造方法中生成了mHttpService，而 Service 中可以定义和业务相关的多个api，比如：例子中的HttpService中，
可以定义和电影相关的多个api,获取电影列表、获取电影详情、搜索电影等api，就不用定义多个接口了。
MovieLoader 是从 ObjectLoader 中继承下来的，ObjectLoader 提取了一些公共的操作。代码如下：
/**
- 将一些重复的操作提出来，放到父类以免Loader 里每个接口都有重复代码
/
public class ObjectLoader {
/* - @param observable
- @param <T>
- @return
*/
protected <T> Observable<T> observe(Observable<T> observable){
return observable
.subscribeOn(Schedulers.io())
.unsubscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread());
}
}
四，Activity/Fragment 中的调用
创建Loader实例：
mMovieLoader = new MovieLoader();
通过Loader 调用方法获取结果,代码如下：
/**
* 获取电影列表
*/
private void getMovieList(){
mMovieLoader.getMovie(0,10).subscribe(new Action1<List<Movie>>() {
@Override
public void call(List<Movie> movies) {
mMovieAdapter.setMovies(movies);
mMovieAdapter.notifyDataSetChanged();
}
}, new Action1<Throwable>() {
@Override
public void call(Throwable throwable) {
Log.e("TAG","error message:"+throwable.getMessage());
}
});
}
五，统一处理结果和错误
1.统一处理请求结果：
现实项目中，所有接口的返回结果都是同一格式，如：
{
"status": 200,
"message": "成功",
"data": {}
}
在请求api 接口的时候，只关心想要的数据，也就上面的 data{ }，其他的东西不太关心，请求失败 的时候可以根据 status 判断进行 错误处理。
包装返回结果：首先需要根据服务端定义的 JSON 结构创建一个 BaseResponse 类，代码如下：
/**
* 网络请求结果 基类
*/
public class BaseResponse<T> {
public int status;
public String message;
public T data;
public boolean isSuccess(){
return status == 200;
}
}
有了统一的格式数据后，我们需要 剥离出data{ }返回给 上层调用者，创建一个 PayLoad 类，代码如下：
/**
* 剥离 最终数据
*/
public class PayLoad<T> implements Func1<BaseResponse<T>{
@Override
public T call(BaseResponse<T> tBaseResponse) {//获取数据失败时，包装一个Fault 抛给上层处理错误
if(!tBaseResponse.isSuccess()){
throw new Fault(tBaseResponse.status,tBaseResponse.message);
}
return tBaseResponse.data;
}
}
PayLoad 继承自 Func1，接收一个BaseResponse<T> , 就是接口返回的 JSON 数据结构，返回的是 T，就是data{ }，判断是否请求成功，请求成功 返回Data，请求失败 包装成一个 Fault 返回给上层统一处理错误。
在Loader类里面获取结果后，通过map 操作符剥离数据。代码如下：
public Observable<List<Movie>> getMovie(int start, int count){
return observe(mMovieService.getTop250(start,count))
.map(new PayLoad<BaseResponse<List<Movie>>());
}
2.统一处理错误：
在PayLoad 类里面，请求失败时，抛出了一个Fault 异常给上层，我在Activity/Fragment 中拿到这个异常，然后判断错误码，进行异常处理。在onError () 中添加。
对应 错误码 处理 相应的错误，代码如下：
public void call(Throwable throwable) {
Log.e("TAG","error message:"+throwable.getMessage());
if(throwable instanceof Fault){
Fault fault = (Fault) throwable;
if(fault.getErrorCode() == 404){
//错误处理
}else if(fault.getErrorCode() == 500){
//错误处理
}else if(fault.getErrorCode() == 501){
//错误处理
}
}
}
六，添加公共参数
实际项目中，每个接口都有一些基本的相同的参数，我们称之为公共参数，比如：userId、userToken、userName、deviceId等等，我们不必每个接口都去写，可以写一个拦截器，在拦截器里面拦截请求，为每个请求都添加相同的公共参数。
拦截器代码如下：
/*
* 拦截器
*
* 向请求头里添加公共参数
*/
public class HttpCommonInterceptor implements Interceptor {
private Map<String,String> mHeaderParamsMap = new HashMap<>();
public HttpCommonInterceptor() {
}
@Override
public Response intercept(Chain chain) throws IOException {
Log.d("HttpCommonInterceptor","add common params");
Request oldRequest = chain.request();
// 添加新的参数，添加到url 中
/*HttpUrl.Builder authorizedUrlBuilder = oldRequest.url().newBuilder()
.scheme(oldRequest.url().scheme())
.host(oldRequest.url().host());*/
<span class="hljs-comment">// 新的请求 </span>
Request.Builder requestBuilder = oldRequest.newBuilder();
requestBuilder.method(oldRequest.method(), oldRequest.body());
<span class="hljs-comment">//添加公共参数,添加到header中 </span>
<span class="hljs-keyword">if</span>(mHeaderParamsMap.size() > <span class="hljs-number">0</span>){
<span class="hljs-keyword">for</span>(Map.Entry<String,String> params:mHeaderParamsMap.entrySet()){
requestBuilder.header(params.getKey(),params.getValue());
}
内容总结
以上是互联网集市为您收集整理的【转载】RxJava2+Retrofit2+OkHttp3的基础、封装和项目中的使用全部内容，希望文章能够帮你解决【转载】RxJava2+Retrofit2+OkHttp3的基础、封装和项目中的使用所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。