在app的開發過程中會使用各種架構，大的架構不外乎MVP和MVVM 架構，今天在查看git hub中發現了一個簡單易用的mvp框架推薦給大家。
下面跟大家介紹一下這個MVP框架。
# EasyMvp
一個簡單強大且靈活的MVP框架。
## 特點
- 原理簡單可以定製成自己想要的方式。
- 一個 Activity 可以綁定多個 Presenter，以達到最大的複用功能。
- 採用註解的方式實現依賴注入，減少耦合。
- 可以靈活管理生命週期。
- 使用起來方便簡單
- 使用例子可以在項目中找到。
- (有人問註解爲什麼不用dagger2,當然dagger2是個好東西,但是對於一部分人來說它的學習成本會略高,所以自己實現會有助於對註解的理解和學習,另一方面懂了自己實現後反過來再看dagger2不就更容易上手了嗎)
## 使用方法
（以簡單的登陸註冊爲例）
單個 Presenter 的情況
1. 定義好你的 View 層接口方法並繼承一個公共的 BaseMvpView 如 LoginView:
public interface LoginView extends BaseMvpView {
void loginSuccess();
}
2. 編寫 LoginPresenter 繼承 BasePresenter 並實現你的 Presenter 功能方法：
public class LoginPresenter extends BasePresenter<LoginView> {
public void login() {
mView.loginSuccess();
}
}
3. Activity 繼承 BaseMvpActivity 並實現你的 View 接口：
@CreatePresenter(presenter = LoginPresenter.class)
public class ExampleActivity3 extends BaseMvpActivity<LoginPresenter> implements LoginView {
@Override
protected int getContentView() {
return R.layout.activity_main;
}
@Override
public void init() {
getPresenter().login();
}
@Override
public void loginSuccess() {
Log.i("ExampleActivity1", "登陸成功");
}
}
其中在 Activity 中，Presenter 實例的獲取方法可以有上面代碼所示的通過 getPresenter 來獲取，這種方法需要在 BaseMvpActivity 後面
填入泛型參數你的 Presenter 實現類，比如上面所示的 LoginPresenter。
除了這種方法，也可以通過註解的方式獲取實例：
@CreatePresenter(presenter = LoginPresenter.class)
public class ExampleActivity3 extends BaseMvpActivity implements LoginView {
@PresenterVariable
private LoginPresenter mLoginPresenter;
@Override
protected int getContentView() {
return R.layout.activity_main;
}
@Override
public void init() {
mLoginPresenter.login();
}
@Override
public void loginSuccess() {
Log.i("ExampleActivity1", "登陸成功");
}
}
如果不喜歡註解，還可以通過直接獲取的方式獲取：
@CreatePresenter(presenter = LoginPresenter.class)
public class ExampleActivity3 extends BaseMvpActivity implements LoginView {
private LoginPresenter mLoginPresenter;
@Override
protected int getContentView() {
return R.layout.activity_main;
}
@Override
public void init() {
mLoginPresenter = getPresenterProviders().getPresenter(0);
mLoginPresenter.login();
}
@Override
public void loginSuccess() {
Log.i("ExampleActivity1", "登陸成功");
}
}
通過 getPresenterProviders().getPresenter(int index) 方法獲取，傳入的參數是你通過 @CreatePresenter 註解傳入的 class 對象的
數組下標，這裏因爲只有一個 Presenter, 所以傳 0 即可。
- 多個 Presenter 的情況多個 Presenter 的情況前兩個步驟跟上面一樣，主要是在 Activity 綁定這邊有些區別：
@CreatePresenter(presenter = {LoginPresenter.class, RegisterPresenter.class})
public class ExampleActivity1 extends BaseMvpActivity implements LoginView, RegisterView {
@PresenterVariable
private LoginPresenter mLoginPresenter;
@PresenterVariable
private RegisterPresenter mRegisterPresenter;
@Override
protected int getContentView() {
return R.layout.activity_main;
}
@Override
public void init() {
//也可以通過這種方式去獲取實例
//mLoginPresenter = getPresenterProviders().getPresenter(0);
//mRegisterPresenter = getPresenterProviders().getPresenter(1);
mLoginPresenter.login();
mRegisterPresenter.register();
}
@Override
public void loginSuccess() {
Log.i("ExampleActivity1", "登陸成功");
}
@Override
public void registerSuccess() {
Log.i("ExampleActivity1", "註冊成功");
}
}
如上所示，假如一個 Activity 中需要同時用到 LoginPresenter 和 RegisterPresenter 中的某些方法，只需要使用註解
@CreatePresenter 依次傳入它們的 class 對象即可完成綁定。同樣地爲了得到各個 Presenter 的實例，可以通過 @PresenterVariable
註解去獲取，當然如果不喜歡用註解，也可以通過 getPresenterProviders().getPresenter(int index) 方法去獲取哦。
- 不需要使用 Mvp 的情況並不是所有地方都需要用到 Mvp，當不需要用的時候，其實也沒什麼特別，就正常用就行：
public class ExampleActivity4 extends BaseMvpActivity {
@Override
protected int getContentView() {
return R.layout.activity_main;
}
@Override
public void init() {
}
}
## 混淆配置
-keep com.xxx.xxx.xxx.PresenterVariable class * {*;}
-keep com.xxx.xxx.xxx.CreatePresenter class * {*;}
-keep class * {
com.xxx.xxx.xxx.PresenterVariable <fields>;
com.xxx.xxx.xxx.CreatePresenter <fields>;
}
-keepclassmembers class ** {
com.xxx.xxx.xxx.PresenterVariable <methods>;
com.xxx.xxx.xxx.CreatePresenter <methods>;
}
謝謝 @yswheye 指點。
## 編寫 BasePresenter, BaseMvpView, BaseMvpActivity 等一些基礎類
上面例子中有用到 BasePresenter, BaseMvpView, BaseMvpActivity 等一些基礎類，這裏給出一種例子，用戶可根據自己需要去編寫。
- BaseMvpViewBaseMvpView 是基礎的 View 層接口：
public interface BaseMvpView {
void showError(String msg);
void complete();
void showProgressUI(boolean isShow);
}
可以看到就是定義了一些公共的接口方法。其實這個接口可以不需要，但是一般爲了方便，就寫上吧。
- BasePresenter
BasePresenter 就是基礎的 BasePresenter 了，作用也是實現一些公共的 Presenter 接口方法：
public class BasePresenter <V> {
protected Context mContext;
protected V mView;
protected void onCleared() {
}
public void attachView(Context context, V view) {
this.mContext = context;
this.mView = view;
}
public void detachView() {
this.mView = null;
}
public boolean isAttachView() {
return this.mView != null;
}
public void onCreatePresenter(@Nullable Bundle savedState) {
}
public void onDestroyPresenter() {
this.mContext = null;
detachView();
}
public void onSaveInstanceState(Bundle outState) {
}
}
裏面實現一些公共的 Presenter 方法，一般像 attachView，detachView ，isAttachView 等方法是一定要實現的，因爲這些與生命週期綁定有關，可以做資源的賦值和釋放等操作。
- BaseMvpActivity這個大家都知道，就是 Activity 的基類了，看看它的一種實現：
public abstract class BaseMvpActivity<P extends BasePresenter> extends AppCompatActivity implements BaseMvpView {
private PresenterProviders mPresenterProviders;
private PresenterDispatch mPresenterDispatch;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(getContentView());
mPresenterProviders = PresenterProviders.inject(this);
mPresenterDispatch = new PresenterDispatch(mPresenterProviders);
mPresenterDispatch.attachView(this, this);
mPresenterDispatch.onCreatePresenter(savedInstanceState);
init();
}
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
mPresenterDispatch.onSaveInstanceState(outState);
}
protected abstract int getContentView();
public abstract void init();
protected P getPresenter() {
return mPresenterProviders.getPresenter(0);
}
public PresenterProviders getPresenterProviders() {
return mPresenterProviders;
}
@Override
public void showError(String msg) {
}
@Override
public void complete() {
}
@Override
public void showProgressUI(boolean isShow) {
}
@Override
protected void onDestroy() {
super.onDestroy();
mPresenterDispatch.detachView();
}
}
BaseMvpActivity 後面定義的泛型 P 主要是爲了一個 Presenter 的時候使用 getPresenter() 方法時用到的，代碼如上面例子所示。可以看看 getPresenter() 的實現：
protected P getPresenter() {
return mPresenterProviders.getPresenter(0);
}
也只是調用了 PresenterProviders.getPresenter(int index) 方法而已。
然後 BaseMvpActivity 實現了 BaseMvpView 接口，默認實現了一些公共方法，當你繼承它的時候，需要可以重寫他們。
主要說一下 PresenterProviders，這個類的作用是解析用到的註解以及完成綁定和解綁 View 等一些公共的 Presenter 操作。1. 首先調用 inject 方法實例化，傳入當前對象（Activity 或者 Fragment）,傳 this 即可。
2. 通過查看 inject 的實現，它裏面調用了構造方法，構造方法再調用 resolveCreatePresenter 和 resolvePresenterVariable 方法來進行對註解 @CreatePresenter 和 @PresenterVariable 的解析。
private Activity mActivity;
private Fragment mFragment;
private Class<?> mClass;
public static PresenterProviders inject(Activity activity) {
return new PresenterProviders(activity, null);
}
public static PresenterProviders inject(Fragment fragment) {
return new PresenterProviders(null, fragment);
}
private PresenterProviders(Activity activity, Fragment fragment) {
if (activity != null) {
this.mActivity = activity;
mClass = this.mActivity.getClass();
}
if (fragment != null) {
this.mFragment = fragment;
mClass = this.mFragment.getClass();
}
resolveCreatePresenter();
resolvePresenterVariable();
}
```
下面簡單分析一下 PresenterProviders 具體實現：
1. 關於註解的知識，可以看這篇文章，看完應該就懂了：[深入理解Java註解類型(@Annotation)](https://blog.csdn.net/javazejian/article/details/71860633)2. PresenterStore 類：
這個類的主要作用就是將 Presenter 的實例存儲起來，用的是 HashMap 實現：
private static final String DEFAULT_KEY = "PresenterStore.DefaultKey";
private final HashMap<String, P> mMap = new HashMap<>();
public final void put(String key, P presenter) {
P oldPresenter = mMap.put(DEFAULT_KEY + ":" + key, presenter);
if (oldPresenter != null) {
oldPresenter.onCleared();
}
}
public final P get(String key) {
return mMap.get(DEFAULT_KEY + ":" + key);
}
public final void clear() {
for (P presenter : mMap.values()) {
presenter.onCleared();
}
mMap.clear();
}
因爲需要處理的是一個或多個 Presenter 對象，所以這樣做的目的是爲了可以統一管理和查找。3. 然後到了主要的 PresenterProviders 類
這個類主要看幾個方法，第一個 resolveCreatePresenter() 方法：
private <P extends BasePresenter> PresenterProviders resolveCreatePresenter() {
CreatePresenter createPresenter = mClass.getAnnotation(CreatePresenter.class);
if (createPresenter != null) {
Class<P>[] classes = (Class<P>[]) createPresenter.presenter();
for (Class<P> clazz : classes) {
String canonicalName = clazz.getCanonicalName();
try {
mPresenterStore.put(canonicalName, clazz.newInstance());
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
return this;
}
resolveCreatePresenter() 方法主要的作用是解析 @CreatePresenter 註解，過程是這樣的：首先獲取到註解上所有定義的 class 對象數組 classes，然後
循環，取它們的 canonicalName 作爲 key ,調用 newInstance 方法實例化後作爲 value 存入上面說到的 HasMap 中。
接下來是 resolvePresenterVariable 方法：
private <P extends BasePresenter> PresenterProviders resolvePresenterVariable() {
for (Field field : mClass.getDeclaredFields()) {
//獲取字段上的註解
Annotation[] anns = field.getDeclaredAnnotations();
if (anns.length < 1) {
continue;
}
if (anns[0] instanceof PresenterVariable) {
String canonicalName = field.getType().getName();
P presenterInstance = (P) mPresenterStore.get(canonicalName);
if (presenterInstance != null) {
try {
field.setAccessible(true);
field.set(mFragment != null ? mFragment : mActivity, presenterInstance);
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
}
return this;
}
resolvePresenterVariable 方法主要的作用就是爲將用 @PresenterVariable 註解標記的對象在 HashMap 中找到對應的實例，並賦值。過程是這樣的，首先通過 getDeclaredFields 獲取類上所以的變量的 Field，然後判斷如果該變量有標記 @PresenterVariable
註解的話，就取它的 Type 對應的 Name，這個 Name 的值是會與 canonicalName 一樣的，所以就可以通過它作爲 key 在 HashMap 中查找對應的實例，找到後通過 Field 的 set 方法給變量賦值。
還有一個類 PresenterDispatch ：
可以看到 attachView 和 detachView 等一些操作都是通過它來完成的，之所以需要這個類，是爲了隔離開 PresenterProviders 和 PresenterStore，免得耦合。
public class PresenterDispatch {
private PresenterProviders mProviders;
public PresenterDispatch(PresenterProviders providers) {
mProviders = providers;
}
public <P extends BasePresenter> void attachView(Context context, BaseContract.View view) {
PresenterStore store = mProviders.getPresenterStore();
HashMap<String, P> mMap = store.getMap();
for (Map.Entry<String, P> entry : mMap.entrySet()) {
P presenter = entry.getValue();
if (presenter != null) {
presenter.attachView(context, view);
}
}
}
public <P extends BasePresenter> void detachView() {
PresenterStore store = mProviders.getPresenterStore();
HashMap<String, P> mMap = store.getMap();
for (Map.Entry<String, P> entry : mMap.entrySet()) {
P presenter = entry.getValue();
if (presenter != null) {
presenter.detachView();
}
}
}
...
}
可以看到他裏面是拿到了 PresenterProviders 對象，然後再拿到存儲了 Presenter 實例的 HashMap，然後再進行操作。其他一些公共實現也可以這樣做。
整個過程就完成了，是不是很簡單。在實際的運用過程中可以根據自己額需要做對應的修改。