登录注册
最新博客
最新资源下载
Retrofit + OkHttp +RxJava 网络库构建及项目实践（下篇）
达芬奇密码2018-07-13 17:253、简便的调用方式（满足微服务多域名BaseUrl等）：
因为项目后台采用微服务，每个模块的接口域名都不一样，即BaseUrl有多个，所以这里需要创建多个Retrofit对象，并通过注解的方式，拿到develop(开发环境) alpha（测试环境）online(正式环境下配置的域名)
1）示例1 ActionCommon.java:
@HOST(develop = API.Helper.HTTPS_PREFIX + API.Helper.HOST_APP_DEVELOP,
alpha = API.Helper.HTTPS_PREFIX + API.Helper.HOST_APP_ALPHA,
online = API.Helper.HTTPS_PREFIX + API.Helper.HOST_APP_ONLINE)
public interface ActionCommon {
@GET("ooxx/user/userInfo.do")
Observable<StatusResponse<UserInfoResponse>> getUserInfo();
@GET("ooxx/index.do")
Observable<StatusResponse<HallResponse>> hallIndex();
@GET("/user/ooxx/list.do")
Observable<StatusResponse<BaseListResponse<ListEntity>>> getList(@QueryMap Map<String, String> map);
@GET("/user/ooxx/detail.do")
Observable<StatusResponse<DetailEntity>> getDetail(@QueryMap Map<String, String> map);
}
上面的注解HOST配置为这几个接口对应的微服务的域名，分别为develop(开发环境) alpha（测试环境）online(正式环境）下配置的域名)。
2）示例2 ActionBonus.java:
@HOST(develop = API.Helper.HTTPS_PREFIX + API.Helper.HOST_BONUS_DEVELOP,
alpha = API.Helper.HTTPS_PREFIX + API.Helper.HOST_BONUS_ALPHA,
online = API.Helper.HTTPS_PREFIX + API.Helper.HOST_BONUS_ONLINE)
public interface ActionBonus {
@GET("/bonus/list.do")
Observable<StatusResponse<BonusResponse>> list(@QueryMap Map<String, String> map);
}
3）API.java:
public class API {
/**
* 主站服务
*/
public final static ActionCommon ACTION_COMMON = OKHttpClientUtils.createService(ActionCommon.class);
/**
* 红包服务
*/
public final static ActionBonus ACTION_BONUS = OKHttpClientUtils.createService(ActionBonus.class);
/**
* 用户服务
*/
public final static ActionUser ACTION_USER = OKHttpClientUtils.createService(ActionUser.class);
public static class Helper {
/**
* 主站服务
*/
static final String HOST_APP_DEVELOP = "develop.app." + DEVELOP_DOMAIN;
static final String HOST_APP_ALPHA = "test.app." + ALPHA_DOMAIN;
static final String HOST_APP_ONLINE = "app." + ONLINE_DOMAIN;
/**
* 红包服务
*/
static final String HOST_BONUS_DEVELOP = "develop.rp." + DEVELOP_DOMAIN;
static final String HOST_BONUS_ALPHA = "test.rp." + ALPHA_DOMAIN;
static final String HOST_BONUS_ONLINE = "bonus." + ONLINE_DOMAIN;
....
}
}
createService中所做操作:
public static <T> T createService(Class<T> clazz) {
Retrofit retrofit =
new Retrofit.Builder()
.client(sOkHttpClient)
.baseUrl(getAndroidHost(clazz))
.addConverterFactory(sStringConverterFactory)
.addConverterFactory(sGsonConverterFactory)
.addCallAdapterFactory(sRXJavaCallAdapterFactory)
.build();
return retrofit.create(clazz);
}
/**
* 获取host retrofit2 baseUrl 需要以 "/" 结尾
*/
public static <T> String getAndroidHost(Class<T> clazz) {
HOST host = clazz.getAnnotation(HOST.class);
String trueHost;
try {
if (MiscUtils.isDevelop(sContext)) {
// 开发环境
trueHost = host.develop();
} else if (MiscUtils.isAlpha(sContext)) {
// 测试环境
trueHost = host.alpha();
} else {
// 线上环境
trueHost = host.online();
}
} catch (Exception e) {
// 有异常默认返回线上地址
e.printStackTrace();
trueHost = host.online();
}
return trueHost + "/";
}
下面看个具体调用实例：
API.ACTION_COMMON = OKHttpClientUtils.createService(ActionCommon.class);
public static Observable<StatusResponse<DetailEntity>> getDetail(String pid, String Id) {
Map<String, String> params = new HashMap<String,String>();
// Map<String,String> params=new HashMap<String, String>();
params.put("pid",pid);
params.put("id",Id);
return API.ACTION_COMMON.getDetail(params)
.compose(new MapTransformer<DetailEntity>());
}
getDetail(pid，id).subscribe(new BaseSubscriber<StatusResponse<DetailEntity>>(this){
@Override
public void onNext(StatusResponse<DetailEntity> data) {
DetailEntity detailEntity=data.getResult();
...
}
@Override
protected void onError(ApiException ex) {
...
}
});
通过getDetail(pid，id) 即可完成该接口的网络请求。当然上述的compose方法只是目前项目中比较普遍的调用方式，如果你在拿到Observable>需要进行其他的map flatmap等操作的话，可以自己实现对应方法的调用，不过需要处理MapTransformer中对服务器错误码自定义异常的处理操作，即（只是举个示例）
API.ACTION_COMMON.getDetail(params).subscribeOn(Schedulers.io())
.map(new ServerResultFunc<T>())
...
.map(...)
...
.flatMap(...)
.onErrorResumeNext(new HttpResultFunc<StatusResponse<T>>())
.observeOn(AndroidSchedulers.mainThread());4.Cookie本地保存及请求时添加统一处理
new OkHttpClient.Builder().cookieJar(new CommonCookieJar())
public static class CommonCookieJar implements CookieJar {
@Override
public void saveFromResponse(HttpUrl url, List<Cookie> cookies) {
Log.v("OKHttpClientUtils", "response cookieHeader---->" + cookies);
CookieHelper.saveCookies(cookies);
}
@Override
public List<Cookie> loadForRequest(HttpUrl url) {
Log.v("OKHttpClientUtils", "requestCookie---->" +
CookieHelper.getCookieHeader(url.uri()));
return CookieHelper.getCookieHeader(url.uri());
}
}
getCookie():
Cookie.Builder build = new Cookie.Builder();
build.name(savedCookieName);
build.value(sp.getString(savedCookieName));
build.domain(API.Helper.getCurrentDomain(context.getAppContext()));
List.add(build.build())
...
saveCookie():
SharedPreference.putString(cookieName,cookieValue);
...
说明： saveFromResponse(HttpUrl url, List cookies) 中 通过CookieHelper.saveCookies(cookies), 将后台接口返回的cookie保存在本地，并每次更新（客户端本地加了一个cookie的白名单列表，只有在白名单中,才会将对应cookie存储在本地） loadForRequest(HttpUrl url)中，调用CookieHelper.getCookieHeader(url.uri())，这里主要是将本地数据如token id等数据 构造成Retrofit2的Cookie，然后组装成List，在loadForRequest时传给后台服务器。
5.通过拦截器实现get及post请求的公共参数及Header的统一添加
公共参数和Header的统一添加，是通过OKHttp的拦截器实现。拦截器是OKHttp提供的一种强大的机制,可以监视、重写和重试调用。很多功能比如缓存数据，接口请求的加密解密等，均可以通过拦截器实现。其基础概念和用法可以参考：Okhttp-wiki 之 Interceptors 拦截器
new OkHttpClient.Builder().addInterceptor(new CommonAppInterceptor());
public static class CommonAppInterceptor implements Interceptor {
@Override
public Response intercept(Chain chain) throws IOException {
String token = null;
try {
token =
SharedPrefsManager.getInstance(BaseApplication.getContext()).getString(SharedPre
fsManager.TOKEN);
} catch (BaseException e) {
e.printStackTrace();
}
Request request = chain.request();
Request.Builder newBuilder = request.newBuilder();
// get请求
if (request.method().equals("GET")) {
// GET 请求
HttpUrl.Builder builder = request.url().newBuilder();
builder.setQueryParameter("t", StringUtil.random());
if (token != null) {
builder.setQueryParameter(AuthProxy.Token, token);
}
HttpUrl httpUrl = builder.build();
newBuilder.url(httpUrl);
} // post请求
else if (request.method().equals("POST")) {
//Form表单
if (request.body() instanceof FormBody) {
FormBody.Builder bodyBuilder = new FormBody.Builder();
FormBody oldFormBody = (FormBody) request.body();
//把原来的参数添加到新的构造器，（因为没找到直接添加，所以就new新的）
for (int i = 0; i < oldFormBody.size(); i++) {
bodyBuilder.addEncoded(oldFormBody.encodedName(i), oldFormBody.encodedValue(i));
}
bodyBuilder.addEncoded("t", StringUtil.random());
if (token != null) {
bodyBuilder.addEncoded(AuthProxy.TOKEN, token);
}
newBuilder.post(bodyBuilder.build());
}
//MultipartBody
else if (request.body() instanceof MultipartBody) {
MultipartBody.Builder multipartBuilder = new
MultipartBody.Builder().setType(MultipartBody.FORM);
List<MultipartBody.Part> oldParts = ((MultipartBody)
request.body()).parts();
if (oldParts != null && oldParts.size() > 0) {
for (MultipartBody.Part part : oldParts) {
multipartBuilder.addPart(part);
}
}
multipartBuilder.addFormDataPart("t", StringUtil.random());
if (token != null) {
multipartBuilder.addFormDataPart(AuthProxy.TOKEN, token);
}
newBuilder.post(multipartBuilder.build());
}
}
//公共Header的统一添加
Header[] headers = new Header[]{HeaderManager.getUAHeader(sContext),
HeaderManager.getModifiedUAHeader(sContext)};
for (Header head : headers) {
newBuilder.addHeader(head.getName(), head.getValue());
}
request = newBuilder.build();
//The network interceptor's Chain has a non-null Connection that can be used to interrogate
// the IP address and TLS configuration that were used to connect to the webserver.
//应用拦截器的chain.connection(), request.headers() 为空，网络拦截器不为空
long t1 = System.nanoTime();
Log.d("OKHttpClientUtils", String.format("CommonAppInterceptor---->Sending request
%s on %s%n%s",request.url(), chain.connection(), request.headers()));
Response response = chain.proceed(request);
long t2 = System.nanoTime();
Log.d("OKHttpClientUtils", String.format("CommonAppInterceptor---->Received response
for %s in %.1fms%n%s",response.request().url(), (t2 - t1) / 1e6d,
response.headers()));
return response;
}
}
get请求比较简单，就是将公共请求参数加入到请求的url中，这里是通过request.url().newBuilder().setQueryParameter(key，value)的方式添加，而不是addQueryParameter,add的话，如果外部调用时也有加这个参数，就会出现请求参数添加了多个的情况，而set的话，可以直接替换（替换是不会造成问题的）。
Post请求需要区分几种情况，看是以表单提交方式FormBody（目前项目post请求基本是这种），还是以MultipartBody（上传文件，图片等比较常用），当然如果还有其他提交方式，比如流数据提交，也是可以在拦截器统一处理的，因为项目暂未用到，这里不再赘述（当然这种情况比较少见，也可以在外部调用时由调用者自行添加而不是在拦截器中统一添加）。
添加公共Hearder Request.newBuilder().addHeader(key,value);
6.如何优雅地取消网络请求回调的全局处理
作为Android开发者比较容易碰到的一个问题就是，在一个页面比如Actiivty,如果这个页面还在进行网络请求，但是用户又要退出这个页面，那么该如何取消这个网络请求呢，其实一般来说，异步操作一旦进行，是无法取消的，所以我们这里只是取消网络请求回调，而不是取消网络请求。RxJava的订阅机制可以通过Subscription.unsubscribe取消订阅，来取消网络请求回调，这样就不会出现网络请求正在进行，页面销毁，请求完成回调到OnNext或onError（UI线程），造成空指针或内存泄漏的问题。
基本思路就是，全局单例中，有个Map> Tag可以理解为各个页面，List为每个页面里网络请求的订阅关系，在该页面销毁时，遍历List，如果Subscription还未被取消订阅，就执行取消订阅操作
上文提到过的BaseSubscriber
public abstract class BaseSubscriber<T> extends Subscriber<T> {
public BaseSubscriber(CustomContext tag) {
SubscriptionManager.getInstance().add(tag, this);
}
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
if (e instanceof ApiException) {
...相关处理
}
onError((ApiException) e);
} else {
onError(new ApiException(e, ERROR.UNKNOWN));
Log.i("network", "onError-otherError->" + e.toString());
}
Crashlytics.logException(e);
Log.e("network", "exception-->" + e.toString());
}
/**
* 错误回调
*/
protected abstract void onError(ApiException ex);
}
构造函数中 添加 SubscriptionManager.getInstance().add(tag, this);
public interface ISubscription<T> {
void add(T tag, Subscription subscription);
void remove(T tag);
void removeAll();
void cancel(T tag);
void cancelAll();
String getName(T tag);
}
public class SubscriptionManager<T> implements ISubscription<T> {
private Map<Object, List<Subscription>> mMap = new HashMap<>();
private static SubscriptionManager sSubscriptionManager;
public SubscriptionManager() {
}
public static synchronized SubscriptionManager getInstance() {
if (sSubscriptionManager == null) {
sSubscriptionManager = new SubscriptionManager();
}
return sSubscriptionManager;
}
@Override
public void add(T tag, Subscription subscription) {
List<Subscription> perPageList = mMap.get(tag);
if (perPageList == null) {
perPageList = new ArrayList<>();
mMap.put(tag, perPageList);
}
perPageList.add(subscription);
mMap.put(tag, perPageList);
}
@Override
public void remove(T tag) {
if (!mMap.isEmpty()) {
List<Subscription> perPageList = mMap.get(tag);
if (perPageList != null && perPageList.size() > 0) {
mMap.remove(tag);
}
}
}
@Override
public void removeAll() {
if (!mMap.isEmpty()) {
mMap.clear();
}
}
@Override
public void cancel(T tag) {
if (!mMap.isEmpty()) {
List<Subscription> perPageList = mMap.get(tag);
if (perPageList != null && perPageList.size() > 0) {
for (Subscription subscription : perPageList) {
if (subscription != null && !subscription.isUnsubscribed()) {
subscription.unsubscribe();
}
}
Log.d("SubscriptionManager","tag--->"+tag);
Log.d("SubscriptionManager","perPageList--->"+perPageList.size());
mMap.remove(tag);
}
}
}
@Override
public void cancelAll() {
if (!mMap.isEmpty()) {
Set<Object> keys = mMap.keySet();
for (Object apiKey : keys) {
cancel((T)apiKey);
}
}
}
@Override
public String getName(T tag) {
return tag.getClass().getName();
}
}
网络请求调用即为
public static Observable<StatusResponse<BaseListResponse<ResultListEntity>>>
getResultList(String offset, String pageSize) {
Map<String, String> params = new HashMap<String,String>();
params.put("offset", offset);
params.put("pageSize", pageSize);
return API.ACTION.getResultList(params)
.compose(new MapTransformer<BaseListResponse<ResultListEntity>>());
}
getResultList(mOffset, String.valueOf(DEFAULT_PAGE_SIZE)).subscribe(
new BaseSubscriber<StatusResponse<BaseListResponse<ResultListEntity>>>(this) {
@Override
protected void onError(ApiException ex) {
onDataFail(ex);
}
@Override
public void onNext(StatusResponse<BaseListResponse<ResultListEntity>> data) {
onDataSuccess(data.getResult());
}
});
在BaseActivity的onDestroy()，BaseFragment的OnDestroyView()中调用SubscriptionManager.getInstance().cancel(this);即可。 其中，上文中的CustomContext 可以理解为任意的一个接口，BaseActivity BaseFragment BaseContentView(自定义View)等，所有需要全局取消网络请求的类，均需要实现这个接口。实现该接口的类，需要在其生命周期结束时，执行SubscriptionManager.getInstance().cancel(this)；进行订阅关系的判断和取消订阅操作。
结语:
本文主要讲述在使用Retrofit和RxJava做网络请求库时，从基础网络配置，通用实体定义，Cookie相关处理，调用方式优化，服务器错误码及自定义异常的全局处理，公共请求参数Header的统一添加，全局取消网络请求回调等项目实践中容易遇到的问题的一些解决方案。还有其他如添加缓存，接口加密解密等比较常见的场景后续可以扩展。
因时间关系文章难免有疏漏，欢迎提出指正，谢谢。同时对RxJava和Retrofit感兴趣的童鞋可以参考以下链接：
3、Okhttp-wiki 之 Interceptors 拦截器
相关阅读：Retrofit + OkHttp +RxJava 网络库构建及项目实践（上篇）
本文来自网易实践者社区，经作者朱强龙授权发布。
分享至：
