安卓之MVP模式

      以前写程序都是MVC模式的，其实安卓自带的就是MVC模式，但现在觉得这种写法在后面随着项目越来越大，Activty或者Fragment中代码也会越来越多，导致项目的维护变的越来越复杂。所以需要另外一种架构模式来解决这个问题，发现适合Android开发的架构模式非MVP莫属了。

1.什么是MVP模式

MVP的M是指模型（model）、V是指视图（view）、P是指主持人（presenter），分别代表不同的模块。

模型（model）：就是处理业务逻辑的一块，进行数据的处理和存储，比如数据库操作，网络下载

视图（view）：是数据显示的一块，与用户进行交互

主持人（presenter）：就是用来连接模型（model）和视图（view）的桥梁，将模型和视图分开出来

       如下图所示，View与Model并不直接交互，而是使用Presenter作为View与Model之间的桥梁。其中Presenter中同时持有Viwe层以及Model层的Interface的引用，而View层持有Presenter层Interface的引用。当View层某个界面需要展示某些数据的时候，首先会调用Presenter层的某个接口，然后Presenter层会调用Model层请求数据，当Model层数据加载成功之后会调用Presenter层的回调方法通知Presenter层数据加载完毕，最后Presenter层再调用View层的接口将加载后的数据展示给用户。这就是MVP模式的整个核心过程。

这样分层的好处就是大大减少了Model与View层之间的耦合度。一方面可以使得View层和Model层单独开发与测试，互不依赖。另一方面Model层可以封装复用，可以极大的减少代码量。当然，MVP还有其他的一些优点，这里不再赘述。下面看下MVP模式在具体项目中的使用。

下面我就通过RxJava、Retrofit一起实现MVP模式

首先我把我们网络数据的实体先写出来

public class UrlBean {
    private boolean error;
    private List<ResultsBean> results;
    public boolean isError() {
        return error;
    }
    public void setError(boolean error) {
        this.error = error;
    }
    public List<ResultsBean> getResults() {
        return results;
    }
    public void setResults(List<ResultsBean> results) {
        this.results = results;
    }
    public static class ResultsBean {
        private String _id;
        private String createdAt;
        private String desc;
        private String publishedAt;
        private String source;
        private String type;
        private String url;
        private boolean used;
        private String who;
        public String get_id() {
            return _id;
        }
        public void set_id(String _id) {
            this._id = _id;
        }
        public String getCreatedAt() {
            return createdAt;
        }
        public void setCreatedAt(String createdAt) {
            this.createdAt = createdAt;
        }
        public String getDesc() {
            return desc;
        }
        public void setDesc(String desc) {
            this.desc = desc;
        }
        public String getPublishedAt() {
            return publishedAt;
        }
        public void setPublishedAt(String publishedAt) {
            this.publishedAt = publishedAt;
        }
        public String getSource() {
            return source;
        }
        public void setSource(String source) {
            this.source = source;
        }
        public String getType() {
            return type;
        }
        public void setType(String type) {
            this.type = type;
        }
        public String getUrl() {
            return url;
        }
        public void setUrl(String url) {
            this.url = url;
        }
        public boolean isUsed() {
            return used;
        }
        public void setUsed(boolean used) {
            this.used = used;
        }
        public String getWho() {
            return who;
        }
        public void setWho(String who) {
            this.who = who;
        }
    }
}

在写一个接口

//这个接口是连接presenter和view
public interface MainView<V> {
    void getDataSuccess(V view);
    void getFailMsg(String s);
    void showLoading();

    void hideLoading();
}

在将model层写出来，该层是通过RxJava和Retrofit封装的，如果对这两个还不了解的同学可以去看我关于 RxJava和Retrofit初级用法的博客

public interface ApiStores {
    //baseUrl
    String API_SERVER_URL = "http://gank.io/api/";
    //   http://gank.io/api/data/休息视频/10/1
    @GET("data/{shiping}/{month}/{day}")
    Observable<UrlBean> getUser(@Path("shiping") String shiping,@Path("month") String month,@Path("day") String day);
}

public class AppClient {
    public static Retrofit mRetrofit;
    public static Retrofit retrofit() {
        if (mRetrofit == null) {
            OkHttpClient.Builder builder = new OkHttpClient.Builder();

            if (BuildConfig.DEBUG) {
                // Log信息拦截器
                HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor();
                loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
                //设置 Debug Log 模式
                builder.addInterceptor(loggingInterceptor);
            }
            OkHttpClient okHttpClient = builder.build();
            mRetrofit = new Retrofit.Builder()
                    .baseUrl(ApiStores.API_SERVER_URL)
                    .addConverterFactory(GsonConverterFactory.create())
                    .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                    .client(okHttpClient)
                    .build();
        }
        return mRetrofit;
    }
}

public abstract class ApiCallback<M> extends Subscriber<M> {
    public abstract void onSuccess(M model);
    public abstract void onFailure(int code, String msg);
    public abstract void onFinish();
    @Override
    public void onError(Throwable e) {
        e.printStackTrace();
        if (e instanceof HttpException) {
            HttpException httpException = (HttpException) e;
            //httpException.response().errorBody().string()
            int code = httpException.code();
            String msg = httpException.getMessage();
            Log.d("asdas","code=" + code);
            if (code == 504) {
                msg = "网络不给力";
            }
            if (code == 502 || code == 404) {
                msg = "服务器异常，请稍后再试";
            }
            onFailure(code, msg);
        } else {
            onFailure(0, e.getMessage());
        }
        onFinish();
    }
    @Override
    public void onNext(M model) {
        onSuccess(model);
    }
    @Override
    public void onCompleted() {
        onFinish();
    }
}

然后再是pesenter层

public class BasePresenter<V> {
    public V view;
    protected ApiStores apiStores;
    private CompositeSubscription mCompositeSubscription;
    public void attachView(V view){
        this.view=view;
        apiStores = AppClient.retrofit().create(ApiStores.class);
    };
    public void detachView() {
        this.view = null;
        onUnsubscribe();
    }
    //RXjava取消注册，以避免内存泄露
    public void onUnsubscribe() {
        if (mCompositeSubscription != null && mCompositeSubscription.hasSubscriptions()) {
            mCompositeSubscription.unsubscribe();
        }
    }
    public void addSubscription(Observable observable, Subscriber subscriber) {
        if (mCompositeSubscription == null) {
            mCompositeSubscription = new CompositeSubscription();
        }
        mCompositeSubscription.add(observable
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(subscriber));
    }
}

public class MainPresenter extends BasePresenter<MainView>{
    public MainPresenter(MainView view) {
       attachView(view);
    }
    public void loadData(String a,String b,String c) {
        view.showLoading();
        addSubscription(apiStores.getUser(a,b,c),
                new ApiCallback<UrlBean>() {
                    @Override
                    public void onSuccess(UrlBean model) {
                        view.getDataSuccess(model);
                    }

                    @Override
                    public void onFailure(int code, String msg) {
                        view.getFailMsg(msg);
                    }

                    @Override
                    public void onFinish() {
                        view.hideLoading();
                    }

                });
    }
}

最后是view层

public class MainActivity extends Activity implements MainView {
    @InjectView(R.id.tv_1)
    TextView text;
    private MainPresenter mainPresenter;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ButterKnife.inject(this);
        mainPresenter=new MainPresenter(this);
        mainPresenter.loadData("休息视频","10","10");
    }

    @Override
    public void getDataSuccess(Object view) {
        //在这里获取数据的对象，加载到界面，这里就不写了
        UrlBean user= (UrlBean) view;
        for (int i=0;i<user.getResults().size();i++){
            Log.e("url",user.getResults().get(i).getUrl().toString());
        }
    }
    @Override
    public void getFailMsg(String s) {
        //错误信息
    }

    @Override
    public void showLoading() {
        //加载动画
    }

    @Override
    public void hideLoading() {
        //取消动画
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (mainPresenter != null) {
            mainPresenter.detachView();
        }
    }
}