东西不多,甚至说很少,目的并不是把网络请求封装的多么好,功能多么全,而是记录下自己的思路。希望无意中路过的同学看完之后能有些许收获!
请求前驱
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
食用,口感更佳哦~