MVP+RxAndroid+Retrogit封装的获取网络

这次直接上代码：
代码目录

搭建环境

/*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 +"");
            }
        });

    }

}