MVP设计模式个人理解

MVP：Module View Presenter。

Module : 负责主要业务逻辑的实现，有个数据类处理，如网络请求或提交。

View：xml 及自定义的view，与用户交互的界面。但是MVP模式中View完全不与Model发生关系，不能直接获取Model中数据。

Presenter ：负责View 与 Module 的交互，获取两者对象，设定实现的方法，在用到时获取presenter的对象，调用想要处理的方法。方法内会调用Module中方法。可设定接口回调，在Module方法参数上多设置一个监听，处理完成逻辑，在重写方法后处理View逻辑。

如：
P层+V层（官方的实现方式）

interface Constract{
        interface BaseView{
            view相关处理
        }
        
        interface BasePresenter{
            逻辑处理
            如： ui界面  网络状态或是数据加载状态的更换
        }
}

将有关view 的处理放在view中，其他操作放在presenter层。可抽取Base，向下延伸。使用泛型<T extend BaseConstract.Presenter> 来实现。设置接口回调，执行对应子类或实现类的处理逻辑。

例子：
写法一：
Module:
/**
 * Module : 负责与model类及相关业务处理逻辑，比如网络请求获取数据，提交数据等等
 */
public interface IUser{
    //Module中想要处理的事情,比如登录
    void login（String name,String age,OnLoginListener listener）;
}
   // IUser 设定事情，IUserImpl 是其业务类。里面是具体实现。OnLoginListener 接口回调，view层创建，获取具体处理事件
public class IUserImpl implements IUser{
    @override
    public void login(String name,String age,OnLoginListener listener){
        //一些逻辑处理
        if(name!=null&&age!=null&&!name.isEmpty()&&name.equels(age)){
              log.d(TAG,"输出")
              listener.success();
        }else{
              listener.fail();
        }
    } 
}


/**
 *OnLoginListener listener : Module 实现类参数中设定的。根据业务逻辑处理一些相应的事情。如验证逻辑成功后调用处理成功方法，走P层方法
 */
public abstract class OnLoginListener{
   abstract void success();
    
   abstract void fail()
}


View：
/**
    View负责UI交互,获取UI中的数据或是更改UI
    Activity 实现这个类,重写逻辑。
*/
public interface MView{
    String getName();
    
    String getAge();
}

public class MainActivity implements MView{
    Presenters p;
    onCreate(){
        MView mView;
        IUserImpl iUser;
        p = new Presenters(mView,iUser);
        p.login();
    }
    
    @override
    public String getName(){
    return "";
    };
    @override
    public String getAge(){
     return "";
    };
}


Presenter:
/*
    可以这样直接写个presenter。还可以类似Module，设定个接口presenter，然后设定presenterImpl（具体业务） 实现接口
*/
public class Presenters{
    MView mView;
    IUserImpl iUser;
    public Presenters(MView mView,IUserImpl iUser){
        this.mView = mView;
        this.iUser = iUser;
    }
    
    /*
      对外暴露实现方法，Activity中获取这个类对象，调用此方法。相当于整个逻辑的入口。  
    */
    public login(){
        iUser.login(mView.getName,mView.getAge,new OnLoginListener(){
                    @override
                    void success(){
                        //验证成功后走这个方法
                    }
                    @override
                    void fail(){
                    
                    }
         });
    }
}


写法二：
Module：
/**
    Module : 负责与model类及相关业务处理逻辑，比如网络请求获取数据，提交数据等等
    
    与类型一样,重复代码
*/
public interface IUser{
    //Module中想要处理的事情,比如登录
    void login（String name,String age,OnLoginListener listener）;
}
   // IUser 设定事情，IUserImpl 是其业务类。里面是具体实现。OnLoginListener 接口回调，view层创建，获取具体处理事件
public class IUserImpl implements IUser{
    @override
    public void login(String name,String age,OnLoginListener listener){
        //一些逻辑处理
        if(name!=null&&age!=null&&!name.isEmpty()&&name.equels(age)){
              log.d(TAG,"输出")
              listener.success();
        }else{
              listener.fail();
        }
    } 
}


/**
 *OnLoginListener listener : Module 实现类参数中设定的。根据业务逻辑处理一些相应的事情。如验证逻辑成功后调用处理成功方法，走P层方法
 */
public abstract class OnLoginListener{
   abstract void success();
    
   abstract void fail()
}


Presenter+View   Constract：


/**
View 和 Presenter 都设定到一个统一接口Constract中
创建BaseConstract
*/
public interface BaseConstract{
    interface BaseView{
        String getName();
    
        String getAge();
    }
    
    interface BasePresenters{
         void attachView();
        
         void login();
    }
}


Presenter:
public abstract class BasePresenters<T:BaseConstract.BaseView> implements BaseConstract.BasePresenters{
        public T mView =null;//可设定泛型，约束变量类型，获取BaseView 相关子类view
                                          
       @override
       public void attachView(T view){
            this.mView = view;       
       }     
}
                                     
 public class DemoPresenter<ChildBaseView> extend BasePresenters(){
       IUserImpl iuser;
       public DemoPresenter( IUserImpl iuser){
           this.iuser = iuser;
       }                              
                 
                                     
       @override
       public void login(){
            //实现  
            iuser.login(mView.getName(),mView.getAge(),new OnLoginListener listener(){
                    @override
                    void success(){
                        //验证成功后走这个方法
                    }
                    @override
                    void fail(){
                    
                    }                                
            })
       }
 }


View：
public abstract class BaseView implements BaseConstract.BaseView{
         
}
                                     
 public class ChildBaseView extend BaseView(){
       @override
       public void getName(){
            //实现                         
       }
       @override
       public void getAge(){
            //实现                         
       }
 }

以上代码是在记事本中写的，大体例子意思是这样。

MVP设计模式个人理解

MVP：Module View Presenter。

猜你喜欢