RxJava+Retrofit实现全局过期token自动刷新Demo篇_太原达内Web培训
RxJava+Retrofit实现全局过期token自动刷新Demo篇
发布：alighters
来源：alighters
今天太原达内web培训班来为大家介绍一些最新的IT知识来帮大家一起努力，共同进步。
Rxjava+Retrofit 实现全局过期Token 自动刷新中，主讲了实现的思想，发布之后，有些小伙伴抱怨没有完整的 Demo，所以在这里重新补上了一个姗姗来迟的简单的实例。
一个应用的大部分请求都需要一个带有 token 的参数，来表示当前的用户信息;另外 token 是带有有效时间的，当 token 过期时，需要执行刷新 token 的操作。这个解决方案就是针对这种情况而产生的，当一个请求收到 token 过期的错误信息，我们会在底层执行刷新 token 的操作(这个操作是透明操作，对用户不可见)，当 token 刷新成功之后，则重新执行之前发出的请求。
另外，不适用的就是 token 是放在 http 请求的 header 中的请求，这种情况的需要通过使用 okhttp 的拦截器来实现，可自行查阅其他的文章。
1.实现思想
利用 Observale 的 retryWhen 的方法，识别 token 过期失效的错误信息，此时发出刷新 token 请求的代码块，完成之后更新 token，这时之前的请求会重新执行，但将它的 token 更新为最新的。另外通过代理类对所有的请求都进行处理，完成之后，我们只需关注单个 API 的实现，而不用每个都考虑 token 过期，大大地实现解耦操作。
为了保证 Demo 的完整性，API 这个环节是必不可少的，这里允许我偷个小懒，没有采用远程的 API 服务来实现。而是使用 NodeJs 在本地写了个简单的服务，所以小小地辛苦读者多动一下手指头，先启动咱们的 API 服务。 NodeJs代码点我
启动服务 完成的服务器代码在项目的根目录下的 server 文件中，里面包含一个名 refresh_token 的 js 文件。我们切到 server 目录下，在命令行下执行 node refresh_token.js ，就可以启动一个监听端口号为 8888 的服务。 另外，如果在电脑上访问的话，执行 http://127.0.0.1:8888 即可访问;如果通过模拟器访问的话，需要拿到电脑的本地 IP，这里我获取到的是 192.168.56.1。
API 介绍 这里为了模仿真实的 token 原理，我采用时间戳来作为 token 的一种实现。客户端向服务器请求 token, 服务器返回当前的时间戳来作为之后用户每次的请求则需要携带这个 token 作为参数，服务器拿到客户端发送过来的 token，来与当前的时间进行比较，这里我使用的时间间隔为30秒，若小于30秒，服务器认为 token 合法，返回正确结果;若大于30秒，则认为 token 失效。
实现 这里我设计了三个 API，获取 token 的 get_token 及刷新 token 的 refresh_token ，简单起见，它俩不需要参数，并且返回的结果相同;另外一个正常请求的 API 是 request ，它需要传递一个名称为 token 的参数。代码很简单，如下：
var http = require('http');
var url = require('url');
var querystring = require('querystring');
http.createServer(function (request, response) {
// 发送 HTTP 头部
// HTTP 状态值: 200 : OK
// 内容类型: text/plain
response.writeHead(200, {'Content-Type': 'text/plain'});
var pathname = url.parse(request.url).
if (pathname == "/get_token" || pathname ==
"/refresh_token"){
// get a new token or refresh the token
var result = {
"success" : true,
"data" : {
"token" : new Date().getTime().toString()
response.end(JSON.stringify(result));
}else if (pathname == "/request"){
// Normal request
var token_str =
querystring.parse(url.parse(request.url).query)['token'];
if (token_str){
var token_time = parseFloat(token_str);
var cur_time = new Date().getTime();
if(cur_time - token_time & 30 * 1000){
var result = {
"success" : true,
"data" : {
"result" : true
response.end(JSON.stringify(result));
response.end(JSON.stringify({"success": false,
"error_code" : 1001}));
response.end(JSON.stringify({"success": false,
"error_code" : 1000}));
}).listen(8888);
代码很简单，需要提及的是当 token 超过限定的30秒，返回的 error_code 是 1001;而 token 不存在则返回的 error_code 是 1000，这时我们可能需要做的操作就是重新登录的操作等等。
3.错误抛出
当服务器错误信息的时候，同样也是一个 model，不同的是 success 为 false，并且含有 error_code的信息。所以我们需要针对 model 处理的时候，做以判断。主要修改的地方就是 retrofit 的 GsonConvertFactory ，这里不再通过 gradle 引入，直接把其源码中的三个文件添加到咱们的项目中。
首先提及的一下是对统一 model 的封装，如下：
public class ApiModel {
@SerializedName("error_code") public int errorC
当正确返回的时候，我们获取到 data，直接给上层;当出错的时候，可以针对 errorCode的信息，做一些处理，让其走最上层调用的 onError 方法。
好了，说说我们这里要修改的地方：
1.修改 GsonConverterFactory 中，生成 GsonResponseBodyConverter 的方法：
public Converter responseBodyConverter(final Type type, Annotation[]
annotations, Retrofit retrofit) {
Type newType = new ParameterizedType() {
public Type[] getActualTypeArguments() {
return new Type[] { type };
public Type getOwnerType() {
public Type getRawType() {
return ApiModel.
TypeAdapter adapter = gson.getAdapter(TypeToken.get(newType));
return new GsonResponseBodyConverter&&(adapter);
可以看出我们这里对 type 类型，做以包装，让其重新生成一个类型为 ApiModel 的新类型。因为我们在写接口代码的时候，都以真正的类型 type 来作为返回值的，而不是 ApiModel。
2.GsonResponseBodyConverter的处理 它的修改，则是要针对返回结果，做以异常的判断并抛出，主要看其的 convert 方法：
public Object convert(ResponseBody value) throws IOException {
ApiModel apiModel = (ApiModel) adapter.fromJson(value.charStream());
if (apiModel.errorCode == ErrorCode.TOKEN_NOT_EXIST) {
throw new TokenNotExistException();
} else if (apiModel.errorCode == ErrorCode.TOKEN_INVALID) {
throw new TokenInvalidException();
} else if (!apiModel.success) {
// TODO: 16/8/21 handle the other error.
} else if (apiModel.success) {
return apiModel.
} finally {
value.close();
4.添加代理
在使用 Retrofit 的时候，我们都需要针对每个 API 编写相应的接口代码，最后通过 Retrofit 的 create 方法来实现调用，而这个方法就是通过使用代理，根据这个接口方法的各种注解参数，最后一个个单独的完整的 API 调用。
因为我们也需要对每个 API 做处理，所以我们也对它的 create 方法做一个代理的实现，主要使用的代码是 Proxy 类的 newProxyInstance 方法。
public T getProxy(Class tClass) {
T t = getRetrofit().create(tClass);
return (T) Proxy.newProxyInstance(tClass.getClassLoader(), new
Class[] { tClass }, new ProxyHandler(t));
核心的代理实现则是这个 ProxyHandler ，它是对接口 InvocationHandler 的一个实现类。思想就是针对 method 的调用，做以 retryWhen 的包装，在retryWhen 中获取相应的异常信息来做处理，看 retryWhen 的代码：
retryWhen(new Func1&OBSERVABLE, Observable&() {
public Observable call(Observable observable) {
return observable.flatMap(new Func1&() {
public Observable call(Throwable throwable) {
if (throwable instanceof TokenInvalidException) {
return refreshTokenWhenTokenInvalid();
} else if (throwable instanceof TokenNotExistException) {
Toast.makeText(BaseApplication.getContext(), "Token is not
existed!!", Toast.LENGTH_SHORT).show();
return Observable.error(throwable);
return Observable.error(throwable);
这里针对 token 过期的 TokenInvalidException 的异常，执行刷新 token 的操作，刷新 token 的操作则是直接调用 Retrofit 的方法，而不需要走代理了。另外它必须是个同步的代码块，主要的代码就不在这里贴了，具体的代码见 这里 。
5.代码验证
最上层的代码调用中，添加了两个按钮: + 按钮1：获取token
@OnClick(R.id.btn_token_get)
public void onGetTokenClick(View v) {
RetrofitUtil.getInstance()
.get(IApiService.class)
.getToken()
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Subscriber() {
public void onCompleted() {
public void onError(Throwable e) {
public void onNext(TokenModel model) {
if (model != null && !TextUtils.isEmpty(model.token)) {
GlobalToken.updateToken(model.token);
token 获取成功之后，仅仅更新一下全局的token即可。
按钮2：正常的请求
这里为了模拟多请求，这里我直接调正常的请求5次：
@OnClick(R.id.btn_request)
public void onRequestClick(View v) {
for (int i = 0; i & 5; i++) {
RetrofitUtil.getInstance()
.getProxy(IApiService.class)
.getResult(GlobalToken.getToken())
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Subscriber() {
public void onCompleted() {
public void onError(Throwable e) {
public void onNext(ResultModel model) {
为了查看输出，另外对 Okhttp 添加了 HttpLoggingInterceptor 并设置 Body 的 level 输出，用来监测 http 请求的输出。
一切完成之后，先点击获取 token 的按钮，等待30秒之后，再点击正常请求按钮。可以看到如下的输出：
--& GET http://192.168.56.1:8888/request?token=4
--& END GET
--& GET http://192.168.56.1:8888/request?token=4
--& END GET
--& GET http://192.168.56.1:8888/request?token=4
--& END GET
--& GET http://192.168.56.1:8888/request?token=4
--& END GET
--& GET http://192.168.56.1:8888/request?token=4
--& END GET
&-- 200 OK http://192.168.56.1:8888/request?token=4
Content-Type: text/plain
Date: Mon, 22 Aug :09 GMT
Connection: keep-alive
Transfer-Encoding: chunked
{"success":false,"error_code":1001}
&-- END HTTP (35-byte body)
&-- 200 OK http://192.168.56.1:8888/request?token=4
&-- 200 OK http://192.168.56.1:8888/request?token=4
Content-Type: text/plain
Date: Mon, 22 Aug :09 GMT
Connection: keep-alive
Transfer-Encoding: chunked
--& GET http://192.168.56.1:8888/refresh_token http/1.1
--& END GET
{"success":false,"error_code":1001}
&-- END HTTP (35-byte body)
Content-Type: text/plain
Date: Mon, 22 Aug :09 GMT
Connection: keep-alive
Transfer-Encoding: chunked
&-- 200 OK http://192.168.56.1:8888/request?token=4
Content-Type: text/plain
Date: Mon, 22 Aug :09 GMT
Connection: keep-alive
{"success":false,"error_code":1001}
Transfer-Encoding: chunked
&-- END HTTP (35-byte body)
{"success":false,"error_code":1001}
&-- END HTTP (35-byte body)
&-- 200 OK http://192.168.56.1:8888/refresh_token (2ms)
Content-Type: text/plain
&-- 200 OK http://192.168.56.1:8888/request?token=4
Date: Mon, 22 Aug :09 GMT
Content-Type: text/plain
Date: Mon, 22 Aug :09 GMT
Connection: keep-alive
Connection: keep-alive
Transfer-Encoding: chunked
Transfer-Encoding: chunked
{"success":true,"data":{"token":"6"}}
&-- END HTTP (49-byte body)
{"success":false,"error_code":1001}
&-- END HTTP (35-byte body)
roxy: Refresh token success, time = 7
--& GET http://192.168.56.1:8888/request?token=6
--& GET http://192.168.56.1:8888/request?token=6
--& END GET
--& END GET
--& GET http://192.168.56.1:8888/request?token=6
--& GET http://192.168.56.1:8888/request?token=6
--& END GET
--& END GET
--& GET http://192.168.56.1:8888/request?token=6
--& END GET
&-- 200 OK http://192.168.56.1:8888/request?token=6
Content-Type: text/plain
Date: Mon, 22 Aug :09 GMT
Connection: keep-alive
Transfer-Encoding: chunked
{"success":true,"data":{"result":true}}
&-- END HTTP (39-byte body)
&-- 200 OK http://192.168.56.1:8888/request?token=6
&-- 200 OK http://192.168.56.1:8888/request?token=6
Content-Type: text/plain
Date: Mon, 22 Aug :09 GMT
Connection: keep-alive
Transfer-Encoding: chunked
{"success":true,"data":{"result":true}}
&-- END HTTP (39-byte body)
Content-Type: text/plain
Date: Mon, 22 Aug :09 GMT
Connection: keep-alive
Transfer-Encoding: chunked
&-- 200 OK http://192.168.56.1:8888/request?token=6
Content-Type: text/plain
Date: Mon, 22 Aug :09 GMT
Connection: keep-alive
Transfer-Encoding: chunked
{"success":true,"data":{"result":true}}
&-- END HTTP (39-byte body)
&-- 200 OK http://192.168.56.1:8888/request?token=6
Content-Type: text/plain
Date: Mon, 22 Aug :09 GMT
Connection: keep-alive
Transfer-Encoding: chunked
{"success":true,"data":{"result":true}}
&-- END HTTP (39-byte body)
{"success":true,"data":{"result":true}}
&-- END HTTP (39-byte body)
刚发出的5个请求都返回了 token 过期的 error，之后看到一个重新刷新 token 的请求，它成功之后，原先的5个请求又进行了重试，并都返回了成功的信息。一切圆满。
好了，今天就给大家讲这么多吧，喜欢我的内容可以关注或者分享（微信公众平台：tytedu）选择，不再孤军奋战，轻轻松松做IT高薪白领。太原达内培训带领有明确目标的学子迈向成功之路!
之前有人问过我一个问题：实习期间最大的收获是什么?
APP产品能不能做好，取决于很多因素，而一个完善的开发过程往往能够帮助你做出精致赏心的产品。
作为一个h5设计师，要想有好的设计，就要一击即中用户的要害，达到我们要用的营销目的。
作为一名web前端初学者来说会遇到很多奇葩的问题，今天太原web前端培训机构就来助你一臂之力。
Copyright (C)
All Rights Reserved
选择城市和中心
达内北京亦庄大学生实训基地
达内北京网络营销中心
达内北京会计中心当你的才华还撑不起你的梦想时，你只能一直前进！
一、写在前面
　　相信各位看官对retrofit和rxjava已经耳熟能详了，最近一直在学习retrofit+rxjava的各种封装姿势，也结合自己的理解，一步一步的做起来。
　　骚年，如果你还没有掌握retrofit和rx两大框架，那你是真的out了！
　　如果你对Rxjava不熟悉，请先看扔物线的，超详细；
　　如果你只是想了解retrofit的简单使用，你可以看我另外一篇博客（仅仅是简单使用），，详情请查看官网：。
二、基本使用
　　好了，就不多BB了，直接进入正题。下面是我用retrofit和rxjava步步深入的封装方法。
　　1、首先依赖，别忘了添加网络访问权限。
dependencies {
compile fileTree(include: ['*.jar'], dir: 'libs')
androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
exclude group: 'com.android.support', module: 'support-annotations'
compile 'com.android.support:appcompat-v7:25.0.1'
testCompile 'junit:junit:4.12'
compile 'com.squareup.retrofit2:retrofit:2.1.0'
compile 'io.reactivex:rxandroid:1.2.1'
// Because RxAndroid releases are few and far between, it is recommended you also
// explicitly depend on RxJava's latest version for bug fixes and new features.
compile 'io.reactivex:rxjava:1.1.6'
compile 'com.google.code.gson:gson:2.8.0'
compile 'com.squareup.retrofit2:converter-gson:2.1.0'
compile 'com.squareup.retrofit2:adapter-rxjava:2.1.0'
　　2、先来一个retrofit的简单访问请求，这里采用本人开源的毕业设计上的一个api接口做测试，返回数据格式为：也就是一个code,msg,data的方式。
　　3、按照retrofit的官方方式，写上一个接口，用于定义子目录和方法
* 使用普通的retrofit方式获取数据
@GET("ezSQL/get_user.php")
Call&BaseResponse&List&UserModel&&& getUsers();
　　4、然后直接访问如下
Retrofit retrofit = new Retrofit.Builder()
.baseUrl(Consts.APP_HOST)
.addConverterFactory(GsonConverterFactory.create())
ApiService apiService = retrofit.create(ApiService.class);
apiService.getUsers().enqueue(new Callback&BaseResponse&List&UserModel&&&() {
public void onResponse(Call&BaseResponse&List&UserModel&&& call, Response&BaseResponse&List&UserModel&&& response) {
showToast("成功:" + response.body().data.toString());
Log.e(TAG, "成功:" + response.body().data.toString());
Log.e(TAG, "retCode:" + response.code() + ",msg：" + response.message());
mTextView.setText("成功:" + response.body().data.toString());
public void onFailure(Call&BaseResponse&List&UserModel&&& call, Throwable t) {
showToast("失败:" + t.getMessage());
Log.e(TAG, "失败:" + t.getMessage());
mTextView.setText("失败:" + t.getMessage());
　　5、如果用rx的方式为：
* 使用rx+retrofit获取数据
* 【subscribeOn和observeOn区别】
* 1、subscribeOn用于切换之前的线程
* 2、observeOn用于切换之后的线程
* 3、observeOn之后，不可再调用subscribeOn切换线程
* &&&&&&&&
下面是来自扔物线的额外总结 &&&&&&&&&&&&
* 1、下面提到的&操作&包括产生事件、用操作符操作事件以及最终的通过 subscriber 消费事件
* 2、只有第一subscribeOn() 起作用（所以多个 subscribeOn() 毛意义）
* 3、这个 subscribeOn() 控制从流程开始的第一个操作，直到遇到第一个 observeOn()
* 4、observeOn() 可以使用多次，每个 observeOn() 将导致一次线程切换()，这次切换开始于这次 observeOn() 的下一个操作
* 5、不论是 subscribeOn() 还是 observeOn()，每次线程切换如果不受到下一个 observeOn() 的干预，线程将不再改变，不会自动切换到其他线程
* @param view
public void btnClick1(View view) {
Retrofit retrofit = new Retrofit.Builder()
.baseUrl(Consts.APP_HOST)
.addConverterFactory(GsonConverterFactory.create())
.addCallAdapterFactory(RxJavaCallAdapterFactory.create())
ApiService apiService = retrofit.create(ApiService.class);
Observable&BaseResponse&List&UserModel&&& observable = apiService.getUsersByRx();
observable
.subscribeOn(Schedulers.io())
// 网络请求切换在io线程中调用
.unsubscribeOn(Schedulers.io())// 取消网络请求放在io线程
.observeOn(AndroidSchedulers.mainThread())// 观察后放在主线程调用
.subscribe(new Subscriber&BaseResponse&List&UserModel&&&() {
public void onCompleted() {
public void onError(Throwable e) {
showToast("rx失败:" + e.getMessage());
Log.e(TAG, "rx失败:" + e.getMessage());
mTextView.setText("rx失败:" + e.getMessage());
public void onNext(BaseResponse&List&UserModel&& listBaseResponse) {
showToast("rx成功:" + listBaseResponse.data.toString());
mTextView.setText("rx成功:" + listBaseResponse.data.toString());
Log.e(TAG, "rx成功:" + listBaseResponse.data.toString());
　　6、其中BaseResponse是我们的统一的返回格式封装，采用泛型。　
1 package com.nanchen.retrofitrxdemoo.
3 import com.google.gson.annotations.SerializedN
5 import java.io.S
* 获取json数据基类
* @author nanchen
* @fileName RetrofitRxDemoo
* @packageName com.nanchen.retrofitrxdemoo
16 public class BaseResponse&T& implements Serializable{
@SerializedName("code")
public int
@SerializedName("msg")
@SerializedName("data")
1 package com.nanchen.retrofitrxdemoo.
4 import java.io.S
* @author nanchen
* @fileName RetrofitRxDemoo
* @packageName com.nanchen.retrofitrxdemoo
13 public class UserModel implements Serializable {
public String toString() {
return "UserModel{" +
"username='" + username + '\'' +
", password='" + password + '\'' +
三、开始封装
　　可以看到传统的retrofit，不管采用callback，还是rx方式，重复代码都太多。如果不做一个封装，那每一次网络访问都要做四步操作的话，那必须得折腾死人。如果你不嫌麻烦，那没事，你可以下班了，当我没说。
　　我相信大多数人都是想做一下封装的，所以我们仔细观察一下上面，的确有很多地方是可以直接封装的。比如初始化retrofit，rx的线程切换等等。
　　别急，我们一步一步来！
　　1、首先写一个util类，这里我们采用单例方式；　
public class RetrofitUtil {
public static final int DEFAULT_TIMEOUT = 5;
private Retrofit mR
private ApiService mApiS
private static RetrofitUtil mI
* 私有构造方法
private RetrofitUtil(){
OkHttpClient.Builder builder = new OkHttpClient.Builder();
builder.connectTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS);
mRetrofit = new Retrofit.Builder()
.client(builder.build())
.baseUrl(Consts.APP_HOST)
.addConverterFactory(GsonConverterFactory.create())
.addCallAdapterFactory(RxJavaCallAdapterFactory.create())
mApiService = mRetrofit.create(ApiService.class);
public static RetrofitUtil getInstance(){
if (mInstance == null){
synchronized (RetrofitUtil.class){
mInstance = new RetrofitUtil();
* 用于获取用户信息
* @param subscriber
public void getUsers(Subscriber&BaseResponse&List&UserModel&&& subscriber){
mApiService.getUsersByRx()
.subscribeOn(Schedulers.io())
.unsubscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(subscriber);
　　2、可以看到有了这个Util，那我们在Activity中调用就简单了。
RetrofitUtil.getInstance().getUsers(new Subscriber&BaseResponse&List&UserModel&&&() {
public void onCompleted() {
public void onError(Throwable e) {
showToast("rx失败:" + e.getMessage());
Log.e(TAG, "rx失败:" + e.getMessage());
mTextView.setText("rx失败:" + e.getMessage());
public void onNext(BaseResponse&List&UserModel&& listBaseResponse) {
showToast("rx成功:" + listBaseResponse.data.toString());
mTextView.setText("rx成功:" + listBaseResponse.data.toString());
Log.e(TAG, "rx成功:" + listBaseResponse.data.toString());
　　3、可以看到的确让整个过程简单一些了，但似乎我们的确经常关注的是返回的数据，也就是onNext方法，而onCompleted和onError两个方法则调用较少，那么我们再把这两个方法做统一处理，并且我们一般网络访问都会用到加载对话框，加强用户交互性，遇到error的时候直接显示message即可。所以我们不妨把对话框显示也封装一下。
　　　　a)　　首先写一个对话框退出接口，供后面调用　　
1 package com.nanchen.
* @author nanchen
* @fileName RetrofitRxDemoo
* @packageName com.nanchen.retrofitrxdemoo
10 public interface ProgressCancelListener {
void onCancelProgress();
　　　　b)　　我们这里采用Handler的方式显示和隐藏加载对话框
1 package com.nanchen.
3 import android.app.ProgressD
4 import android.content.C
5 import android.content.DialogI
6 import android.os.H
7 import android.os.M
* @author nanchen
* @fileName RetrofitRxDemoo
* @packageName com.nanchen.retrofitrxdemoo
16 public class ProgressDialogHandler extends Handler {
public static final int SHOW_PROGRESS_DIALOG = 1;
public static final int DISMISS_PROGRESS_DIALOG = 2;
private ProgressD
private boolean
private ProgressCancelListener mProgressCancelL
public ProgressDialogHandler(Context context, ProgressCancelListener mProgressCancelListener,
boolean cancelable) {
this.context =
this.mProgressCancelListener = mProgressCancelL
this.cancelable =
private void initProgressDialog(){
if (pd == null) {
pd = new ProgressDialog(context);
pd.setCancelable(cancelable);
if (cancelable) {
pd.setOnCancelListener(new DialogInterface.OnCancelListener() {
public void onCancel(DialogInterface dialogInterface) {
mProgressCancelListener.onCancelProgress();
if (!pd.isShowing()) {
pd.show();
private void dismissProgressDialog(){
if (pd != null) {
pd.dismiss();
pd = null;
public void handleMessage(Message msg) {
switch (msg.what) {
case SHOW_PROGRESS_DIALOG:
initProgressDialog();
case DISMISS_PROGRESS_DIALOG:
dismissProgressDialog();
　　c)　　既然我们只关注onNext数据，所以把它提取出来，做成一个接口，以便于我们在Activity或者fragment中对数据进行操作，由于我们数据类型未知，所以这里也传入一个泛型。
1 package com.nanchen.
* @author nanchen
* @fileName RetrofitRxDemoo
* @packageName com.nanchen.retrofitrxdemoo
10 public interface SubscriberOnNextListener&T& {
void onNext(T t);
　　d)　　来到重头戏，我们为Subscriber写一个子类，让其实现对话框的退出方法。因为Subscriber比Observer（正常情况下都会被转换为Subscriber，详情请看源代码）会多一个onStart方法，我们可以在onStart中调用对话框显示，在onComplete方法中调用对话框的隐藏方法。
1 package com.nanchen.
3 import android.content.C
4 import android.widget.T
6 import java.net.ConnectE
7 import java.net.SocketTimeoutE
9 import rx.S
* @author nanchen
* @fileName RetrofitRxDemoo
* @packageName com.nanchen.retrofitrxdemoo
19 public class ProgressSubscriber&T& extends Subscriber&T& implements ProgressCancelListener{
private SubscriberOnNextListener&T& mL
private Context mC
private ProgressDialogHandler mH
public ProgressSubscriber(SubscriberOnNextListener&T& listener, Context context){
this.mListener =
this.mContext =
mHandler = new ProgressDialogHandler(context,this,true);
private void showProgressDialog(){
if (mHandler != null) {
mHandler.obtainMessage(ProgressDialogHandler.SHOW_PROGRESS_DIALOG).sendToTarget();
private void dismissProgressDialog(){
if (mHandler != null) {
mHandler.obtainMessage(ProgressDialogHandler.DISMISS_PROGRESS_DIALOG).sendToTarget();
mHandler = null;
* 订阅开始时调用
* 显示ProgressDialog
public void onStart() {
super.onStart();
showProgressDialog();
public void onCompleted() {
dismissProgressDialog();
Toast.makeText(DemoApplication.getAppContext(),"获取数据完成！",Toast.LENGTH_SHORT).show();
public void onError(Throwable e) {
if (e instanceof SocketTimeoutException) {
Toast.makeText(DemoApplication.getAppContext(), "网络中断，请检查您的网络状态", Toast.LENGTH_SHORT).show();
} else if (e instanceof ConnectException) {
Toast.makeText(DemoApplication.getAppContext(), "网络中断，请检查您的网络状态", Toast.LENGTH_SHORT).show();
Toast.makeText(DemoApplication.getAppContext(), "error:" + e.getMessage(), Toast.LENGTH_SHORT).show();
dismissProgressDialog();
public void onNext(T t) {
if (mListener != null){
mListener.onNext(t);
public void onCancelProgress() {
if (!this.isUnsubscribed()){
this.unsubscribe();
　　e)　　为了让大家可以测试代码，所以我这里把api接口换为天狗网的健康菜谱。返回格式为
　　f)　　由于这个返回格式和我的毕设的返回格式不一样，所以，我们重写一个TngouResponse类，这里就不贴代码了。
　　g)　　我们仔细观察上面的封装Util，发现我们的线程切换其实也是可以封装成一个单独的方法的，这样又可以降低代码的耦合了。所以完整的ProgressSubscriber类为：
1 package com.nanchen.
3 import android.content.C
4 import android.widget.T
6 import java.net.ConnectE
7 import java.net.SocketTimeoutE
9 import rx.S
* @author nanchen
* @fileName RetrofitRxDemoo
* @packageName com.nanchen.retrofitrxdemoo
19 public class ProgressSubscriber&T& extends Subscriber&T& implements ProgressCancelListener{
private SubscriberOnNextListener&T& mL
private Context mC
private ProgressDialogHandler mH
public ProgressSubscriber(SubscriberOnNextListener&T& listener, Context context){
this.mListener =
this.mContext =
mHandler = new ProgressDialogHandler(context,this,true);
private void showProgressDialog(){
if (mHandler != null) {
mHandler.obtainMessage(ProgressDialogHandler.SHOW_PROGRESS_DIALOG).sendToTarget();
private void dismissProgressDialog(){
if (mHandler != null) {
mHandler.obtainMessage(ProgressDialogHandler.DISMISS_PROGRESS_DIALOG).sendToTarget();
mHandler = null;
* 订阅开始时调用
* 显示ProgressDialog
public void onStart() {
super.onStart();
showProgressDialog();
public void onCompleted() {
dismissProgressDialog();
Toast.makeText(DemoApplication.getAppContext(),"获取数据完成！",Toast.LENGTH_SHORT).show();
public void onError(Throwable e) {
if (e instanceof SocketTimeoutException) {
Toast.makeText(DemoApplication.getAppContext(), "网络中断，请检查您的网络状态", Toast.LENGTH_SHORT).show();
} else if (e instanceof ConnectException) {
Toast.makeText(DemoApplication.getAppContext(), "网络中断，请检查您的网络状态", Toast.LENGTH_SHORT).show();
Toast.makeText(DemoApplication.getAppContext(), "error:" + e.getMessage(), Toast.LENGTH_SHORT).show();
dismissProgressDialog();
public void onNext(T t) {
if (mListener != null){
mListener.onNext(t);
public void onCancelProgress() {
if (!this.isUnsubscribed()){
this.unsubscribe();
　　h)　　现在，我们发现在activity或fragment中调用网络数据其实就是这么简单！
SubscriberOnNextListener mListener = new SubscriberOnNextListener&TngouResponse&List&Cook&&&() { @Override public void onNext(TngouResponse&List&Cook&& listTngouResponse) { mTextView.setText(listTngouResponse.tngou.toString()); showToast(listTngouResponse.tngou.toString()); } };
RetrofitUtil.getInstance().getCookList(2,5,new ProgressSubscriber&TngouResponse&List&Cook&&&(mListener,this));
四、写在最后
　　本次retrofit和rxjava的简单封装就到这里了，虽然讲解质量有待提高，不过楼主依赖打算分享给大家，代码地址：
　　另外楼主近期在开源android各种实用开源控件，希望大家多多支持：
　　最后的最后，楼主如果空出了足够的时间，一定会出一款retrofit的封装框架的，望大家持续关注~
阅读(...) 评论()
写不完的矫情，做不完的开源
优美钢琴曲合集-南尘.mp3　　　　　　　　　　　　　　　　　　　　感谢您阅读我的博客，如果您现在工作、学习累了或者疲惫了，不妨聆听一下音乐，它能够减轻你的疲劳，还能够带给您一种舒适愉悦的心情。（样式取自博客园-欲泪成雪）}