Android中的MVP-Part2
Android中的MVP-Part2
在上一篇文章中我们谈论了Model View Presenter (MVP)的概念和在Android开发中的优点。这是系列文章的第二篇，我们来动手实践一下，将使用典型的形式实现一个MVP结构，不使用任何Android SDK或JAVA以外的库。
我们会开发一个简单的工程，但是由于涉及大量的对象，可能使项目看起来有些复杂。但是，一旦你掌握了，你就会明白MVP模式如何能帮助你。如果你想直接看代码，在这里。
设计MVP
MVP在Android中的主要概念
Presenter
Presenter是View和Model的中间人。它从Model层获取数据，格式化后返回给View层。 但是和典型的MVC模式不同的是，它还决定如何处理你和视图的交互。
View
视图层，通常是由Activity实现，其中包含有presenter的引用。视图层唯一要做的事就是响应 用户的操作，调用Presenter层的方法。
Model
在有良好分层结构的应用中，Model层只是domain层或者业务逻辑的入口。把它看做视图层 数据的提供者就好。
以上优秀的定义提取自Antonio Leiva’s article
使用MVP模式的最大任务是增加我们项目的关注分离.因此我们需要确保Model层，View层和Presenter层的隔离。这种情况下，View层和Model层无法直接通信，因此Presenter负责各层的通讯
Model View Presenter行为图
让我们设想一个简单的应用，它允许用户在旅途中做笔记。主要就是用户记录笔记，系统保存和展示数据。如果我们沿着输入笔记的行为，结合MVP模式，我们会得到下图：
- 用户点击输入笔记。视图层将笔记内容传入Presenter层的newNote(textNote)方法。
- Presenter层调用Model层的insertNote(note, this)方法，将传入的string创建为一个新的笔记。
- Model层在数据库中插入笔记并且使用onSuccess()方法通知Presenter层成功/失败的结果
- Presenter层处理结果后调用showToast()方法让View层展示一个toast
这个映射给了我们对类设计的灵感。上述不同层之间的通信过程实现可能会不一样：直接调用对象的方法，使用接口或者使用EventBus。然而，既然我们的实现方式遵循典型方式，并且意在增加关注分离，所以我们只用原始简单的接口。
Model View Presenter类图
让我们根据上面的行为图来构造我们的MVP模式类图。我们会对概念做一点改动，把callback换成interface，来将结果从Model层传回Presenter层。我相信这种方式更高效，但是有人会对此有争议，认为callback会增加关注分离。
- Presenter层实现PresenterOps接口
- View层接受PresenterOps的引用来访问Presenter
- Model层实现ModelOps接口
- Presenter层接受ModelOps的引用来访问Model
- Presenter层实现RequiredPresenterOps接口
- Model层接受RequiredPresenterOps的引用来访问Presenter
- View层实现RequiredViewOps接口
- Presenter层接受RequiredViewOps的引用来访问View
在Android中实现MVP
事不宜迟，让我们动起来！先定义操作。为了更好的结构组织，我们使用一个“umbrella”类，包含所有层次间通讯的接口。
注意：由于实现MVP模式已经很复杂了，我不会实现其他多余的内容。我假设读者都对Android SDK有很好的理解，因此不需要我关注这些。
Interface MainMVP
/*
* Aggregates all communication operations between MVP pattern layer:
* Model, View and Presenter
*/
public interface MainMVP {
/**
* View mandatory methods. Available to Presenter
* Presenter -> View
*/
interface RequiredViewOps {
void showToast(String msg);
void showAlert(String msg);
// any other ops
}
/**
* Operations offered from Presenter to View
* View -> Presenter
*/
interface PresenterOps {
void onConfigurationChanged(RequiredViewOps view);
void onDestroy(boolean isChangingConfig);
void novaNota(String textoNota);
void deletaNota(Nota nota);
// any other ops to be called from View
}
/**
* Operations offered from Presenter to Model
* Model -> Presenter
*/
interface RequiredPresenterOps {
void onNotaInserida(Nota novaNota);
void onNotaRemovida(Nota notaRemovida);
void onError(String errorMsg);
// Any other returning operation Model -> Presenter
}
/**
* Model operations offered to Presenter
* Presenter -> Model
*/
interface ModelOps {
void insereNota(Nota nota);
void removeNota(Nota nota);
void onDestroy();
// Any other data operation
}
}MainPresenter Class
public class MainPresenter implements MainMVP.RequiredPresenterOps, MainMVP.PresenterOps {
// Layer View reference
private WeakReference<MainMVP.RequiredViewOps> mView;
// Layer Model reference
private MainMVP.ModelOps mModel;
// Configuration change state
private boolean mIsChangingConfig;
public MainPresenter(MainMVP.RequiredViewOps mView) {
this.mView = new WeakReference<>(mView);
this.mModel = new MainModel(this);
}
/**
* Sent from Activity after a configuration changes
* @param view View reference
*/
@Override
public void onConfigurationChanged(MainMVP.RequiredViewOps view) {
mView = new WeakReference<>(view);
}
/**
* Receives {@link MainActivity#onDestroy()} event
* @param isChangingConfig Config change state
*/
@Override
public void onDestroy(boolean isChangingConfig) {
mView = null;
mIsChangingConfig = isChangingConfig;
if ( !isChangingConfig ) {
mModel.onDestroy();
}
}
/**
* Called by user interaction from {@link MainActivity}
* creates a new Note
*/
@Override
public void newNote(String noteText) {
Note note = new Note();
note.setText(textoNota);
note.setDate(getDate());
mModel.insertNote(note);
}
/**
* Called from {@link MainActivity},
* Removes a Note
*/
@Override
public void removeNote(Note note) {
mModel.removeNote(note);
}
/**
* Called from {@link MainModel}
* when a Note is inserted successfully
*/
@Override
public void onNoteInsert(Note newNote) {
mView.get().showToast("New register added at " + newNote.getDate());
}
/**
* Receives call from {@link MainModel}
* when Note is removed
*/
@Override
public void onNoteRemoved(Note noteRemoved) {
mView.get().showToast("Note removed);
}
/**
* receive errors
*/
@Override
public void onError(String errorMsg) {
mView.get().showAlert(errorMsg);
}
}MainModel Class
public class MainModel implements MainMVP.ModelOps {
// Presenter reference
private MainMVP.RequiredPresenterOps mPresenter;
public MainModel(MainMVP.RequiredPresenterOps mPresenter) {
this.mPresenter = mPresenter;
}
/**
* Sent from {@link MainPresenter#onDestroy(boolean)}
* Should stop/kill operations that could be running
* and aren't needed anymore
*/
@Override
public void onDestroy() {
// destroying actions
}
// Insert Note in DB
@Override
public void insertNote(Note note) {
// data business logic
// ...
mPresenter.onNoteInserted(note);
}
// Removes Note from DB
@Override
public void removeNote(Note note) {
// data business logic
// ...
mPresenter.onNoteRemoved(note);
}
}处理Android相关的特性
在我们的MVP模式中，视图层负责创建Presenter层，Presenter层负责实例化Model层对象。考虑到使用Activity来实现View层，我们需要考虑一些Android的细节，尤其是销毁和创建activities及其对象的生命周期。
这就是说，我们需要增加第四个元素StateMaintainer，负责在生命周期的变化中维护Presenter和Model的状态。使用retained fragment来实现这个对象，如下是一个简化的MVP模式Activity生命周期：
- Activity创建一个Presenter的实例并持有PresenterOps的引用。Presenter存储在StateMaintainer中
- Presenter在创建时接受RequiredViewOps类型参数并且创建一个Model对象
- Model接受RequiredPresenterOps类型参数
- 当Activity被销毁时，会通知Presenter
- Presenter处理信息，作必要的处理后传递给Model
- Activity从StateMaintainer中恢复Presenter，并且传递RequiredViewOps，通知他的激活状态。
StateMaintainer Class
StateMaintainer的这种实现可以用来存储任何对象的状态。
StateMainainer
public class StateMaintainer {
protected final String TAG = getClass().getSimpleName();
private final String mStateMaintenerTag;
private final WeakReference<FragmentManager> mFragmentManager;
private StateMngFragment mStateMaintainerFrag;
/**
* Constructor
* @param fragmentManager FragmentManager reference
* @param stateMaintainerTAG the TAG used to insert the state maintainer fragment
*/
public StateMaintainer(FragmentManager fragmentManager, String stateMaintainerTAG) {
mFragmentManager = new WeakReference<>(fragmentManager);
mStateMaintenerTag = stateMaintainerTAG;
}
/**
* Create the state maintainer fragment
* @return true: the frag was created for the first time
* false: recovering the object
*/
public boolean firstTimeIn() {
try {
// Recovering the reference
mStateMaintainerFrag = (StateMngFragment)mFragmentManager.get().findFragmentByTag(mStateMaintenerTag);
// Creating a new RetainedFragment
if (mStateMaintainerFrag == null) {
Log.d(TAG, "Creating a new RetainedFragment " + mStateMaintenerTag);
mStateMaintainerFrag = new StateMngFragment();
mFragmentManager.get().beginTransaction()
.add(mStateMaintainerFrag,mStateMaintenerTag).commit();
return true;
} else {
Log.d(TAG, "Returns a existent retained fragment existente " + mStateMaintenerTag);
return false;
}
} catch (NullPointerException e) {
Log.w(TAG, "Error firstTimeIn()");
return false;
}
}
/**
* Insert Object to be preserved during configuration change
* @param key Object's TAG reference
* @param obj Object to maintain
*/
public void put(String key, Object obj) {
mStateMaintainerFrag.put(key, obj);
}
/**
* Insert Object to be preserved during configuration change
* Uses the Object's class name as a TAG reference
* Should only be used one time by type class
* @param obj Object to maintain
*/
public void put(Object obj) {
put(obj.getClass().getName(), obj);
}
/**
* Recovers saved object
* @param key TAG reference
* @param <T> Class type
* @return Objects
*/
@SuppressWarnings("unchecked")
public <T> T get(String key) {
return mStateMaintainerFrag.get(key);
}
/**
* Verify the object existence
* @param key Obj TAG
*/
public boolean hasKey(String key) {
return mStateMaintainerFrag.get(key) != null;
}
/**
* Save and manages objects that show be preserved
* during configuration changes.
*/
public static class StateMngFragment extends Fragment {
private HashMap<String, Object> mData = new HashMap<>();
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// Grants that the frag will be preserved
setRetainInstance(true);
}
/**
* Insert objects
* @param key reference TAG
* @param obj Object to save
*/
public void put(String key, Object obj) {
mData.put(key, obj);
}
/**
* Insert obj using class name as TAG
* @param object obj to save
*/
public void put(Object object) {
put(object.getClass().getName(), object);
}
/**
* Recover obj
* @param key reference TAG
* @param <T> Class
* @return Obj saved
*/
@SuppressWarnings("unchecked")
public <T> T get(String key) {
return (T) mData.get(key);
}
}
}MainActivity Activity (View layer)
public class MainActivity extends AppCompatActivity implements MainMVP.RequiredViewOps {
protected final String TAG = getClass().getSimpleName();
// Responsible to maintain the Objects state
// during changing configuration
private final StateMaintainer mStateMaintainer = new StateMaintainer( this.getFragmentManager(), TAG );
// Presenter operations
private MainMVP.PresenterOps mPresenter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
startMVPOps();
setContentView(R.layout.activity_main);
Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
setSupportActionBar(toolbar);
FloatingActionButton fab = (FloatingActionButton)findViewById(R.id.fab);
}
/**
* Initialize and restart the Presenter.
* This method should be called after {@link Activity#onCreate(Bundle)}
*/
public void startMVPOps() {
try {
if ( mStateMaintainer.firstTimeIn() ) {
Log.d(TAG, "onCreate() called for the first time");
initialize(this);
} else {
Log.d(TAG, "onCreate() called more than once");
reinitialize(this);
}
} catch ( InstantiationException | IllegalAccessException e ) {
Log.d(TAG, "onCreate() " + e );
throw new RuntimeException( e );
}
}
/**
* Initialize relevant MVP Objects.
* Creates a Presenter instance, saves the presenter in {@link StateMaintainer}
*/
private void initialize( MainMVP.RequiredViewOps view ) throws InstantiationException, IllegalAccessException{
mPresenter = new MainPresenter(view);
mStateMaintainer.put(MainMVP.PresenterOps.class.getSimpleName(), mPresenter);
}
/**
* Recovers Presenter and informs Presenter that occurred a config change.
* If Presenter has been lost, recreates a instance
*/
private void reinitialize( MainMVP.RequiredViewOps view)
throws InstantiationException, IllegalAccessException {
mPresenter = mStateMaintainer.get( MainMVP.PresenterOps.class.getSimpleName() );
if ( mPresenter == null ) {
Log.w(TAG, "recreating Presenter");
initialize( view );
} else {
mPresenter.onConfigurationChanged( view );
}
}
// Show AlertDialog
@Override
public void showAlert(String msg) {
// show alert Box
}
// Show Toast
@Override
public void showToast(String msg) {
Toast.makeText(getApplicationContext(), msg, Toast.LENGTH_SHORT).show;
}
}源码
下一篇文章
我知道这篇文章有一点长了，很抱歉。但我真的希望可以帮到谁。下一遍文章，我们会讨论如何使用最终的框架，它包含了一些可以加快MVP实现的抽象，我们也会谈论一些适配的小问题。
回头见！