Android MVP架构模式简单示例

原文：https://blog.csdn.net/uyy203/article/details/78950718

MVP架构的概念

MVP(Model-View-Presenter)是从经典的模式MVC演变而来的，它们的基本思想有相通的地方：Controller/Presenter负责逻辑的处理，Model提供数据，View负责显示。作为一种新的模式，MVP与MVC有着一个重大的区别：在MVP中View并不直接使用Model，它们之间的通信是通过Presenter (MVC中的Controller)来进行的，所有的交互都发生在Presenter内部，而在MVC中View会直接从Model中读取数据而不是通过 Controller。

image

View： 对应于Activity，负责View的绘制以及与用户交互
Model： 依然是业务逻辑和实体模型
Presenter： 负责完成View于Model间的交互

View不直接与Model交互，而是通过与Presenter交互来与Model间接交互。
Presenter与View的交互是通过接口来进行的。
通常View与Presenter是一对一的，但复杂的View可能绑定多个Presenter来处理逻辑。

MVP架构模式的简单实践

Version实体类

public class Version implements Serializable{
    //是否有新版本
    private String hasNewVersion;
    //新版本名
    private String versionName;
    //最新版本号
    private String versionCode;

    public void setHasNewVersion(String hasNewVersion) {
        this.hasNewVersion = hasNewVersion;
    }

    public String getHasNewVersion() {
        return hasNewVersion;
    }

    public String getVersionName() {
        return versionName;
    }

    public void setVersionName(String versionName) {
        this.versionName = versionName;
    }

    public String getVersionCode() {
        return versionCode;
    }

    public void setVersionCode(String versionCode) {
        this.versionCode = versionCode;
    }
}

主界面有两个TextView，一个用于显示版本名，一个用于显示版本号，还有一个按钮，点击按钮会触发请求，代码如下：

public class MvpActivity extends AppCompatActivity implements VersionView {

    private TextView versionName;
    private TextView versionCode;
    private VersionPresenter mVersionPresenter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_mvp);
        versionName = (TextView) findViewById(R.id.version_name);
        versionCode = (TextView) findViewById(R.id.version_code);
        mVersionPresenter = VersionPresenter.getInstance(this);

        findViewById(R.id.button).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                mVersionPresenter.getNewVersion(getApplicationContext(), "local-url");
            }
        });
    }

    @Override
    public void showVersionNameAndDesc(Version version) {
        versionName.setText("最新版本名：" + version.getVersionName());
        versionCode.setText("最新版本号：" + version.getVersionCode());
    }

    @Override
    public void showToast(String msg) {
        Toast.makeText(getApplicationContext(), msg, Toast.LENGTH_LONG).show();
    }
}

该Activity实现了VersionView接口，这就是mvp中的view层，用于跟用户交互，显示数据。我们可以看到VersionPresenter的初始化，VersionPresenter属于presenter层，用于处理view与model层的通信，不让view直接操作model，可见用户点击按钮后，就通知VersionPresenter去获取版本信息，至于如何获取版本信息，presenter层会交给对应的model去进行处理，下面是VersionPresenter的代码：

public class VersionPresenter extends IPresenter {
    private static VersionPresenter mVersionPresenter;
    private VersionModel mVersionModel;
    private VersionView mVersionView;

    private VersionPresenter(IView view){
        this.mVersionView = (VersionView) view;
        this.mVersionModel = new VersionModel();
    }

    public static VersionPresenter getInstance(VersionView view){
        if (mVersionPresenter == null){
            synchronized (VersionPresenter.class){
                if (mVersionPresenter == null){
                    mVersionPresenter = new VersionPresenter(view);
                }
            }
        }
        return mVersionPresenter;
    }

    //获取版本信息
    public void getNewVersion(final Context context, String url){
        mVersionModel.getNewVersion(url, new VersionModel.VersionCallback() {
            @Override
            public void onVersionCallback(final Version version) {
                ((Activity)context).runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        mVersionView.showVersionNameAndDesc(version);
                        if (version.getHasNewVersion().equals("true")){
                            mVersionView.showToast("App有新版本,请更新");
                        }
                    }
                });

            }
        });
    }

}

用户通知presenter后，presenter就把view的需求通知model层，数据操作交给model层去做具体实现，可以见到在VersionPresenter的getNewVersion方法中只是把view传过来的参数给到model，具体的网络请求交给VersionModel去实现，下面是VersionModel的具体实现：

public class VersionModel implements IModel {
    public interface VersionCallback {
        void onVersionCallback(Version version);
    }

    private HttpURLConnection httpURLConnection = null;
    private InputStream inputStream = null;
    private BufferedReader bufferedReader = null;

    public void getNewVersion(final String url, final VersionCallback versionCallback) {

        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    httpURLConnection = (HttpURLConnection) new URL(url).openConnection();
                    httpURLConnection.connect();
                    inputStream = httpURLConnection.getInputStream();
                    bufferedReader = new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
                    StringBuilder stringBuilder = new StringBuilder();
                    String tempLine = null;
                    while ((tempLine = bufferedReader.readLine()) != null) {
                        stringBuilder.append(tempLine).append("\n");
                    }
                    String data = stringBuilder.toString();
                    Log.e("data", data);
                    JSONObject jsonObject;
                    jsonObject = new JSONObject(data);
                    Version version=new Version();
                    version.setHasNewVersion("has_new_version");
                    version.setVersionCode(jsonObject.optString("version_code"));
                    version.setVersionName(jsonObject.optString("version_name"));
                    versionCallback.onVersionCallback(version);
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    try {
                        bufferedReader.close();
                        inputStream.close();
                    } catch (Exception e) {

                    }
                }
            }
        }).start();
    }
}

VersionModel去执行网络请求，获取到VersonView需要的数据然后回调到VersionPresenter，再由VersionPresenter通知VersonView去做UI的变化或者其他一些操作。纵观整个过程可以发现，view层和model层没有一丝耦合，这就是mvp架构模式的初衷，做到了松耦合，view，model，presenter每一层负责自身的工作，绝不越界。