MVC MVP

灰太狼 2022-10-01 06:47 132阅读 0赞

## 开篇 ##

*  不知道有没有初学者和我一样的困惑，MVC和MVP傻傻分不清楚，C和P不就是一样的吗，一开始的认知是这样的：

> M：Model层，是那些javabean类，比如自定义的Person类等  
> V：View层，android里的layout.xml文件  
> P：Presenter层，用来解耦网络请求的，将网络操作单独放在这个P类里

*  这就是典型的把MVC和MVP混在一起了，把P和M混在一起

## 分析 ##

1.  MVC正确的理解

1.  这里需要结合代码看下：

public class MVCActivity extends AppCompatActivity {
    
        private Button button;
        private TextView textView;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_test);
            button = findViewById(R.id.button);
            textView = findViewById(R.id.text_view);
            button.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    new HttpModel(textView).request();
                }
            });
        }
    }
    
    
    
    public class HttpModel {
        private TextView textView;
    
        public HttpModel(TextView textView) {
            this.textView = textView;
        }
    
        private Handler handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                textView.setText((String) msg.obj);
            }
        };
    
        public void request() {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(2000);
                        Message msg = handler.obtainMessage();
                        msg.obj = "从网络获取到的数据";
                        handler.sendMessage(msg);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
    复制代码

1.  问题是activity做了太多工作，既是view也是controller，而我们希望在activity中做的工作只是负责view的显示更新，所以将Controller层的工作抽出来封装到P层，之前的调用网络请求由P层去完成，P层调用M层的网络请求，M层返回结果以后通过P层，P层再更新到V层；这样可以做到view层非常简洁，将一些非view层的初始化逻辑或者调用网络请求操作交由P层去处理，P层会持有view层的引用，以便需要更新view，而view也会持有P层的引用。
2.  看下改造后的：

interface MVPView {
        void updateTv(String text);
    }
    
    
    public class MVPActivity extends AppCompatActivity implements MVPView {
        private Button button;
        private TextView textView;
        private Presenter presenter;
    
        @Override
        protected void onCreate(@Nullable Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_test);
            button = findViewById(R.id.button);
            textView = findViewById(R.id.text_view);
            presenter = new Presenter(this);
            button.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    presenter.request();
                }
            });
        }
    
        @Override
        public void updateTv(String text) {
            textView.setText(text);
        }
    }
    
    
    interface Callback {
        void onResult(String text);
    }
    
    
    public class HttpModel {
        private Callback callback;
    
        public HttpModel(Callback callback) {
            this.callback = callback;
        }
    
        private Handler handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                callback.onResult((String) msg.obj);
            }
        };
    
        public void request() {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(2000);
                        Message msg = handler.obtainMessage();
                        msg.obj = "从网络获取到的数据";
                        handler.sendMessage(msg);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
    
    
    public class Presenter {
        private MVPView view;
        private HttpModel model;
    
        public Presenter(MVPView view) {
            this.view = view;
            model = new HttpModel(new Callback() {
                @Override
                public void onResult(String text) {
                    Presenter.this.view.updateTv(text);
                }
            });
        }
    
        public void request() {
            model.request();
        }
    }
    复制代码

1.  这里注意有内存泄漏的风险，当activity退出的时候，P层仍持有Activity的引用，P层此时若正在执行耗时操作，则不会被内存回收，间接导致activity不会被回收，造成泄漏。所以要在退出的时候将其引用置空

P层：
    public void detachView(){
        view = null;
    }
    Activity:
    @Override
    protected void onDestroy(){
        super.onDestroy();
        presenter.detachView();
    }
    复制代码

## 扩展 ##

> 这里分析下这个MVP开源库：[github.com/sockeqwe/mo…][github.com_sockeqwe_mo] ，学习一下别人的思想，MVP是一种思想，但实际到项目中使用如果封装好，用起来就会比较方便

1.  看下几个基本接口、基类

//这个MvpView接口我们写一个接口去继承它，里面提供通用更新View的方法，
 //再让业务Activity实现该接口，重写对应方法，在方法中做相应的更新view的操作
 public interface MvpView {
 }
 //P层对应有attachView() detachView() destroy() 三个通用方法
 public interface MvpPresenter<V extends MvpView> {
 
 /**
 * Set or attach the view to this presenter
 */
 @UiThread
 void attachView(@NonNull V view);
 
 /**
 * Will be called if the view has been destroyed. Typically this method will be invoked from
 * <code>Activity.detachView()</code> or <code>Fragment.onDestroyView()</code>
 *
 * @deprecated This method has been split into 2 methods: {@link #detachView()} and {@link #destroy()}
 */
 @UiThread
 @Deprecated
 void detachView(boolean retainInstance);
 
 /**
 * Will be called if the view has been detached from the Presenter.
 * Usually this happens on screen orientation changes or view (like fragment) has been put on the backstack.
 */
 @UiThread
 void detachView();
 
 /**
 * Will be called if the presenter is no longer needed because the View has been destroyed permanently.
 * This is where you do clean up stuff.
 */
 @UiThread
 void destroy();
 }
 
 //来看下实现P层接口的通用Presenter类，主要分析下重写的这三个方法
 public class MvpBasePresenter<V extends MvpView> implements MvpPresenter<V> {
 
 
 private WeakReference<V> viewRef;
 private boolean presenterDestroyed = false;
 
 @UiThread @Override public void attachView(V view) {
 //传进来的view是this，实现了V层接口的业务Activity，通过弱引用的方式进行
 //引用，在Acitivy需要被回收的时候，Activity对象不会因为被弱引用引用而导致
 //回收不了，防止内存泄漏
 viewRef = new WeakReference<V>(view);
 presenterDestroyed = false;
 }
 
 /**
 * Gets the attached view. You should always call {@link #isViewAttached()} to check if the view
 * is attached to avoid NullPointerExceptions.
 * 在Presenter类中，通过此方法来获取activity对象，调用对应的在activity
 * 中重写的更新view的方法，通常用法是：
 * if(getView()!=null){ getView().updateView() }
 * 
 * @return <code>null</code>, if view is not attached, otherwise the concrete view instance
 * @deprecated Use {@link #ifViewAttached(ViewAction)}
 */
 
 @Deprecated @UiThread public V getView() {
 return viewRef == null ? null : viewRef.get();
 }
 
 /**
 * {@inheritDoc}
 */
 @Deprecated @UiThread @Override public void detachView(boolean retainInstance) {
 }
 
 /**
 * {@inheritDoc}此方法也会在activity的onDestroy()中调用，同时还会在屏幕旋转、
 * Fragment的onDetachView()中调用
 */
 @Override public void detachView() {
 detachView(true);
 if (viewRef != null) {
 viewRef.clear();
 viewRef = null;
 }
 }
 
 /**
 * {@inheritDoc} 此方法会在完全退出即activty退出onDestroy()中使用
 */
 @Override public void destroy() {
 detachView(false);
 presenterDestroyed = true;
 }
 }
 复制代码

1.  主要的类和基类Activity：

public class ActivityMvpDelegateImpl<V extends MvpView, P extends MvpPresenter<V>>
 implements ActivityMvpDelegate {
 
 protected static final String KEY_MOSBY_VIEW_ID = "com.hannesdorfmann.mosby3.activity.mvp.id";
 
 public static boolean DEBUG = false;
 private static final String DEBUG_TAG = "ActivityMvpDelegateImpl";
 
 private MvpDelegateCallback<V, P> delegateCallback;
 protected boolean keepPresenterInstance;
 protected Activity activity;
 protected String mosbyViewId = null;
 
 /**
 * 这里构造方法会传进来三个参数，分别是activity，delegateCallback主要是构造Presenter,调用其createPresenter(),
 * getPresenter(),setPresenter()方法，keepPresenterInstance判断是否要保存Presenter实例
 * @param activity The Activity
 * @param delegateCallback The callback
 * @param keepPresenterInstance true, if the presenter instance should be kept across screen
 * orientation changes. Otherwise false.
 */
 public ActivityMvpDelegateImpl(@NonNull Activity activity,
 @NonNull MvpDelegateCallback<V, P> delegateCallback, boolean keepPresenterInstance) {
 
 if (activity == null) {
 throw new NullPointerException("Activity is null!");
 }
 
 if (delegateCallback == null) {
 throw new NullPointerException("MvpDelegateCallback is null!");
 }
 this.delegateCallback = delegateCallback;
 this.activity = activity;
 this.keepPresenterInstance = keepPresenterInstance;
 }
 
 /**
 * Determines whether or not a Presenter Instance should be kept
 * 在onDestroy()中用于判断是否保留Presenter实例
 * @param keepPresenterInstance true, if the delegate has enabled keep
 */
 static boolean retainPresenterInstance(boolean keepPresenterInstance, Activity activity) {
 return keepPresenterInstance && (activity.isChangingConfigurations()
 || !activity.isFinishing());
 }
 
 /**
 * Generates the unique (mosby internal) view id and calls {@link
 * MvpDelegateCallback#createPresenter()}
 * to create a new presenter instance
 *
 * @return The new created presenter instance
 */
 private P createViewIdAndCreatePresenter() {
 
 //这里的createPresenter()最终是对应业务activity去重写的，new出对应的Presenter
 P presenter = delegateCallback.createPresenter();
 if (presenter == null) {
 throw new NullPointerException(
 "Presenter returned from createPresenter() is null. Activity is " + activity);
 }
 //将对应activity和presenter保存
 if (keepPresenterInstance) {
 mosbyViewId = UUID.randomUUID().toString();
 PresenterManager.putPresenter(activity, mosbyViewId, presenter);
 }
 return presenter;
 }
 
 @Override public void onCreate(Bundle bundle) {
 
 P presenter = null;
 
 if (bundle != null && keepPresenterInstance) {
 
 mosbyViewId = bundle.getString(KEY_MOSBY_VIEW_ID);
 
 if (DEBUG) {
 Log.d(DEBUG_TAG,
 "MosbyView ID = " + mosbyViewId + " for MvpView: " + delegateCallback.getMvpView());
 }
 
 if (mosbyViewId != null
 && (presenter = PresenterManager.getPresenter(activity, mosbyViewId)) != null) {
 //
 // Presenter restored from cache
 //
 if (DEBUG) {
 Log.d(DEBUG_TAG,
 "Reused presenter " + presenter + " for view " + delegateCallback.getMvpView());
 }
 } else {
 //
 // No presenter found in cache, most likely caused by process death
 //
 presenter = createViewIdAndCreatePresenter();
 if (DEBUG) {
 Log.d(DEBUG_TAG, "No presenter found although view Id was here: "
 + mosbyViewId
 + ". Most likely this was caused by a process death. New Presenter created"
 + presenter
 + " for view "
 + getMvpView());
 }
 }
 } else {
 // activity第一次启动，需要创建对应presenter
 // Activity starting first time, so create a new presenter
 //
 presenter = createViewIdAndCreatePresenter();
 if (DEBUG) {
 Log.d(DEBUG_TAG, "New presenter " + presenter + " for view " + getMvpView());
 }
 }
 
 if (presenter == null) {
 throw new IllegalStateException(
 "Oops, Presenter is null. This seems to be a Mosby internal bug. Please report this issue here: https://github.com/sockeqwe/mosby/issues");
 }
 
 delegateCallback.setPresenter(presenter);
 //持有对应activity的弱引用
 getPresenter().attachView(getMvpView());
 
 if (DEBUG) {
 Log.d(DEBUG_TAG, "View" + getMvpView() + " attached to Presenter " + presenter);
 }
 }
 
 private P getPresenter() {
 P presenter = delegateCallback.getPresenter();
 if (presenter == null) {
 throw new NullPointerException("Presenter returned from getPresenter() is null");
 }
 return presenter;
 }
 
 private V getMvpView() {
 V view = delegateCallback.getMvpView();
 if (view == null) {
 throw new NullPointerException("View returned from getMvpView() is null");
 }
 return view;
 }
 
 @Override public void onDestroy() {
 boolean retainPresenterInstance = retainPresenterInstance(keepPresenterInstance, activity);
 //释放activiy的弱引用
 getPresenter().detachView();
 if (!retainPresenterInstance){
 getPresenter().destroy();
 }
 if (!retainPresenterInstance && mosbyViewId != null) {
 PresenterManager.remove(activity, mosbyViewId);
 }
 
 if (DEBUG) {
 if (retainPresenterInstance) {
 Log.d(DEBUG_TAG, "View"
 + getMvpView()
 + " destroyed temporarily. View detached from presenter "
 + getPresenter());
 } else {
 Log.d(DEBUG_TAG, "View"
 + getMvpView()
 + " destroyed permanently. View detached permanently from presenter "
 + getPresenter());
 }
 }
 }
 
 @Override public void onPause() {
 
 }
 
 @Override public void onResume() {
 
 }
 
 @Override public void onStart() {
 
 }
 
 @Override public void onStop() {
 
 }
 
 @Override public void onRestart() {
 
 }
 
 @Override public void onContentChanged() {
 
 }
 
 @Override public void onSaveInstanceState(Bundle outState) {
 if (keepPresenterInstance && outState != null) {
 outState.putString(KEY_MOSBY_VIEW_ID, mosbyViewId);
 if (DEBUG) {
 Log.d(DEBUG_TAG,
 "Saving MosbyViewId into Bundle. ViewId: " + mosbyViewId + " for view " + getMvpView());
 }
 }
 }
 
 @Override public void onPostCreate(Bundle savedInstanceState) {
 }
 }
 复制代码

public abstract class MvpActivity<V extends MvpView, P extends MvpPresenter<V>>
 extends AppCompatActivity implements MvpView,
 com.hannesdorfmann.mosby3.mvp.delegate.MvpDelegateCallback<V,P> {
 
 protected ActivityMvpDelegate mvpDelegate;
 protected P presenter;
 protected boolean retainInstance;
 
 @Override protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 getMvpDelegate().onCreate(savedInstanceState);
 }
 
 @Override protected void onDestroy() {
 super.onDestroy();
 getMvpDelegate().onDestroy();
 }
 
 @Override protected void onSaveInstanceState(Bundle outState) {
 super.onSaveInstanceState(outState);
 getMvpDelegate().onSaveInstanceState(outState);
 }
 
 @Override protected void onPause() {
 super.onPause();
 getMvpDelegate().onPause();
 }
 
 @Override protected void onResume() {
 super.onResume();
 getMvpDelegate().onResume();
 }
 
 @Override protected void onStart() {
 super.onStart();
 getMvpDelegate().onStart();
 }
 
 @Override protected void onStop() {
 super.onStop();
 getMvpDelegate().onStop();
 }
 
 @Override protected void onRestart() {
 super.onRestart();
 getMvpDelegate().onRestart();
 }
 
 @Override public void onContentChanged() {
 super.onContentChanged();
 getMvpDelegate().onContentChanged();
 }
 
 @Override protected void onPostCreate(Bundle savedInstanceState) {
 super.onPostCreate(savedInstanceState);
 getMvpDelegate().onPostCreate(savedInstanceState);
 }
 
 /**
 * Instantiate a presenter instance
 * 让继承MvpActivity的业务Activity重写此方法，new出对应的Presenter对象
 * @return The {@link MvpPresenter} for this view
 */
 @NonNull public abstract P createPresenter();
 
 /**
 * Get the mvp delegate. This is internally used for creating presenter, attaching and detaching
 * view from presenter.
 *
 * Please note that only one instance of mvp delegate should be used per Activity
 * instance.
 * 
 *
 * 
 * Only override this method if you really know what you are doing.
 * 
 *
 * @return {@link ActivityMvpDelegateImpl}
 */
 @NonNull protected ActivityMvpDelegate<V, P> getMvpDelegate() {
 if (mvpDelegate == null) {
 mvpDelegate = new ActivityMvpDelegateImpl(this, this, true);
 }
 
 return mvpDelegate;
 }
 
 @NonNull @Override public P getPresenter() {
 return presenter;
 }
 
 @Override public void setPresenter(@NonNull P presenter) {
 this.presenter = presenter;
 }
 
 @NonNull @Override public V getMvpView() {
 return (V) this;
 }
 }
 复制代码

*  其实以上都是贴源码，能够大致理解该框架MVP的思想，一些细节问题不用去细扣，看不懂建议大家直接去下源码来看下，最后以上的理解都是基于此[任玉刚大神的博客][Link 1]的理解，如果有看不懂，可以结合来看

转载于:https://juejin.im/post/5c4fce7af265da61223ab5e6

[github.com_sockeqwe_mo]: https://link.juejin.im?target=https%3A%2F%2Fgithub.com%2Fsockeqwe%2Fmosby
[Link 1]: https://link.juejin.im?target=https%3A%2F%2Fblog.csdn.net%2Fsingwhatiwanna%2Farticle%2Fdetails%2F80841705