MVP应用架构模式

时间  2019-12-04
标签 mvp 应用 架构 模式 栏目 系统架构 繁體版
原文   原文链接

最近经过《Android源码设计模式解析与实战》对MVP应用架构进行了了解，摘其重点记录于此。数据库

MVP简介

MVP模式全称Model View Presenter。能：
1.有效地下降View复杂性，避免业务逻辑被塞进View中；
2.解除View与Model的耦合，保证了系统的整洁性、灵活性。设计模式

理想化的MVP模式能够实现同一份逻辑代码搭配不一样的显示页面，由于它们之间并不依赖于具体（class），而是依赖于抽象（interface）。
MVP并非一个标准化的模式，咱们可根据本身的需求和本身认为对的方式去修正MVP的实现方式，它能够随着Presenter的复杂程度变化。
只要咱们是经过Presenter将View和Model解耦合、下降类型复杂度、各个模块能够独立测试、独立变化，这就是正确的方向。缓存

MVP模式的三个角色

  1. Presenter层：主要做为View和Model的桥梁，它从Model层检索数据后，返回给View层，使得View和Model之间没有耦合，也将业务逻辑从View角色上抽离出来。
  2. View层：用户界面，一般是指Activity、Fragment或者某个View控件，它含有一个Presenter成员变量。负责页面渲染与事件分发（即调用Presenter方法处理事件）。
  3. Model层：Model角色主要是提供数据的存取功能。Presenter须要经过Model层存储、获取数据，Model就像一个数据仓库。更直白地说，Model是封装了数据库DAO或者网络获取数据的角色，或者两种数据获取方式的集合。

MVP模式的应用

下面经过一个简单的客户端示例来直观地体会MVP在开发中的运用。咱们的UI原型大体以下图所示：主界面就是一个ListView和进度条，在加载数据时显示进度条，加载完成以后隐藏。UI原型服务器

进入应用后首先会从服务器下载最新的20篇文章，而后将每一篇文章的简介显示到列表上。所以，咱们的业务逻辑大概有下列2个：网络

  1. 向服务器请求数据，而且在数据存储到数据库中；
  2. 从数据库中加载文章列表。

关键类以下：架构

  1. 本地仓库——LinkedList<String>：负责提供（输出）本地数据，同时负责将远程数据缓存至本地，被仓库层持有；
  2. 远程仓库接口——RemoteRepository：如Retrofit对应的interface文件，被仓库层持有；
  3. 远程仓库实现——RemoteRepositoryImpl ：负责Http请求的发起及响应的接收，被仓库层实例化；
  4. 仓库层接口——ArticleModel：定义了仓库层须要实现的功能，亦即Presenter可调用的方法，被Presenter持有；
  5. 仓库层实现——ArticleModelImpl ：即Model层，内部持有本地仓库和远程仓库的引用，负责为Presenter提供数据，被Presenter实例化；
  6. Presenter层——ArticlePresenter ：被View层实现持有，同时持有仓库层接口（ArticleModel）及View层接口（ArticleViewInterface），经过调用仓库层及View层的方法实现业务逻辑；
  7. View层接口——ArticleViewInterface：定义视图层须要实现的功能，被Presenter持有；
  8. View层实现——MvpHomeActivity：实现View层须要具有的功能（方法），按需调用Presenter的业务逻辑；
/**
*数据加载监听
*/
public interface DataListener<T> {
    //泛型是数据集合的类型
    public void onComplete(T articles);
}

/**
*远程数据获取接口（remote仓库接口）
*/
public interface RemoteRepository{
    /**
    *远程抓取数据
    */
    public void fetchArticles(DataListener<List<String>> listener);
}

/**
*远程数据获取实现（remote仓库实现）
*/
public class RemoteRepositoryImpl implements RemoteRepository{
    @Override
    public void fetchArticles(DataListener<List<String>> listener) {
        List<String> articles = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            articles.add("文章" + i);
        }
         listener.onComplete(articles);
    }
}

/**
*数据层抽象（Model层接口、仓库层接口）
*/
public interface ArticleModel {
    /**
    *调用远程接口获取文章列表
    */
    public void loadArticlesFromRemote(DataListener<List<String>> listener);
    /**
    *缓存网络数据至本地
    */
    public void saveArticles(List<String> articles);
    /**
    *从缓存中加载数据
    *@param listener  该参数由ModelImpl调用，由Presenter负责实现，用于解耦。
    */
    public void loadArticlesFromCache(DataListener<List<String>> listener);
}

/**
*数据层实现（Model层实现、仓库层实现）
*/
public class ArticleModelImpl implements ArticleModel {
    /**
    *持有local仓库的引用
    */
    List<String> mCacheArticles = new LinkedList<String>();

    /**
    *持有remote仓库的引用
    */
    RemoteRepository remote= new RemoteRepositorympl();
    
    @Override
    public void loadArticlesFromRemote(DataListener<List<String>> listener) {
        remote.fetchArticles(listener);
     }
    
    @Override
    public void saveArticles(List<String> articles) {
        //为了代码简单，咱们这里模拟数据库的存取操做，将数据缓存到内存中
        mCacheArticles.addAll(articles);
     }
    
    @Override
    public void loadArticlesFromCache(DataListener<List<String>> listener) {
        listener.onComplete(mCacheArticles);
    }
}

/**
*Presenter层
*/
public class ArticlePresenter {
    //Presenter层持有View层的接口
    ArticleViewInterface mArticleView;
    
    //Presenter层持有Model层的接口
    ArticleModel mArticleModel;
    
    //构造器，给持有的View层接口赋以具体的实现，进而能够调用View层的方法
    //同时实例化成员变量
    public ArticlePresenter(ArticleViewInterface viewInterface) {
        mArticleView = viewInterface;
        mArticleModel = new ArticleModelImpl();
    }
    
    /**
    *业务逻辑1：获取远程数据
    */
    public void fetchArticles() {
        mArticleView.showLoading();
        mArticleModel .loadArticlesFromRemote(new DataListener<List<String>>() {
            @Override
            public void onComplete(List<String> result) {
                //数据加载完，调用View的showArticles函数将数据传递为View显示
                mArticleView.showAricles(result);
    
                mArticleView.hideLoading();
    
                //储存到数据库
                mArticleModel.saveArticles(result);
            }
        });
    }

    /**
    *业务逻辑2：获取缓存数据:
    */
    public void loadArticlesFromDB(){
        mArticleModel.loadArticlesFromCache(new DataListener<List<String>>() {
            @Override
            public void onComplete(List<String> result) {
                mArticleView.showAricles(result);
            }
        });
    }
}

/**
*View层接口
*/
public interface ArticleViewInterface {
    /**
    *展现数据
    */
    public void showAricles(List<String> articles);
    /**
    *显示进度条
    */
    public void showLoading();
    /**
    *隐藏进度条
    */
    public void hideLoading();
}


/**
*View层实现
*/
public class MvpHomeActivity extends Activity implements ArticleViewInterface {
        
        private ListView lv;
        private ProgressBar pb;
           
        private List<String> mArticles = new LinkedList<String>();
        private BaseAdapter mAdapter;
            //View层实现持有Presenter的引用
        private ArticlePresenter mPresenter;

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_mvp_home);
            //初始化各类控件
            initViews();
            //构建ArticlePresenter，与Activity关联
            mPresenter = new ArticlePresenter(this);

            boolean netAvailable = true;
            if (netAvailable) {
                mPresenter.fetchArticles();
            }else{
                mPresenter.loadArticlesFromDB();
            }
        }
    
        private void initViews() {
            pb = (ProgressBar) findViewById(R.id.pb);
            lv = (ListView) findViewById(R.id.lv);
            mAdapter = new CommonAdapter<String>(this,R.layout.item_layout,mArticles) {
                @Override
                protected void convert(ViewHolder viewHolder, String item, int position) {
                    viewHolder.setText(R.id.text1,item);
                }
            };
            lv.setAdapter(mAdapter);
        }
    
        @Override
        public void showAricles(List<String> articles) {
            mArticles.addAll(articles);
            mAdapter.notifyDataSetChanged();
        }
    
        @Override
        public void showLoading() {
            pb.setVisibility(View.VISIBLE);
        }
    
        @Override
        public void hideLoading() {
            pb.setVisibility(View.GONE);
        }
    }

延伸

须要注意的是，上述代码中对于ArticlePresenter并无进行接口抽象，而是使用了具体类，由于业务逻辑相对稳定，在此咱们直接使用具体类便可。固然，若是业务逻辑相对来讲易于变化，使用Presenter接口来应对更是最好不过了。ide

同时，因为Presenter常常性地须要执行一些耗时操做，如网络请求。而Presenter持有了MvpHomeActivity的强引用，若是在请求结束以前Activity被销毁了，那么因为网络请求尚未返回，致使Presenter一直持有MvpHomeActivity对象，使得MvpHomeActivity对象没法被回收，此时就发生了内存泄漏。函数

为了解决上述问题，能够经过弱引用和Activity，Fragment的生命周期来解决这个问题。首先创建一个Presenter抽象，它是一个泛型类，泛型类型为View角色要实现的接口类型，代码以下：测试

public abstract class BasePresenter<T> {
    protected Reference<T> mViewRef;//View接口类型的弱引用
    
    public void attachView(T view){
        mViewRef = new WeakReference<T>(view);//创建关联
    }
    
    //获取View
    protected T getView(){
        return mViewRef.get();
    }
    
    //判断是否与View创建了关联
    public boolean isViewAttached(){
        return mViewRef!=null&&mViewRef.get()!=null;
    }
    
    //解除关联
    public void detachView(){
        if(mViewRef!=null){
            mViewRef.clear();
            mViewRef = null;
        }
    }
}

而后，建立一个MVPBaseActivity基类，经过这个基类的生命周期来控制它和Presenter的关系，代码以下：fetch

public abstract class MVPBaseActivity<V, P extends BasePresenter<V>> extends Activity {
    /**
    *Presenter对象
    */
    protected P mPresenter;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //建立Presenter
        mPresenter = createPresenter();
        mPresenter.attachView((V) this);
    }
    
    @Override
    protected void onDestroy() {
        super.onDestroy();
         /**
        *弱引用防止内存溢出
        */
        mPresenter.detachView();
    }
    
    /**
    *子类负责提供具体的Presenter对象
    */
    protected abstract P createPresenter();
}

MVPBaseActivity含有两个泛型参数，第一个是View层接口，第二个是Presenter的具体类型。经过泛型参数，使得一些通用的逻辑能够被抽象到MVPBaseActivity类中。

它山之石

  1. 理解Java中的弱引用
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程