版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/u010369338/article/details/70809586
东西不多，甚至说很少，目的并不是把网络请求封装的多么好，功能多么全，而是记录下自己的思路。希望无意中路过的同学看完之后能有些许收获！
请求前驱
HTTPServiceWrapper
响应后驱HTTPCallbackWrapper
1、HTTPCENTER
因为HTTPServiceWrapper的出现，HTTPCENTER又要增加东西了～
/**
* 获取ServiceWrapper单例
* @return
*/
public static HTTPServiceWrapper getWrapper() {
return ServiceWrapperHoler.serviceWrapper;
}
private static class ServiceWrapperHoler {
static HTTPServiceWrapper serviceWrapper = new HTTPServiceWrapper();
}2、HTTPServiceWrapper
请求前驱：我乱叫的。
代码
/**
* @author Lwang
* @time 2017/4/26.
*/
public class HTTPServiceWrapper {
public static HTTPService dmService = HTTPCenter.getService(HTTPCenter.SERVICE);
public static HTTPService toyService = HTTPCenter.getService(HTTPCenter.TOYS_SERVICE);
public void heart(HTTPCallbackWrapper<Heart,DMResponse> httpCallbackWrapper) {
dmService.heart().map(new Function<Heart, Heart>() {
@Override
public Heart apply(@NonNull Heart heart) throws Exception {
return heart;
}
}).compose(httpCallbackWrapper.transformer()).subscribe(httpCallbackWrapper.get());
}
public void toys(int offset,int limit,HTTPCallbackWrapper<TimeLineModel,TOYResponse> httpCallbackWrapper) {
toyService.requestRecommendTimeLine(offset,limit).map(new Function<TimeLineModel, TimeLineModel>() {
@Override
public TimeLineModel apply(@NonNull TimeLineModel timeLineModel) throws Exception {
/**
* 此处还可以取出(例如:登陆信息)另行储存
* token
* secret
*/
return timeLineModel;
}
}).compose(httpCallbackWrapper.transformer()).subscribe(httpCallbackWrapper.get());
}
}把请求时候需要做的琐碎的操作放在了这个包装类里，发送请求时，只需调用HTTPServiceWrapper中的方法即可。
例如:HTTPCenter.getWrapper().toys(0,20,httpCallbackWrapper);
3、HTTPCallbackWrapper 敲黑板！重点！
响应后驱 : 我乱叫的，同时也是重点！
既然是包装类，那么肯定就会有HTTPCallback，否则包装什么？
/**
* @author Lwang
* @time 2017/4/26.
*/
public class HTTPCallBack<T, M> {
/**
* 请求开始
*/
public void onStart() {
}
public void onSuccess(T success) {
}
/**
* 处理由服务器发起的错误
* 401
* 500 ...
*
* @param httpResponse
*/
public void onFail(M httpResponse) {
};
/**
* 处理异常
*
* @param e
*/
public void onError(Throwable e) {
};
}HTTPCallback的泛型
HTTPCallback有两个泛型<T,M>
T为请求成功的泛型。
M为出现错误时的泛型。(为了适应多个Host的情况)
HTTPCallbackWrapper代码
/**
* @author Lwang
* @time 2017/4/26.
*/
public class HTTPCallbackWrapper<T, M> {
private RxAppCompatActivity activity;
private RxFragment fragment;
private HTTPCallBack<T, M> callBack;
private Class clazz;
protected Gson gson = new Gson();
public HTTPCallbackWrapper(RxAppCompatActivity activity, HTTPCallBack<T, M> callBack) {
this.activity = activity;
this.callBack = callBack;
}
public HTTPCallbackWrapper(RxFragment fragment, HTTPCallBack<T, M> callBack) {
this.fragment = fragment;
this.callBack = callBack;
}
public Observer get() {
return new Observer<T>() {
@Override
public void onError(Throwable e) {
try {
if (callBack != null && e != null) {
if (e instanceof HttpException) {
int errorCode = ((HttpException) e).response().code();
switch (errorCode) {
case 401:
M response = gson.fromJson("",getClz());
callBack.onFail(response);
break;
case 500:
break;
default:
}
} else {
//error
callBack.onError(e);
}
} else {
//error
if (callBack != null)
callBack.onError(e);
}
} catch (Exception e1) {
//error
if (callBack != null)
callBack.onError(e);
}
}
@Override
public void onComplete() {
}
@Override
public void onSubscribe(Disposable d) {
if (callBack != null)
callBack.onStart();
}
@Override
public void onNext(T o) {
if (callBack != null)
callBack.onSuccess(o);
}
};
}
public <T> ObservableTransformer<T, T> transformer() {
do {
if (activity != null) {
return getObservableTransformer(activity);
}
if (fragment != null) {
return getObservableTransformer(fragment);
}
} while (false);
return null;
}
@android.support.annotation.NonNull
private <T> ObservableTransformer<T, T> getObservableTransformer(RxAppCompatActivity rxAct) {
return new ObservableTransformer<T, T>() {
@Override
public ObservableSource<T> apply(@NonNull Observable<T> upstream) {
return upstream.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.compose(rxAct.bindToLifecycle());
}
};
}
@android.support.annotation.NonNull
private <T> ObservableTransformer<T, T> getObservableTransformer(RxFragment rxFragment) {
return new ObservableTransformer<T, T>() {
@Override
public ObservableSource<T> apply(@NonNull Observable<T> upstream) {
return upstream.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.compose(rxFragment.bindToLifecycle());
}
};
}
/**
* 通过反射拿到泛型 class
*/
@SuppressWarnings("unchecked")
public Class<M> getClz() {
if (clazz == null) {
clazz = (Class<M>) (((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments()[0]);
}
return clazz;
}
}构造函数中的RxAppCompatActivity和RxFragment
为了支持绑定`RxLifecycle`所以在初始化的时候必须传递进来。
get函数
封装了`RxJava`中的被观察者，在`onError`中处理了服务器发出的错误，和`RxJava`抛出的`Throwable`；
前面说到了`HTTPCallbackWrapper`的两个泛型。重点在`M`。
```
M response = gson.fromJson("", getClz());
```
怎么让onFail返回多种对象呢？
之前我想多个类实现一个接口，之后让`onFail`的参数为此接口，后来想到，如果这样做，调用`onFail`的时候得到的是接口对象，还需要根据`host`来确定对象类型，这样就违背了我的初衷。
所以我想到了继续用泛型，用泛型就涉及到一个问题。
怎么得到泛型的class？
完美解决问题，感兴趣的同学可以查一下反射相关的。
/**
* 通过反射拿到泛型 class
*/
@SuppressWarnings("unchecked")
public Class<M> getClz() {
if (clazz == null) {
clazz = (Class<M>) (((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments()[0]);
}
return clazz;
}封装RxJava的转换ObservableTransformer（transformer函数）
线程切换和RxLifecycle的绑定生命周期每次都会出镜，当然要封装起来啦，我还能怎么办。。。
配合MVP食用,口感更佳哦～