开发模式 MVP - 基础框架搭建和分析

这期来看下 MVP ，如果不是很了解 MVP 是啥？请自行补一补基础知识，我其实也不太会，如果 RxJava 、OkHttp 、Retrofit 的运用和源码不是特别熟悉，也请去我之前的一些文章补一补，我其实也不太会。我们先来写一个简单版代码，然后分析其问题，运用之前的一些设计模式基础来一个一个解决。拿获取个人用户资料信息为例：

1.简单基础版本

UserInfoContract 类

/**
 * description: User Contract
 * author: Darren on 2017/12/16 11:15
 * email: [email protected]
 * version: 1.0
 */
public interface UserInfoContract {
    // user View 层
    interface UserInfoView {
        void onLoading();
        void onError();
        void onSucceed(UserInfo userInfo);
    }

    // user presenter 层
    interface UserInfoPresenter {
        void getUsers(String token);
    }

    //Model层定义接口,外部只需关心Model返回的数据,无需关心内部细节,如是否使用缓存
    interface UserInfoModel {
        UserInfo getUsers(String token) throws Exception;
    }
}

UserInfoModel 类：

/**
 * description: user model
 * author: Darren on 2017/12/16 11:18
 * email: [email protected]
 * version: 1.0
 */
public class UserInfoModel implements UserInfoContract.UserInfoModel {
    @Override
    public UserInfo getUsers(String token) throws Exception {
        // 模拟数据
        Thread.sleep(2000);
        return new UserInfo("Darren", "14726932514");
    }
}

UserInfoPresenter 类：

/**
 * description: User Presenter
 * author: Darren on 2017/12/16 11:26
 * email: [email protected]
 * version: 1.0
 */
public class UserInfoPresenter implements UserInfoContract.UserInfoPresenter {
    private UserInfoContract.UserInfoView userInfoView;
    private UserInfoContract.UserInfoModel userInfoModel;

    public UserInfoPresenter(UserInfoContract.UserInfoView userInfoView) {
        this.userInfoView = userInfoView;
        userInfoModel = new UserInfoModel();
    }

    @Override
    public void getUsers(String token) {
        // 应该是 RXJava + OkHttp + Retrofit + Dagger 结合
        userInfoView.onLoading();
        // 这里只用 RXJava 模拟一下
        Observable.just(token)
                .map(new Function<String, UserInfo>() {
                    @Override
                    public UserInfo apply(@NonNull String token) throws Exception {
                        return userInfoModel.getUsers(token);
                    }
                }).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<UserInfo>() {
                    @Override
                    public void accept(UserInfo userInfo) throws Exception {
                        userInfoView.onSucceed(userInfo);
                    }
                });
    }
}

UserInfoActivity 类：

/**
 * description: 用户信息 InfoActivity
 * author: Darren on 2017/12/16 11:15
 * email: [email protected]
 * version: 1.0
 */
public class UserInfoActivity extends AppCompatActivity implements UserInfoContract.UserInfoView {
    // user presenter
    private UserInfoContract.UserInfoPresenter presenter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        presenter = new UserInfoPresenter(this);
        presenter.getUsers("user token");
    }

    @Override
    public void onLoading() {
        // 正在联网获取加载中...
        Log.e("TAG", "加载中...");
    }

    @Override
    public void onError() {
        // 获取用户信息出错了
        Log.e("TAG", "出错了 ...");
    }

    @Override
    public void onSucceed(UserInfo userInfo) {
        // 显示用户信息或者做其他操作
        Log.e("TAG", "完成 ："+userInfo.toString());
    }
}

很多人说 MVP 好，我第一感觉是信了你的邪这么麻烦，做开发岂不是很蛋疼？其实有好处肯定有坏处，通过上面的事例我们就能看出不好的地方，这个类太多了，但是分层解耦了，不觉得对于后期维护和团队协作大有用处吗？但一下子从 MVC -> MVP 总会怪怪的，那我告诉你更蛋疼的事情

2.泛型构建基类

上面的这些代码会有很多问题，会有什么问题？会让你奔溃，这里我们来一个一个分析，一个一个解决，我们 new UserInfoPresenter() 的时候传递的是 this 也就是 activity，当我们去联网获取个人信息的时候，如果这个时候用户按了返回键退出了 activity，当数据返回的时候，如果恰好碰到 GC 回收了一些数据，那么会导致应用崩溃，所以我们必须解绑判断，看下修改后的 UserInfoPresenter 类：

/**
 * description: 解绑修改后 User Presenter
 * author: Darren on 2017/12/16 11:26
 * email: [email protected]
 * version: 1.0
 */
public class UserInfoPresenter implements UserInfoContract.UserInfoPresenter {
    private UserInfoContract.UserInfoView userInfoView;
    private UserInfoContract.UserInfoModel userInfoModel;

    public UserInfoPresenter() {
        userInfoModel = new UserInfoModel();
    }

    /**
     * 绑定和解绑
     *
     * @param userInfoView
     */
    public void attachView(UserInfoContract.UserInfoView userInfoView) {
        this.userInfoView = userInfoView;
    }

    public void dettachView() {
        this.userInfoView = null;
    }

    @Override
    public void getUsers(String token) {
        // 应该是 RXJava + OkHttp + Retrofit + Dagger 结合
        userInfoView.onLoading();
        // 这里只用 RXJava 模拟一下
        Observable.just(token)
                .map(new Function<String, UserInfo>() {
                    @Override
                    public UserInfo apply(@NonNull String token) throws Exception {
                        return userInfoModel.getUsers(token);
                    }
                }).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<UserInfo>() {
                    @Override
                    public void accept(UserInfo userInfo) throws Exception {
                        // 判断 userInfoView 是不是等于空
                        if (userInfoView != null)
                            userInfoView.onSucceed(userInfo);
                    }
                });
    }
}

在 Activity 的 finish 方法中解绑，这样能解决调奔溃的问题，但是新的问题又来了，每次都这么写岂不是很蛋疼？所以肯定要采用泛型和基类统一管理，这就要看我们的基础知识是不是牢固了，看下修改后的 UserInfoPresenter 类：

/**
 * description: 解绑 + 泛型 修改后 User Presenter
 * author: Darren on 2017/12/16 11:26
 * email: [email protected]
 * version: 1.0
 */
public class UserInfoPresenter extends BasePresenter<UserInfoContract.UserInfoView, UserInfoContract.UserInfoModel>
        implements UserInfoContract.UserInfoPresenter {

    @Override
    public void getUsers(String token) {
        // 应该是 RXJava + OkHttp + Retrofit + Dagger 结合
        if (view != null)
            view.onLoading();
        // 这里只用 RXJava 模拟一下
        Observable.just(token)
                .map(new Function<String, UserInfo>() {
                    @Override
                    public UserInfo apply(@NonNull String token) throws Exception {
                        return model.getUsers(token);
                    }
                }).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<UserInfo>() {
                    @Override
                    public void accept(UserInfo userInfo) throws Exception {
                        // 判断 userInfoView 是不是等于空
                        if (view != null)
                            view.onSucceed(userInfo);
                    }
                });
    }
}

这样看上去似乎简单了一些，但是我们发现每次调用 View 层的方法的时候，我们不得不判断一下 view 是不是等于空，这个也真是悲剧，所以我们又不得不解决一下，这就要看我们的基础知识是不是牢固了，采用动态代理轻松解决：

/**
 * description: 解绑 + 泛型 + 动态代理 修改后 Base Presenter
 * author: Darren on 2017/12/16 13:01
 * email: [email protected]
 * version: 1.0
 */
public class BasePresenter<V extends IView, M extends IModel> implements IPresenter<V> {
    // 一个是原始的 View ，一个是代理的 View
    private WeakReference<V> mView = null;
    private V mProxyView = null;
    protected M model = null;

    @Override
    public void attachView(V view) {
        this.mView = new WeakReference<>(view);
        // 动态代理
        mProxyView = (V) Proxy.newProxyInstance(view.getClass().getClassLoader(),
                view.getClass().getInterfaces(), new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        if (mView != null && mView.get() != null) {
                            return method.invoke(mView, args);
                        }
                        return null;
                    }
                });

        // 注入 Model，怎么注入，获取泛型的类型，也就是 M 的 class，利用反射new 一个对象
        try {
            ParameterizedType parameterizedType = (ParameterizedType) this.getClass().getGenericSuperclass();
            Class<M> modelClazz = (Class<M>) (parameterizedType.getActualTypeArguments()[1]);
            model = modelClazz.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void detachView() {
        this.mView = null;
    }

    public V getView() {
        return mProxyView;
    }
}

UserInfoActivity 类：

/**
 * description: 解绑 + 泛型 + 动态代理 修改后 用户信息 InfoActivity
 * author: Darren on 2017/12/16 11:15
 * email: [email protected]
 * version: 1.0
 */
public class UserInfoActivity extends BaseActivity<UserInfoPresenter, UserInfoContract.UserInfoView>
        implements UserInfoContract.UserInfoView {

    @Override
    protected void setContentView() {
        setContentView(R.layout.activity_main);
    }

    @Override
    protected void initData(Bundle savedInstanceState) {
        getPresenter().getUsers("user token");
    }

    @Override
    public void onLoading() {
        // 正在联网获取加载中...
        Log.e("TAG", "加载中...");
    }

    @Override
    public void onError() {
        // 获取用户信息出错了
        Log.e("TAG", "出错了 ...");
    }

    @Override
    public void onSucceed(UserInfo userInfo) {
        // 显示用户信息或者做其他操作
        Log.e("TAG", "完成 ：" + userInfo.toString());
    }
}

当然可能还需要涉及到一些数据恢复，如内存不足的情况下可能导致 Activity 数据保存恢复；可能还需要涉及到一些静态代理，因为不光要有 BaseActivity 肯定还要有 BaseFragment 等等一些其他 Base ，肯定也需统一处理；还可以结合 Dagger 注入等等。

所有分享大纲：Android进阶之旅 - 系统架构篇

视频讲解地址：周日晚八点