又有MVP新寫法了，這次我認為挺不錯的。

L_Xian發表於2018-07-27
MVP

EasyMvp

一個簡單強大且靈活的MVP框架。 專案地址：EasyMvp

特點

  • 一個 Activity 可以繫結多個 Presenter，以達到最大的複用功能。
  • 採用註解的方式實現依賴注入，減少耦合。
  • 可以靈活管理生命週期。
  • 使用起來方便簡單
  • 使用例子可以在專案中找到。

使用方法

（以簡單的登陸註冊為例）

  • 單個 Presenter 的情況
  1. 定義好你的 View 層介面方法並繼承一個公共的 BaseMvpView 如 LoginView:
public interface LoginView extends BaseMvpView {
    void loginSuccess();
}


複製程式碼
  1. 編寫 LoginPresenter 繼承 BasePresenter 並實現你的 Presenter 功能方法：
public class LoginPresenter extends BasePresenter<LoginView> {

    public void login() {
        mView.loginSuccess();
    }
}
複製程式碼
  1. 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() {

    }
}
複製程式碼

編寫 BasePresenter, BaseMvpView, BaseMvpActivity 等一些基礎類

上面例子中有用到 BasePresenter, BaseMvpView, BaseMvpActivity 等一些基礎類，這裡給出一種例子，使用者可根據自己需要去編寫。

  • BaseMvpView

BaseMvpView 是基礎的 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 方法例項化，傳入上下文引數。
  2. 通過檢視 inject 的實現，它裡面呼叫了構造方法，構造方法再呼叫 resolveCreatePresenter 和 resolvePresenterVariable 方法來進行對註解 @CreatePresenter 和 @PresenterVariable 的解析。
public static PresenterProviders inject(Context context) {
    return new PresenterProviders(context);
}

private PresenterProviders(Context context) {
    mContext = checkContext(context);
    resolveCreatePresenter();
    resolvePresenterVariable();
}
複製程式碼

下面簡單分析一下 PresenterProviders 具體實現：

  1. 關於註解的知識，可以看這篇文章，看完應該就懂了：深入理解Java註解型別(@Annotation)

  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 物件，所以這樣做的目的是為了可以統一管理和查詢。

  1. 然後到了主要的 PresenterProviders 類 這個類主要看幾個方法，第一個 resolveCreatePresenter() 方法：
public <P extends BasePresenter> PresenterProviders resolveCreatePresenter() {
    CreatePresenter createPresenter = mContext.getClass().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 方法：

public <P extends BasePresenter> PresenterProviders resolvePresenterVariable() {
    for (Field field : mContext.getClass().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(mContext, 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，然後再進行操作。其他一些公共實現也可以這樣做。

整個過程就完成了，是不是很簡單。在實際的運用過程中可以根據自己額需要做對應的修改。 喜歡就給個 Star 吧，歡迎留言提 Issues 和建議。

相關文章