T- MVP在项目中的使用

用了MVP也有一段时间了，最为深的体会就是，写代码的时候，整个思维很清晰，修改需求也变得较为简单，还有一个体会就是，复用性变强了。一开始看着网上的教程，就在项目中用MVP，写了几个界面，发现增加类的量不是一般的多，类一多就会觉得，一点也不简洁；于是，便有了T-MVP。

实现的效果图：

项目结构，大概是这样的：

1、用泛型实现MVP的大瘦身

MVP给人的第一感觉就是要写很多类，很多接口；如果一下基础接口用泛型写，则可以免去重复写接口的繁琐。

• 几个基础接口

public interface EasyOnListener<T> {

    void getSuccess(T T);

    void getFail(T T);
}

public interface IEasyBiz<T> {
    void  getData(Context context, T T,EasyOnListener onListener);
}

public interface IEasyView<T> {

    T getData();

    void getSuccess(int type, T T);

    void getFaild(int type, T T);

    void showLoading();

    void hideLoading();

    void noConnet();

    void isConnect();

}

2、T-MVP的项目使用

Demo中用到的数据接口来自聚合数据提供的免费接口；数据结构大概是这样的：

用Android Studio的GsonFormat可以将Json快速生成实体类；

• 有了接口、实体类，接下来就是请求接口，得到数据，Demo中用到网络请求是Volley，解析Json用的是Gson，代码如下：

public class DataBiz implements IEasyBiz {

    @Override
    public void getData(Context context, Object T, final EasyOnListener onListener) {

        MyJsonObjectRequest json = new MyJsonObjectRequest(BaseMethod.dataUrl, null, new                                    Response.Listener<JSONObject>() {
            @Override
            public void onResponse(JSONObject response) {
                try {
                    if ("200".equals(response.getString("resultcode"))) {
                        Gson gson = new Gson();
                        DataBean dataBean = gson.fromJson(response.toString(), DataBean.class);
                        onListener.getSuccess(dataBean);
                    } else {
                        onListener.getFail(1);
                    }
                } catch (JSONException e) {
                    e.printStackTrace();
                }
            }
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                onListener.getFail(2);
            }
        });
        VolleyController.getInstance(context).addToRequestQueue(json);
    }
}

• 请求网络得到的数据交给Presenter，用泛型的好处在于Model层得到数据交给Presenter层的时候，可以用泛型代替所有的实体类，从而不用每一个界面都写接口，Presenter层的代码如下：

public class DataPresenter {

    private IEasyView iEasyView;
    private DataBiz dataBiz;
    public final static int NOCONNECT = 1;
    public final static int GETFAILED = 2;
    public final static int GETSUCCESS = 1;

    public DataPresenter(IEasyView iEasyView) {
        this.iEasyView = iEasyView;
        this.dataBiz = new DataBiz();
    }

    public void getList(Context context) {

        if (!NetUtils.isNetworkConnected(context)) {
            iEasyView.getFaild(NOCONNECT,null);
            iEasyView.hideLoading();
        } else {
            iEasyView.isConnect();
            iEasyView.showLoading();
            dataBiz.getData(context, iEasyView.getData(), new EasyOnListener() {
                @Override
                public void getSuccess(Object T) {
                    iEasyView.hideLoading();
                    iEasyView.getSuccess(GETSUCCESS, T);
                }
                @Override
                public void getFail(Object T) {
                    iEasyView.hideLoading();
                    int type = (int) T;
                    switch (type){
                        case 1:
                            iEasyView.getFaild(GETFAILED,null);
                            break;
                        case 2:
                            iEasyView.getFaild(NOCONNECT,null);
                            break;
                    }
                }
            });
        }
    }
}

• Presenter层将数据交给View层，让View层做视图加载

public class SimpleRecyclerView extends AppCompatActivity implements IEasyView {

    @Bind(R.id.rv_simple)
    RecyclerView rvSimple;
    @Bind(R.id.ll_noconnect)
    LinearLayout llNoconnect;
    @Bind(R.id.ll_loading)
    LinearLayout llLoading;
    @Bind(R.id.tv_change)
    TextView tvChange;

    private int count = 0;
    private DataPresenter presenter;
    private SimpleAdapter adapter;
    private List<DataBean.ResultBean.FutureBean> mList = new ArrayList<>();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_simple_recycler_view);
        ButterKnife.bind(this);
        setList(0);
        presenter = new DataPresenter(this);
        presenter.getList(this);
    }

    private void setList(int type) {
        if (type == 0) {
            LinearLayoutManager manager = new LinearLayoutManager(this);
            manager.setOrientation(LinearLayoutManager.VERTICAL);
            rvSimple.setLayoutManager(manager);
        } else if (type == 1) {
            GridLayoutManager gridLayoutManager = new GridLayoutManager(this, 2);
            rvSimple.setLayoutManager(gridLayoutManager);
        }
    }

    @Override
    public Object getData() {
        return null;
    }

    @Override
    public void getSuccess(int type, Object T) {
        switch (type) {
            case GETSUCCESS:
                DataBean dataBean = (DataBean) T;
                List<DataBean.ResultBean.FutureBean> list = dataBean.getResult().getFuture();
                mList.addAll(list);
                if (adapter == null) {
                    adapter = new SimpleAdapter(this, mList);
                    rvSimple.setAdapter(adapter);
                } else {
                    adapter.notifyDataSetChanged();
                }
                break;
        }
    }

    @Override
    public void getFaild(int type, Object T) {
        switch (type) {
            case NOCONNECT:
                noConnet();
                break;
            case GETFAILED:
                ToastUtil.showToast(this, "请求数据失败");
                break;
        }
    }

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

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

    @Override
    public void noConnet() {
        llNoconnect.setVisibility(View.VISIBLE);
        ToastUtil.showErro(this);
    }

    @Override
    public void isConnect() {
        llNoconnect.setVisibility(View.GONE);
    }

    @OnClick({R.id.tv_change, R.id.ll_noconnect})
    public void onClick(View view) {
        switch (view.getId()) {
            case R.id.tv_change:
                count++;
                setList(count % 2);
                adapter.notifyDataSetChanged();
                break;
            case R.id.ll_noconnect:
                presenter = new DataPresenter(this);
                presenter.getList(this);
                break;
        }
    }
}

总结

MVP的好处之一就是复用性很高，像获取用户信息这样一个网络请求，在app中肯定有很多处会用到，如果用这种写法，就可以避免每次用到都做网络请求，当然，这只是好处之一。用泛型，能够更加灵活地处理各种情况，也可以减少相当多的类。