Android 运用泛型的MVP架构

entity相关的类

public class BaseEntity {
    private int code;
    private boolean success;
    private String error;

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public boolean isSuccess() {
        return success;
    }

    public void setSuccess(boolean success) {
        this.success = success;
    }

    public String getError() {
        return error;
    }

    public void setError(String error) {
        this.error = error;
    }
}

public class UserInfo extends BaseEntity {
    private String compant;
    private String name;

    public UserInfo(){

    }
    public UserInfo(String compant,String name){
        this.compant = compant;
        this.name = name;
    }

    public String getCompant() {
        return compant;
    }

    public void setCompant(String compant) {
        this.compant = compant;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }


    @Override
    public String toString() {
        return "UserInfo{" +
                "compant='" + compant + '\'' +
                ", name='" + name + '\'' +
                '}';
    }
}

运用泛型的基类

先定义V层、P层、M层的基类
1、BaseModel
2、BasePresent
3、BaseView

//接收P层传给他的需求
public abstract class BaseModel<P extends BasePresent ,CONTRACT> {
    //业务接收Present调用契约合同（接口中的方法）responseRequest(T t)
    public P p;

    public BaseModel(P p) {
        this.p = p;
    }
    public abstract CONTRACT getContract();
}

//present 基类
public abstract class BasePresent<V extends BaseView ,M extends BaseModel,CONTRACT>  {
    public M m;
    public WeakReference<V> weakReference;//虚引用的方式持有V层的引用

    public BasePresent() {
        m = getModel();
    }

    public void bindview(V v){
        weakReference = new WeakReference<>(v);
    }
    public void unbindview() {
        if (weakReference !=null){
            weakReference.clear();
            weakReference = null;
            System.gc();
        }
    }
    //获取View  p---v
    public V getview(){
        if (weakReference!= null){
            return weakReference.get();
        }
        return null;
    }

    public abstract CONTRACT getContract();

    public abstract M getModel();
}

//定义View层基类，继承Activity
public abstract class BaseView<P extends BasePresent ,CONTRACT> extends Activity {
    public P p;

    @Override
    protected void onCreate( Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //弱引用
        p = getPresent();
        //绑定
        p.bindview(this );
    }
    //让P层做什么
    public abstract CONTRACT getContract();

    //从子类中获取具体的契约
    public abstract P getPresent();

    public void error(Exception e){}

    @Override
    protected void onDestroy() {
        super.onDestroy();
        p.unbindview();
    }
}

定义Login功能实现的类

将Model层、View层、present层协商的共同业务，封装成接口

//将Model层、View层、present层协商的共同业务，封装成接口
//契约 合同
public interface LoginContract {

    interface Model{
        //Model 层完成具体方法实现----------2
        void executeLogin(String name,String pwd);

    }
    interface View<T extends BaseEntity>{
        //请求结果往往是javabean----------4
        void handleRequest(T t);
    }
    interface Present<T extends BaseEntity>{
        //登录请求（接受到view层的指令，可以自己做，也可以Model层做）----------1
        void requestLogin(String name,String pwd);

        //结果响应（接收到Model层的返回结果，通知View层刷新UI）----------3
        void responseRequest(T t);
    }
}

Login功能在V层中的实现

public class MainActivity extends BaseView<LoginPresent, LoginContract.View> {
    EditText editText_name;
    EditText editText_pwd;
    Button button;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_login);
        Init();
        InitListener();
    }

    private void Init() {
        editText_name = findViewById(R.id.login_name);
        editText_pwd = findViewById(R.id.login_pwd);
        button = findViewById(R.id.login_onclick);
    }

    public void doLoginAction(View view) {
        String name = editText_name.getText().toString().trim();
        String pwd = editText_pwd.getText().toString().trim();
        p.getContract().requestLogin(name,pwd);
    }
      @Override
    public LoginContract.View getContract() {
        return new LoginContract.View<UserInfo>() {
            @Override
            public void handleRequest(UserInfo userInfo) {
                if (userInfo!= null){
                    Toast.makeText(MainActivity.this,"登录成功",Toast.LENGTH_LONG).show();
                }else {
                    Toast.makeText(MainActivity.this,"登录失败",Toast.LENGTH_LONG).show();
                }
            }
        };
    }

    @Override
    public LoginPresent getPresent() {
        return new LoginPresent();
    }
}

   Login功能在Present层中的实现。
   在Google的官方Demo中，有在Present层中处理逻辑（网络请求/下载、图片加载等）。所以在Present层中有三种处理风格：1、自己处理相关逻辑；2、转发给Model层处理相关逻辑；3、让功能模块处理相关逻辑。

这里只做转发处理。

public class LoginPresent extends BasePresent<MainActivity, LoginModel, LoginContract.Present> {
    @Override
    public LoginContract.Present<UserInfo> getContract() {
        return new LoginContract.Present<UserInfo>() {
            @Override
            public void requestLogin(String name, String pwd) {
                //三种风格，要么不做事只转发，要么拼命做事
                m.getContract().executeLogin(name,pwd);
                //第二种，让功能模块去工作（library:下载，网络请求，图片加载）
                //第三种P层自己处理
            }

            @Override
            public void responseRequest(UserInfo userInfo) {
                getview().getContract().handleRequest(userInfo);
            }
        };
    }

    @Override
    public LoginModel getModel() {
        return new LoginModel(this);
    }
}

Login功能在Model层中的实现

//接收到Present层给她的需求,并返回处理结果
public class LoginModel extends BaseModel<LoginPresent,LoginContract.Model> {
    public LoginModel(LoginPresent loginPresent) {
        super(loginPresent);
    }
//接收到Present层给她的需求
    @Override
    public LoginContract.Model getContract() {
        return new LoginContract.Model() {
            @Override
            public void executeLogin(String name, String pwd) {
                //简单的判断逻辑
                if ("name".equalsIgnoreCase(name) && "123".equals(pwd)){
                    //返回处理结果给Present层
                    p.getContract().responseRequest(new UserInfo("CSDN","csdn123"));
                }else {
                    p.getContract().responseRequest(null);
                }
            }
        };
    }
}

总结

在运用泛型的MVP架构中也脱离不了接口的定义和使用。
1、定义Model、Present、View层的Base类
2、BaseModel中接收P层需求，通过契约合同CONTRACT传入子类需要实现的接口
3、BasePresent中接收CONTRACT传入子类需要实现的接口