MVP + Retrofit + RxJava 搭建一个基础的Android开发框架

basePresenter 实现

import io.reactivex.disposables.CompositeDisposable;
import io.reactivex.disposables.Disposable;

import java.lang.reflect.ParameterizedType;

//basePresenter 两个泛型，前者为视图的，后者为数据源的
public abstract class basePresenter implements IPresenter {

    protected V mView;//V 泛型变量
    protected M mModel;//M 泛型变量

    // 这是一个集合，用来控制生命周期
    private CompositeDisposable compositeDisposable;

    @SuppressWarnings("unchecked")
    public basePresenter(V mView) {
        this.mView = mView;
        // 保存了上级 View
        try {
            // 一个泛型Model 实例
            ParameterizedType type = (ParameterizedType) getClass().getGenericSuperclass();
            if (type == null) {
                throw new RuntimeException("运行异常，初始化失败: " + getClass().getSimpleName());
            }
            Class classM = (Class) type.getActualTypeArguments()[1];
            this.mModel = (M) classM.getConstructors()[0].newInstance(this);
        } catch (Exception e) {
            e.printStackTrace();
        }
        compositeDisposable = new CompositeDisposable();
    }

    //从子管理传参到这里，再for循环出来数据 给compositeDisposable
    public void addDisposable(Disposable... disposables) {
        if (compositeDisposable == null) {
            return;
        }
        for (Disposable disposable : disposables) {
            compositeDisposable.add(disposable);
        }
    }

    @Override
    public void onDestroy() {
        mView = null;
        if (mModel != null) {
            mModel.onDestroy();//不等于空，就销毁
            mModel = null;
        }
        // 在合适的时机取消未结束的网络请求
        // 取消所有未完成的网络请求
        // 因为视图已经销毁了，如果继续下去，会崩溃
        if (compositeDisposable != null) {
            compositeDisposable.dispose();
            compositeDisposable = null;
        }
    }
}

baseActivity/baseFragment 实现

import android.annotation.SuppressLint;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import androidx.annotation.CallSuper;
import androidx.appcompat.app.AppCompatActivity;
import butterknife.ButterKnife;


public abstract class baseActivity
 extends AppCompatActivity implements IView, InitialPro
 {
    protected P mPresenter;
    protected View mContentView;

    @SuppressLint("InflateParams")
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //Event后，在后台能接到消息; 要用Manager里面的eventMManager
        mPresenter = initPresenter();//被 泛型的某一个Presenter来初始化IPresenter  在Activity中
        mContentView = LayoutInflater.from(this).inflate(getContentViewId(), null, false);
        setContentView(mContentView);
        ButterKnife.bind(this, mContentView);
        initView();
        initData();
    }

    @CallSuper
    protected void initData() {
        mPresenter.initDataReq();
    }

    //解绑
    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (mPresenter != null) {
            mPresenter.onDestroy();
            mPresenter = null;
        }
    }
}

import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import androidx.annotation.CallSuper;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import butterknife.ButterKnife;




public abstract class baseFragment
 extends Fragment  implements IView, InitialPro
 {

    protected P mPresenter;
    protected View mContentView;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mPresenter = initPresenter();//被泛型的某一个Presenter来初始化（引入）IPresenter 在Fragment中
    }

    @Nullable
    @Override
    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        mContentView = inflater.inflate(getContentViewId(), container, false);
        // base View 主要做的，绑定 Presenter，初始化结构，绑定ButterKnife
        // ButterKnife 就是做了一个视图绑定，不用再findviewbyid
        ButterKnife.bind(this, mContentView);
        initView();
        initData();
        return mContentView;
    }

    @CallSuper
    protected void initData() {
        // 可以看到，在View 基类中，视图创建好了之后
        // 会告知Presenter可以准备请求网络数据了
        // 因为如果过早，视图还没创建，如果网络请求好了，那就会崩溃
        // 所以这个时机让Presenter请求网络 哦。明白了。是的。。
        mPresenter.initDataReq();
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        // 在视图销毁时，释放资源
        if (mPresenter != null) {
            // 告知Presenter释放
            mPresenter.onDestroy();
            mPresenter = null;
        }
    }
}

import com.blankj.utilcode.util.GsonUtils;
import com.jakewharton.retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory;
import okhttp3.OkHttpClient;
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;

import java.util.concurrent.TimeUnit;

public class NetManager {
    private static NetManager netManager;
    Retrofit retrofit;

    private NetManager() {
        // 我们使用的是Retrofit代管网络，这是他的初始化方法
        retrofit = new Retrofit.Builder()
                .client(obtainOKHttpClient())
                // 这是基础url,会跟 Service 中的 拼接
                .baseUrl("https://www.7timer.info")
                .addConverterFactory(GsonConverterFactory.create(GsonUtils.getGson()))
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .build();
    }

    private OkHttpClient obtainOKHttpClient() {
        return new OkHttpClient.Builder()
                .callTimeout(10, TimeUnit.SECONDS)
                .connectTimeout(10, TimeUnit.SECONDS)
                .readTimeout(10, TimeUnit.SECONDS)
                .writeTimeout(10, TimeUnit.SECONDS)
                .addInterceptor(new RequestInterceptor(RequestInterceptor.Level.ALL))
                .build();
    }

    public static NetManager getInstance() {
        if (netManager == null) {
            throw new RuntimeException("你还没有初始化 NetManager");
        }
        return netManager;
    }

    // 这两个操作，保证唯一，放到Application中
    // 初始化，单例模式，保证唯一
    public static void init(Context context) {
        netManager = new NetManager();
    }

    // 释放资源
    public static void release() {
        if (netManager != null) {
            netManager.retrofit = null;
            netManager = null;
        }
    }

    public  T bindService(Class targetInterface) {
        return retrofit.create(targetInterface);
    }
}

import io.reactivex.Observable;
import retrofit2.http.GET;
import retrofit2.http.Query;

public interface SampleServices {
    
    @GET("/bin/api.pl")
    Observable getWeather(
            @Query("lon") double lon,
            @Query("lat") double lat,
            @Query("product") String pro,
            @Query("output") String output
    );
}

import cn.lzd.mvp.base.struct.baseModel;
import cn.lzd.mvp.base.struct.IPresenter;
import io.reactivex.Observable;

public class SampleModel extends baseModel {
    public SampleModel(IPresenter mPresenter) {
        super(mPresenter);
    }

    public Observable getWeather() {
        return obtainService().getWeather(
                        113.17,
                        23.09,
                        "astro",
                        "json"
                );
    }
}

import cn.lzd.mvp.base.net.RxUtils;
import cn.lzd.mvp.base.struct.basePresenter;

public class SamplePresenter extends basePresenter {
    public SamplePresenter(SampleActivity mView) {
        super(mView);
    }

    void reqWeather() {
        addDisposable(mModel.getWeather()
                .compose(RxUtils.applySchedulers(mView))
                .subscribe(weatherData -> mView.onReceiveWeatherData(weatherData.getDatas())));
    }
}

@SuppressLint("NonConstantResourceId")
public class SampleActivity extends baseActivity {
    @BindView(R.id.reqResult)
    TextView tvReqResult;
    @BindView(R.id.loadingBG)
    View loadingBG;
    @BindView(R.id.loadingProgress)
    ProgressBar loadingProgress;
    @BindView(R.id.request)
    View request;

    @Override
    public int getContentViewId() {
        return R.layout.activity_sample;
    }

    @Override
    public void initView() {
        super.initView();
        tvReqResult.setMovementMethod(ScrollingMovementMethod.getInstance());
    }

    @OnClick({R.id.request, R.id.loadingBG})
    public void onClick(View view) {
        // 对不同的控件做点击事件处理
        switch (view.getId()) {
            case R.id.request: {
                tvReqResult.setText("");
                view.setEnabled(false);
                mPresenter.reqWeather();
                break;
            }
            case R.id.loadingBG:{
                ToastUtils.showShort("请等待……");
                break;
            }
        }
    }

    void onReceiveWeatherData(List weatherData) {
        StringBuilder stringBuilder = new StringBuilder();
        for (SampleBeans.DayData dayData : weatherData) {
            stringBuilder.append(GsonUtils.toJson(dayData)).append("nn");
        }
        tvReqResult.setText(stringBuilder);
        request.setEnabled(true);
    }

    @Override
    public void showLoading() {
        loadingBG.setVisibility(View.VISIBLE);
        loadingProgress.setVisibility(View.VISIBLE);
    }

    @Override
    public void hideLoading() {
        loadingBG.setVisibility(View.GONE);
        loadingProgress.setVisibility(View.GONE);
    }
}

相关示例代码下载链接：MVP_DEMO