从年前一两个月开始,就开始慢慢接触RxJava+Retrofit,针对以往开发中遇到的情况,慢慢写了一个框架Demo。文章不在进行入门介绍,需要了解的同学,可以查看笔者总结的文章RxJava、Retrofit
分割Response
一般来说,网络请求结果包括以下信息:
{ "message": "操作成功", "code": "1", "object": {} }
我们可以定义一个对象Response
,其中泛型T来表示object
,可能是数组,也可能是对象。code
为1(或者其他值,和后台商议)表示接口调用成功,如:登录成功,注册成功等;code
为其他值,则表示失败,如登录失败等,此时message
便返回对应的错误信息,如密码错误等。
如果返回结果为Response
,则每次网络请求都要判断接口是否调用成功,比较麻烦,我们希望的是:如果接口调用成功,返回泛型T,即object
;如果调用失败,则返回code
、message
信息。因此,需要对返回结果进行分割处理。
分割操作代码如下:
/**
* 对网络接口返回的Response进行分割操作
*
* @param response
* @param
* @return
*/
public Observable flatResponse(final Response response) {
return Observable.create(new Observable.OnSubscribe() {
@Override
public void call(Subscriber super T> subscriber) {
if (response.isSuccess()) {
if (!subscriber.isUnsubscribed()) {
subscriber.onNext(response.object);
}
} else {
if (!subscriber.isUnsubscribed()) {
subscriber.onError(new APIException(response.code, response.message));
}
return;
}
if (!subscriber.isUnsubscribed()) {
subscriber.onCompleted();
}
}
});
}
其中response.isSuccess()
的代码如下:
public boolean isSuccess() {
return code.equals(Constant.OK);
}
通过以上代码,便可实现分割操作,这样每次返回结果都不用通过code
来判断是否成功。
打印请求地址+参数
有些时候,为了方便调试,我们需要将网络请求的地址和参数log出来。由于Retrofit是基于OKHttp的,所以我们需要通过Interceptors来拦截OKHttp来log所需信息。
关于Interceptors,不再多说,直接附上代码。代码来自HttpLoggingInterceptor ,做了简化。
package com.sunflower.rxandroiddemo.utils;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.concurrent.TimeUnit;
import okhttp3.Headers;
import okhttp3.Interceptor;
import okhttp3.MediaType;
import okhttp3.MultipartBody;
import okhttp3.Protocol;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;
import okhttp3.internal.Platform;
import okio.Buffer;
/**
* Created by Sunflower on 2016/1/12.
*/
public class HttpLoggingInterceptor implements Interceptor {
private static final Charset UTF8 = Charset.forName("UTF-8");
public enum Level {
/**
* No logs.
*/
NONE,
/**
* Logs request and response lines.
*
* Example:
* {@code
* --> POST /greeting HTTP/1.1 (3-byte body)
*
* <-- HTTP/1.1 200 OK (22ms, 6-byte body)
* }
*/
BASIC,
/**
* Logs request and response lines and their respective headers.
*
* Example:
* {@code
* --> POST /greeting HTTP/1.1
* Host: example.com
* Content-Type: plain/text
* Content-Length: 3
* --> END POST
*
* <-- HTTP/1.1 200 OK (22ms)
* Content-Type: plain/text
* Content-Length: 6
* <-- END HTTP
* }
*/
HEADERS,
/**
* Logs request and response lines and their respective headers and bodies (if present).
*
* Example:
* {@code
* --> POST /greeting HTTP/1.1
* Host: example.com
* Content-Type: plain/text
* Content-Length: 3
*
* Hi?
* --> END GET
*
* <-- HTTP/1.1 200 OK (22ms)
* Content-Type: plain/text
* Content-Length: 6
*
* Hello!
* <-- END HTTP
* }
*/
BODY
}
public interface Logger {
void log(String message);
/**
* A {@link Logger} defaults output appropriate for the current platform.
*/
Logger DEFAULT = new Logger() {
@Override
public void log(String message) {
Platform.get().log(message);
}
};
}
public HttpLoggingInterceptor() {
this(Logger.DEFAULT);
}
public HttpLoggingInterceptor(Logger logger) {
this.logger = logger;
}
private final Logger logger;
private volatile Level level = Level.BODY;
/**
* Change the level at which this interceptor logs.
*/
public HttpLoggingInterceptor setLevel(Level level) {
if (level == null) throw new NullPointerException("level == null. Use Level.NONE instead.");
this.level = level;
return this;
}
@Override
public Response intercept(Interceptor.Chain chain) throws IOException {
Level level = this.level;
Request request = chain.request();
if (level == Level.NONE) {
return chain.proceed(request);
}
boolean logBody = level == Level.BODY;
boolean logHeaders = logBody || level == Level.HEADERS;
RequestBody requestBody = request.body();
boolean hasRequestBody = requestBody != null;
String requestStartMessage = request.method() + ' ' + request.url();
if (!logHeaders && hasRequestBody) {
requestStartMessage += " (" + requestBody.contentLength() + "-byte body)";
}
logger.log(requestStartMessage);
if (logHeaders) {
if (!logBody || !hasRequestBody) {
logger.log("--> END " + request.method());
} else if (bodyEncoded(request.headers())) {
logger.log("--> END " + request.method() + " (encoded body omitted)");
} else if (request.body() instanceof MultipartBody) {
//如果是MultipartBody,会log出一大推乱码的东东
} else {
Buffer buffer = new Buffer();
requestBody.writeTo(buffer);
Charset charset = UTF8;
MediaType contentType = requestBody.contentType();
if (contentType != null) {
contentType.charset(UTF8);
}
logger.log(buffer.readString(charset));
// logger.log(request.method() + " (" + requestBody.contentLength() + "-byte body)");
}
}
long startNs = System.nanoTime();
Response response = chain.proceed(request);
long tookMs = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startNs);
logger.log(response.code() + ' ' + response.message() + " (" + tookMs + "ms" + ')');
return response;
}
private boolean bodyEncoded(Headers headers) {
String contentEncoding = headers.get("Content-Encoding");
return contentEncoding != null && !contentEncoding.equalsIgnoreCase("identity");
}
private static String protocol(Protocol protocol) {
return protocol == Protocol.HTTP_1_0 ? "HTTP/1.0" : "HTTP/1.1";
}
}
这样在初始化Retrofit时,我们可以通过以下代码来log请求地址+参数
HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor(new HttpLoggingInterceptor.Logger() {
@Override
public void log(String message) {
Log.i("RxJava", message);
}
});
OkHttpClient client = new OkHttpClient.Builder()
//log请求参数
.addInterceptor(interceptor)
.build();
结果如下:
ApiWrapper封装类
对于一个APP来说,我们需要建立一个或者多个接口(我们先分析一个接口的情况,下文用APIService
来替代),里面是相应的网络请求,然而不可能每次请求都初始化一个Retrofit
对象,进而获得APIService
对象,传入对应参数,进行网络请求,处理返回结果。
所以,首先可以新建RetrofitUtil
类,用于初始化操作,网络结果分割操作等等;然后新建ApiWrapper
封装类(继承自RetrofitUtil
)。新建ApiWrapper
封装类有什么好处呢?用代码来说明吧!
比说在APIService
中有这样一个网络请求方法:
@FormUrlEncoded
@POST("api/common/msg.json")
Observable> getSmsCode(@Field("mobile") String mobile, @Field("appType") String appType);
该方法是用来获取短信验证码的,需要传入两个参数:手机号、app类型(医生端or孕妇端)
由于返回结果为验证码,即object
字段为String
类型,所以返回结果是Response
通过ApiWrapper
封装后,代码如下:
public Observable getSmsCode(String mobile) {
return getService().getSmsCode(mobile, "GRAVIDA")
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.flatMap(new Func1, Observable>() {
@Override
public Observable call(Response stringResponse) {
return flatResponse(stringResponse);
}
});
}
其中getService()
为父类RetrofitUtil
中获取APIService
对象的方法。
这样的话,在对应Activity中调用起来就很方便了
ApiWrapper wrapper = new ApiWrapper();
wrapper.getSmsCode(mobile)
.subscribe(new Subscriber() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(String s) {
Log.i(TAG, "call " + s);
}
});
通过以上代码,我们可以发现封装类有以下好处:
- 传递某些固定参数,如上述代码中的
String appType
,或者userId等 - 对网络请求返回结果进行分割操作
- 可以进行线程控制
进一步封装
就只能这样了么?
public Observable getSmsCode(String mobile) {
return getService().getSmsCode(mobile, "GRAVIDA")
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.flatMap(new Func1, Observable>() {
@Override
public Observable call(Response stringResponse) {
return flatResponse(stringResponse);
}
});
}
从这个方法中,我们可以清楚地看到数据是如何在一系列操作符之间进行转换的。但是以后每个网络请求都将进行这样的重复操作。
如何将一组操作符重用于多个数据流中呢?例如,因为希望在工作线程中处理数据,在主线程中处理结果,然后分割网络请求结果。所以我会频繁使用subscribeOn()
、observeOn()
、flatMap()
。如果我能够通过重用的方式,将这种逻辑运用到我所有的数据流中,将是一件多么棒的事。
RxJava提供了一种解决方案:Transformer(有转换器意思),一般情况下可以通过使用操作符Observable.compose()来实现。
Transformer实际上就是一个Func1
,换言之就是:可以通过它将一种类型的Observable转换成另一种类型的Observable,和调用一系列的内联操作符是一模一样的。
/**
* http://www.jianshu.com/p/e9e03194199e
*
*
* @param
* @return
*/
protected Observable.Transformer, T> applySchedulers() {
return new Observable.Transformer, T>() {
@Override
public Observable call(Observable> responseObservable) {
return responseObservable.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.flatMap(new Func1, Observable>() {
@Override
public Observable call(Response tResponse) {
return flatResponse(tResponse);
}
})
;
}
};
}
恩,没错,这一部分内容参考了注释内的链接,大家可以去看下这篇帖子。
通过上面的方法,我们将Observable
转化成了Observable
,并把处理了线程调度、分割返回结果等操作组合了起来,达到了复用的目的。
现在APIService
中getSmsCode()
可简化为:
public Observable getSmsCode(String mobile) {
return getService().getSmsCode(mobile, "GRAVIDA")
.compose(this.applySchedulers());
}
由于要经常调用applySchedulers()
方法,可以考虑创造一个实例化Transformer
,节省不必要的实例化对象。代码如下:
final Observable.Transformer transformer = new Observable.Transformer() {
@Override
public Object call(Object observable) {
return ((Observable) observable).subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.flatMap(new Func1() {
@Override
public Object call(Object response) {
return flatResponse((Response
Note
.flatMap(new Func1() {
@Override
public Object call(Object response) {
return flatResponse((Response
flatResponse()
进行类型强转的话,应该没问题吧?笔者暂时不确定,但目前也没发现什么问题,,,
封装Subscriber
在Activity中我们调用getSmsCode()
代码如下:
ApiWrapper wrapper = new ApiWrapper();
showLoadingDialog();
wrapper.getSmsCode(mobile)
.subscribe(new Subscriber() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(String s) {
Log.i(TAG, "call " + s);
}
});
其实,对于大部分请求来说,我们只需处理onNext()
方法,默认在onCompleted()
方法中hideLoadingDialog()
;在onError()
方法中Toast
对应的错误信息。
所以我们可以进一步封装Subscriber
,代码如下:
/**
* 创建观察者
*
* @param onNext
* @param
* @return
*/
protected Subscriber newSubscriber(final Action1 super T> onNext) {
return new Subscriber() {
@Override
public void onCompleted() {
hideLoadingDialog();
}
@Override
public void onError(Throwable e) {
if (e instanceof RetrofitUtil.APIException) {
RetrofitUtil.APIException exception = (RetrofitUtil.APIException) e;
showToast(exception.message);
} else if (e instanceof SocketTimeoutException) {
showToast(e.getMessage());
} else if (e instanceof ConnectException) {
showToast(e.getMessage());
}
Log.e(TAG, String.valueOf(e.getMessage()));
//e.printStackTrace();
hideLoadingDialog();
}
@Override
public void onNext(T t) {
if (!mCompositeSubscription.isUnsubscribed()) {
onNext.call(t);
}
}
};
}
在onError()
方法中,可以根据Throwable e
的类型进行对应处理,其中APIException
是我们自定义的异常,SocketTimeoutException
、ConnectException
则是OKHttp返回的异常。
在onCompleted()
和onError()
中,我们都需要hideLoadingDialog()
。
在
subscribe()
之后,Observable
会持有Subscriber
的引用,这个引用如果不能及时被释放,将有内存泄露的风险。所以最好保持一个原则:要在不再使用的时候尽快在合适的地方(例如onPause()
、onStop()
等方法中)调用unsubscribe()
来解除引用关系,以避免内存泄露的发生。
我们可以在BaseActivity
中声明一个对象
/**
* 使用CompositeSubscription来持有所有的Subscriptions
*/
protected CompositeSubscription mCompositeSubscription;
在onCreate()
方法中初始化:
mCompositeSubscription = new CompositeSubscription();
在onDestroy()
中unsubscribe()
接触引用关系:
@Override
protected void onDestroy() {
super.onDestroy();
//一旦调用了 CompositeSubscription.unsubscribe(),这个CompositeSubscription对象就不可用了,
// 如果还想使用CompositeSubscription,就必须在创建一个新的对象了。
mCompositeSubscription.unsubscribe();
}
在Activity中调用网络请求时:
Subscription subscription = wrapper.getSmsCode2("15813351726")
.subscribe(newSubscriber(new Action1() {
@Override
public void call(String s) {
Log.i(TAG, "call " + s);
}
}));
mCompositeSubscription.add(subscription);
所以在newSubscriber()
中的onNext()
方法中,我们需要事先判断mCompositeSubscription
是否已经解除了引用。
---20160229更新---
代码地址在RxAndroidDemo
请看下篇RxJava+Retrofit框架Demo(二)