这次直接上代码:
代码目录
搭建环境
/*RxJava与RxAndroid的依赖*/
implementation 'io.reactivex.rxjava2:rxandroid:2.0.1'
implementation 'io.reactivex.rxjava2:rxjava:2.1.0'
/*Retrofit与RxAndroid配置依赖*/
implementation 'com.squareup.retrofit2:retrofit:2.3.0'
implementation 'com.squareup.retrofit2:adapter-rxjava2:2.3.0'
/*使Retrofit的转化器自定义完成数据的转化
* 就是我们可以接口中少写一些bean类
* */
implementation 'com.squareup.retrofit2:converter-scalars:+'
/*gson解析*/
implementation 'com.google.code.gson:gson:2.8.1'
1.基类
/**
* Activity基类
* */
public class BaseActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
}
}
/**
* date:2018/12/9
* author:辉(家辉辉辉)
* function:P层基类
*/
public abstract class BaseP<T> {
public T view;
//两个方法,一个绑定,一个解除,解决内存泄漏
public void attach(T view){
this.view = view ;
}
//将P层对象直为空
public void detach(){
this.view = null;
}
}
/**
* V:当前View
* P:当前的Presenter
* 提示:因为每个Activity创建的Pretender,view都不同所以定义泛型
* */
public abstract class BaseMVPActivity<V,T extends BaseP<V>> extends BaseActivity {
public T presenter;
public abstract T initPresenter();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
presenter = initPresenter();
}
@Override
protected void onResume() {
super.onResume();
presenter.attach((V) this);
}
@Override
protected void onDestroy() {
super.onDestroy();
presenter.detach();
}
}
有基类之后呢,去找人继承
实际在Activity中使用
public class MainActivity extends BaseMVPActivity<V,P> {
@Override
public P initPresenter() {
return new P();
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
presenter.getData();
}
}
P层也要继承BaseP
public class P extends BaseP<V> {
private final M mM;
//创建Model
public P() {
mM = new M();
}
//A、Presenter和Model进行交互的操作
public void getData(){
//获取m中的方法
mM.getData();
}
}
我们再看下m层
public class M {
/**
* 有的方法用不到,所以用适配器的设计模式改变
* */
public void getData(){
}
}
**以上就是MVP的封装
**以下开始Retrofit+RxJava的封装
第一步写接口,发现了没有跟我们平常写retrofit的时候不一样因为我们加入了RxJava
/**
* date:2018/12/9
* author:辉(家辉辉辉)
* function:RxAndroid与Retrofit的结晶
*/
public interface ApiService {
/**
* Get的基本请求
* 从Call改为了被观察者observable
* */
@GET
Observable<String> get(@Url String url);
/**
* Get请求提交表单
* 从Call改为了被观察者observable
* */
@GET
Observable<String> get(@Url String url, @QueryMap Map<String,String> map);
/**
* Post请求提交表单
* 从Call改为了被观察者observable
* */
@FormUrlEncoded
@POST
Observable<String> post(@Url String url, @FieldMap Map<String,String> map);
}
第二步写网络工具类
public class RetrofitFactory {
//全局只有一个okhttp对象
public static OkHttpClient sOkHttpClient = new OkHttpClient.Builder()
.connectTimeout(20,TimeUnit.SECONDS)
.readTimeout(20,TimeUnit.SECONDS)
.writeTimeout(20,TimeUnit.SECONDS)
.build();
public static ApiService mApiService = new Retrofit.Builder()
.baseUrl("http://172.17.8.100/small/user/v1/register/")//请求头
//使我们能高度自定义转化器
.addConverterFactory(ScalarsConverterFactory.create())//重要的三步.1
.client(sOkHttpClient)//重要的三步.2
//把 以前的 call 转化成 Observable
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())//重要的三步.3
.build().create(ApiService.class);
public static Observable<String> get(String url){
return mApiService.get(url)
.subscribeOn(Schedulers.io())//被观察者
.observeOn(AndroidSchedulers.mainThread());//观察者
}
public static Observable<String> get(String url, Map<String,String> map){
return mApiService.get(url,map)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread());
}
public static Observable<String> post(String url,Map<String,String> map){
return mApiService.post(url,map)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread());
}
}
第三步使用,但是使用的时候我们会发现观察者有4个方法我们只需要一个所以用一个适配器设计模式改变下
//先写个基类实现接口
/**
* date:2018/12/9
* author:辉(家辉辉辉)
* function:适配器设计模式取我们需要的
*/
public abstract class BaseObserver implements Observer<String> {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String s) {
onSuccess(s);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
public abstract void onSuccess(String str);
}
下面开始在M层使用,我把之前的注释了,让我们更清楚的看到了区别
public class M {
/**
* 有的方法用不到,所以用适配器的设计模式改变
* */
public void getData(){
/* RetrofitFactory.get("").subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String s) {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});*/
RetrofitFactory.get("").subscribe(new BaseObserver() {
@Override
public void onSuccess(String str) {
System.out.println(str +"");
}
});
}
}