如何使用MVP+Dagger2+RxJava+Retrofit开发(1)

时间:2022-04-22
本文章向大家介绍如何使用MVP+Dagger2+RxJava+Retrofit开发(1)，主要内容包括概述、如何在MVP中使用、基本概念、基础应用、原理机制和需要注意的事项等，并结合实例形式分析了其使用技巧，希望通过本文能帮助到大家理解应用这部分内容。

概述

  • 在2016年5，6月份开始在知乎上看到开发方法，那时候记得是看mvc,mvp,mvvm这三种开发模式区别，后面进一步了解到google在github上开源了使用这3种模式进行Android开发的demo.不同的项目有不同的情况，开发项目是找一个最适合的，而不是性能最好，开发时间最短等。
  • MVP是一种开发模式或者架构，RxJava与Retrofit是两个库，前面的是异步的库，后面的是提供Restful请求的库，这两个库都是为了MVP开发模式服务的。当然，他的适用场景是业务逻辑复杂的项目，也就是解决控制层耦合性太高。
  • Dagger2库，RxJava库，Retrofit库会进行简单介绍，了解其运作的机制。

Dagger2库

关键概念

  • Inject--你用它告诉Dagger这个类或者字段需要依赖注入
  • Module-- Modules类里面的方法专门提供依赖，所以我们定义一个类，用@Module注解，这样Dagger在构造类的实例的时候，就知道从哪里去找到需要的依赖
  • Provide--在modules中，我们定义的方法是用这个注解，以此来告诉Dagger我们想要构造对象并提供这些依赖。
  • Component--Components从根本上来说就是一个注入器，也可以说是@Inject和@Module的桥梁，它的主要作用就是连接这两个部分。 Components可以提供所有定义了的类型的实例，比如：我们必须用@Component注解一个接口然后列出所有的@Modules组成该组件，如 果缺失了任何一块都会在编译的时候报错。所有的组件都可以通过它的modules知道依赖的范围。
  • Scope-- Scopes可是非常的有用，Dagger2可以通过自定义注解限定注解作用域。后面会演示一个例子，这是一个非常强大的特点，因为就如前面说的一样，没 必要让每个对象都去了解如何管理他们的实例。在scope的例子中，我们用自定义的@PerActivity注解一个类，所以这个对象存活时间就和 activity的一样。简单来说就是我们可以定义所有范围的粒度(@PerFragment, @PerUser, 等等)。
  • Qualifier--当类的类型不足以鉴别一个依赖的时候，我们就可以使用这个注解标示。例如：在Android中，我们会需要不同类型的context，所以我们就可以定义 qualifier注解“@ForApplication”和“@ForActivity”，这样当注入一个context的时候，我们就可以告诉 Dagger我们想要哪种类型的context。

如何在MVP中使用

创建BasePresenter与BaseView

  • MVP架构中M与V通过P进行交互，activity用来显示不再负责具体业务逻辑，职责明确，便于测试；
  • BasePresenter与BaseView抽象出视图中公共的行为，可以在activity或者fragment中实现BaseView的子类，渲染界面；
public interface BasePresenter {

    //订阅
    void subscribe();

    //解订
    void unsubscribe();
}

public interface BaseView<T> {

    void  setPresenter(T presenter);//view中设置处理器

}

创建处理器(MVP中的P)

1.新建MineContract，view与presenter的抽象接口集合，相当于讲下要去做那些事情

public interface MineContract {

    interface View extends BaseView<Presenter>{

        void login_success(String response);

        void login_failure(String msg);

        void network_exception(int errcode);

        void network_normal();

    }

    interface Presenter extends  BasePresenter{

        void login(User user);

    }

2.新建MinePresenter，实现MineContract.Presenter接口方法，相当于事情具体怎么去做

public class MinePresenter implements MineContract.Presenter {

    private final static String TAG="MinePresenter";

    private MineContract.View mView;

    
    public MinePresenter(MineContract.View view) {
        this.mView = view;
        this.mView.setPresenter(this);
    }

    @Override
    public void subscribe() {

    }

    @Override
    public void unsubscribe() {

    }

    @Override
    public void login(User user) {

        new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                mView.login_success("success");
                Log.d(TAG,"logined");
            }
        },500);

    }
}

创建实体(MVP中的M)

创建User类，作为登录测试

public class User {

    private String uId;

    private  String uName;

    private String uPwd;

    private String uType;

    private String uLevel;

   //省略set与get方法
}

创建界面(MVP中的V)

  • 创建MainActivity，采用嵌套fragment方式，继承自FragmentActivity 
public class MainActivity extends FragmentActivity  {

    private FragmentManager mFragMgr;

    @Inject
     MinePresenter presenter;

    private MineFragment mineFragment;

    private final String MINE = "Mine";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mFragMgr = getSupportFragmentManager();
        initFragments();
        showFragments(MINE,true);
    }

 private void initFragments() {
        mineFragment = new MineFragment();
    }

    private void showFragments(String tag, boolean init) {
        FragmentTransaction trans = mFragMgr.beginTransaction();
        if (init) {
            trans.add(R.id.main_content, getFragmentByTag(tag), tag);
            trans.addToBackStack(tag);
        } else {
            trans.replace(R.id.main_content, getFragmentByTag(tag), tag);
        }
        trans.commit();
    }

    private Fragment getFragmentByTag(String tag) {
        if (MINE.equals(tag)) {
            return mineFragment;
        }
        return null;
    }


}
  • 创建MineFragment，需要实现implements MineContract.View接口
public class MineFragment extends Fragment implements MineContract.View {
    //省略部分代码  

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if (getArguments() != null) {
            mParam1 = getArguments().getString(ARG_PARAM1);
            mParam2 = getArguments().getString(ARG_PARAM2);
        }
    }

    @Override
    public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        uName = (LikeEditText) view.findViewById(R.id.uName);
        uPwd = (LikeEditText) view.findViewById(R.id.uPwd);
        loginBtn = (Button) view.findViewById(R.id.login_btn);
        loginBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                User user=new User();
                user.setuName(uName.getText().toString());
                user.setuPwd(uPwd.getText().toString());
                minePresenter.login(user);
            }
        });
    }

前面讲的都是mvp架构基本搭建，下面是如何运用dagger2；

创建提供应用实例的AppComponent

一个应用在创建时会产生唯一的Application对象，可以在应用的onCreate函数创建，下面有几个步骤：

1.创建提供应用对象的Component

1.1创建提供应用对象的Module

@Module
public class AppModule {

    private  Context mContext;

    public AppModule(Context context){
        this.mContext=context;
    }

    @Provides
    public Context provideContext(){
        return this.mContext;
    }


}

1.2创建AppComponent为其他Component提供依赖

@Component(modules = AppModule.class)
public interface AppComponent {
 Context getContext();
}
2.构建AppComponent的实例
public class SampleApplication extends Application {

    private AppComponent appComponent;

    private static SampleApplication mInstance;

    @Override
    public void onCreate() {
        super.onCreate();
        mInstance=this;
        appComponent=DaggerAppComponent.builder().appModule(new AppModule(this)).build();
    }

    public static SampleApplication  getInstance(){
        return mInstance;
    }

    public AppComponent getAppComponent(){
        return  appComponent;
    }

}

在MainActivity如何自动注入MinePresenter

  • 1.修改MinePresenter代码-构造方法注入
  @Inject
    public MinePresenter(MineContract.View view) {
        this.mView = view;
        this.mView.setPresenter(this);
    }
  • 2.创建MinePresenterModule-提供MineContract.View实例
@Module
public class MinePresenterModule {

    private final MineContract.View mView;

    public MinePresenterModule(MineContract.View view) {
        mView = view;
    }

    @Provides
    MineContract.View provideStatisticsContractView() {
        return mView;
    }
}
  • 3.修改MainComponent
@Component(dependencies = AppComponent.class,modules = MinePresenterModule.class)
public interface MainComponent {
    MineFragment inject(MineFragment mineFragment);

    MainActivity inject(MainActivity mainActivity);
}
  • 4.修改MainActivity代码-成员变量注入与注入MineFragment
 @Inject
  MinePresenter presenter;

 private void initFragments() {
        mineFragment = new MineFragment();
         DaggerMainComponent.builder().minePresenterModule(new MinePresenterModule(mineFragment)).appComponent(SampleApplication.getInstance().getAppComponent()).build().inject(this);

    }

以上所有的步骤已完成，编译项目，dagger2自动生成相关类，并完成注入。

总结

随机文章
java知识点必读
最近更新