首先看下个P层的构造方法
public Presenter(IBaseView mvpView, Class<R> clazz) {
this.mvpView = mvpView;
this.baseModel = new BaseModel(this);
this.clazz = clazz;
}这个泛型R的用处: 就是Retrofit用到的动态代理接口,也就是你们写API的接口,我们把V层传进来,并创建了M层.
再来看看P层的实现接口
public abstract class Presenter<T, R> implements IBasepresenter<T> {
....
}
public interface IBasepresenter<T> {
IBaseModel getModel();//获取modelr层
void accessServer(Map<String, String> map, String url, int flag);//开始进行网络请求
void accessSucceed(T body, int flag);//请求成功
void accessError(int code, String displayMessage, int flag);//请求错误
}当我们想进行请求的时候,我们可以调用presenter.accessServer(...)方法,看一下这个方法的实现
@Override
public void accessServer(Map<String, String> map, String url, int flag) {
R request = NetWorkManager.getRetrofit().create(clazz);
Observable<T> netObservable = getObservable(request, map, url);
if (flag > IS_NOT_NEED_SHOW_DIALOG) {
showProgress();
}
getModel().sendRequestToServer(map, url, netObservable, flag);
}
protected abstract Observable<T> getObservable(R request, Map<String, String> map, String url);
也是相当的简单,我们首先通过retrofit.create方法创建了Api请求类,然后调用P层的getObservable方法获取到我们RxJava的Observable.再判断是否需要展示加载条,最后通过M层进行网络请求.getObservable方法是一个抽象方法,由我们的实现类来操作.
再来看一个model层的sendRequestToServer网络请求方法
@Override
public <T,R> void sendRequestToServer(R request,Map<String, String> map, String url, Observable<T> netObservable, int flag) {
Observable<T> cacheObservable = Observable.create(emitter -> {
Log.e(TAG, "create当前线程:" + Thread.currentThread().getName());
basePresenter.handlerFirstObservable(emitter,request);
});
Disposable subscribe = Observable.concat(cacheObservable, netObservable)
.compose(ResultTransformer.handleResult())
.compose(SchedulerProvider.getInstance().applySchedulers())
.subscribe(t -> {
Log.e(TAG, "subscribe 成功:" + Thread.currentThread().getName());
basePresenter.accessSucceed(t, flag);
}, throwable -> {
Log.e(TAG, "accept : 网络异常: \n");
if (throwable instanceof ApiException) {
basePresenter.accessError(((ApiException) throwable).getCode(), ((ApiException) throwable).getDisplayMessage(), flag);
}
});
basePresenter.addDisposable(subscribe);//把事件添加起来
}首先创建了一个 cacheObservable 其实这个observable可以做很多操作,比如是否用缓存,比如登陆是否要判断Token失效,比如注册成功了我们再进行登陆操作.
就是这么简单,比如我们模拟一个登陆操作,
首先创建一个LogingPresenter
public class LoginPresenter extends Presenter<LoginBean, RequestIn> {
ILoginView mILoginView;
public LoginPresenter(ILoginView iLoginView, Class<RequestIn> clazz) {
super(iLoginView, clazz);
this.mILoginView = iLoginView;
}
@Override
protected Observable<LoginBean> getObservable(RequestIn request, Map<String, String> map, String url) {
return request.logIn(map);
}
@Override
protected void serverResponse(LoginBean body, int flag) {
mILoginView.loginSuccess();
}
@Override
public void showProgress() {
}
@Override
public void hideProgress() {
}
}
public interface RequestIn{
@POST("login")
Observable<LoginBean> logIn(@Body Map<String,String> map);
} 再来看看我们是怎么使用的
public void login(){
Map<String,String> map = new HashMap<>();
map.put("phone","18888888888");
map.put("psw","123456");
LoginPresenter presenter = new LoginPresenter(this, RequestIn.class);
presenter.accessServer(map,"url",1);
}
@Override
public void showNetworkError(int code, String displayMessage, int flag) {
Log.e(TAG,"登陆失败");
}
@Override
public void loginSuccess() {
Log.e(TAG,"登陆成功");
}简简单单的几行代码就实现了我们的登陆操作.
上面也说了我们可以执行先注册,如果注册成功再登陆我们可以在P层
@Override
public void handlerFirstObservable(ObservableEmitter<LoginBean> emitter, RequestIn request) {
super.handlerFirstObservable(emitter, request);
}实现一下这个方法.
就比如上面我们执行的是登陆接口,我们就可以在handlerFirstObservable(...)方法里执行一个注册的Api 如果注册成功了,我们就执行
emitter.onComplete();//执行完这个之后就会执行登陆接口,很方便例如注册失败了,我们可以执行下面代码
emitter.onNext(null);缓存也是一样 ,可以在这个方法里面判断是否有缓存,如果没有我们则可以将缓存添加到内存中,这个就看自己的操作,重写下面方法
@Override
public void hanlerDataRequestSuccess(LoginBean loginBean) {
super.hanlerDataRequestSuccess(loginBean);
//请求成功的数据,可以设置缓存等一些相关操作
}在P层我们也做了反注册代码,你们可以配合自己的BaseActivity进行封闭
void addDisposable(Disposable s) {
if (this.mDisposable == null) {
this.mDisposable = new CompositeDisposable();
}
this.mDisposable.add(s);
}
public void unsubscrible() {
if (this.mDisposable != null && mDisposable.isDisposed()) {
this.mDisposable.dispose();
this.mDisposable = null;
}
}结束