首頁手記 Retrofit2-RxJava-Dagger2-MV...

Retrofit2-RxJava-Dagger2-MVP完美封裝

標簽：

Android

如果对 Retrofit2+RxJava 封装还不是很了解的话
可以参考下:
http://www.jianshu.com/p/17e3e3102c1f
如果对Dagger2 还不是很了解,可以参考下:
http://www.jianshu.com/p/cd2c1c9f68d4
如果对mvp还不是很了解,可以自己百度下,很多的,我就不贴出了.
下面我简单讲述下:
请先看下目录结构:

com└── javalong└── rrdm├── activity│   ├── component│   │   ├── LoginActivityComponent.java│   │   └── MainActivityComponent.java│   ├── iview│   │   ├── ILoginView.java│   │   └── IMainView.java│   ├── LoginActivity.java│   ├── MainActivity.java│   ├── module│   │   ├── LoginActivityModule.java│   │   └── MainActivityModule.java│   └── presenter│       ├── LoginPresenter.java│       └── MainPresenter.java├── app│   ├── annotation│   │   └── ActivityScope.java│   ├── AppBaseActivity.java│   ├── AppBaseApplication.java│   ├── component│   │   └── AppComponent.java│   ├── iview│   │   └── MvpView.java│   ├── module│   │   └── AppModule.java│   └── presenter│       └── AppPresenter.java└── retrofit├── ResponseMessageBean.java├── RetrofitHelper.java├── ServerApi.java├── TWGsonConverterFactory.java├── TWGsonRequestBodyConverter.java├── TWGsonResponseBodyConverter.java└── TWJavaCallAdapterFactory.java

这里我就不对mvp,dagger2和Retrofit2+Rxjava过多介绍了.这里就介绍下具体的封装.
我这里是一个Presenter和一个Activity(View)相互对应,所以我让Presenter直接在基类中注入.对其进行统一管理:
AppPresenter.Java:

/** 
 * Created by javalong on 16-12-27. 
 * presenter基类 
 */  public abstract class AppPresenter<V extends MvpView>{  
    @Inject  
    protected V mvpView;  
  
    public AppPresenter(V mvpView) {  
        this.mvpView = mvpView;  
    }  
  
    public abstract void attach();  
    public abstract void detach();  
}

AppBaseActivity.java--->所有Activity的基类,对presenter进行统一处理.

/** 
 * Created by javalong on 16-12-27. 
 */  
  public abstract class AppBaseActivity<T extends AppPresenter> extends AppCompatActivity {  
    @Inject  
    protected T mPresenter;  
  
    @Override  
    protected void onCreate(@Nullable Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        initInjects();  
        mPresenter.attach();  
    }  
  
    protected abstract void initInjects();  
  
    @Override  
    protected void onDestroy() {  
        super.onDestroy();  
        mPresenter.detach();  
    }  
  
    protected AppComponent getAppComponent(){  
        return AppBaseApplication.getInstance().getAppComponent();  
    }  
}

AppBaseActivity中引用了AppComponent.这个需要在AppBaseApplication进行初始化.Component是dagger2依赖注入的基础.

AppBaseApplication.java

/** 
 * Created by javalong on 16-12-27. 
 */  
  public class AppBaseApplication extends Application {  
  
    private static AppBaseApplication instance;  
  
    public static AppBaseApplication getInstance() {  
        return instance;  
    }  
  
    AppComponent appComponent;  
  
    public AppComponent getAppComponent() {  
        return appComponent;  
    }  
  
    @Override  
    public void onCreate() {  
        super.onCreate();  
        instance = this;  
        if (appComponent == null) {  
            appComponent = DaggerAppComponent.builder().appModule(new AppModule(this)).build();  
        }  
    }  
}

如果不熟悉Dagger2的童鞋,可能会发现没有DaggerAppComponent这个类,不要慌,请'Make Project'编译下项目.DaggerAppComponent会自动生成.DaggerAppComponent其实是根据我们写的AppComponent接口生成的一个类,下面我们先看下AppComponent.

@Singleton  @Component(modules = AppModule.class)  
public interface AppComponent {  
    Context getContext();  
    ServerApi getServerApi();  
}

AppComponent这个接口其实很简单.这里记得要加上@Scope注解(@Singleton是@Scope的一种)使Component和Module中provide出来的对象联系起来.
关于@Scope注解的含义我这里就不过多介绍了,大家可以参考我上面推荐的文章.写的很不错.
接下来看下AppModule中提供了哪些依赖

@Module  public class AppModule {  
  
    private Context mContext;  
  
    public AppModule(Context context) {  
        this.mContext = context;  
    }  
  
    @Provides @Singleton  
    Context provideContext(){  
        return mContext;  
    }  
  
    @Provides @Singleton  
    ServerApi provideServerApi(Context context){  
        RetrofitHelper.init(context);  
        return RetrofitHelper.getApi();  
    }  
  
}

这里的@Singleton 和前面AppComponent的@Singleton 相互连接,让我们造成了单例的假象.其实@Singleton并没有单例的作用,是因为
和AppComponent一起使用,AppComponent只创建了一次,所以产生'单例'这个现象.(我这里又重复得说了一边,汗~~)
AppComponent和AppModule请根据自己项目的详细情况来进行封装,由于我这个demo比较简单,所以只@Provides 了2个对象出来.

下面我来详细介绍下Activity和Presenter之间的封装.
首先我这里先说明下,我这里的一个Activity,对应着1个view,1个presenter,1个component,1个module.
可能封装的不是很好,没有领悟到mvp的精髓,但是对我来说更加清晰.
MainActivity.java

public class MainActivity extends AppBaseActivity<MainPresenter> implements IMainView{  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
        mPresenter.test();  
    }  
  
    @Override  
    protected void initInjects() {  
        DaggerMainActivityComponent.builder()  
                .appComponent(getAppComponent())  
                .mainActivityModule(new MainActivityModule(this))  
                .build()  
                .inject(this);  
    }  
  
  
    @Override  
    public void showMainMessage() {  
        ((TextView)findViewById(R.id.tv_test))  
                .setText("你好 dagger");  
        findViewById(R.id.bt_login)  
        .setOnClickListener(new View.OnClickListener() {  
            @Override  
            public void onClick(View v) {  
                LoginActivity.start(MainActivity.this);  
                MainActivity.this.finish();  
            }  
        });  
    }  
}

MainActivity必须继承AppBaseActivity,然后传入泛型,即对应的Presenter的类型.在initInjects中必须完成Dagger2的注入操作,因为在AppBaseActivity中的Presenter需要
注入,如果不注入,在基类中调用mPresenter.attach会出错.
当你使用Dagger2的时候,其实很明显会暴露他的一个缺点,必须要编译后,才能产生对应的Dagger**Component.当然相对于他的好处来讲,这点还是可以忍受的.
前面提到了必须要对基类中的Presenter进行注入,那么到底注入的是什么呢?这里我以MainPresenter为例.

public class MainPresenter extends AppPresenter<IMainView>{  
  
    @Inject  
    public MainPresenter(IMainView mvpView) {  
        super(mvpView);  
    }  
  
    @Override  
    public void attach() {  
  
    }  
  
    @Override  
    public void detach() {  
  
    }  
  
    public void test() {  
        mvpView.showMainMessage();  
    }  
}

MainActivityModule.java

@Module  public class MainActivityModule  {  
  
    private IMainView mainView;  
  
    public MainActivityModule(IMainView mainView) {  
        this.mainView = mainView;  
    }  
  
    @Provides @ActivityScope IMainView provideIMainView(){  
        return mainView;  
    }  
  
    /** 
     * 这种方式,和直接在MainPresenter构造方法上添加@Inject是一样的 
     * 二选一即可. 
     */  //    @Provides @ActivityScope MainPresenter provideMainPresenter(IMainView mainView){  //        return new MainPresenter(mainView);  //    }  }

看注释,这里有2种方式可以完成MainPresenter的注入,一种是直接在MainPreenter的构造方法上加上@Inject,一种是在对应的Module中使用
@Provides 把MainPresenter提供出来. 至于@ActivityScope其实是和前面@Scope一样的,我这里就不过多介绍了.
最关键的一步:
MainActivityComponent.java

@ActivityScope  @Component(dependencies = AppComponent.class,modules = MainActivityModule.class)  
public interface MainActivityComponent{  
    /** 
     * @param mainView 
     * 这里必须使用MainActivity,不能使用IMain接口 
     * 否则会造成@Inject注入失败 
     */  
    void inject(MainActivity mainView);  
}

必须在对应的Component提供注入方法(名字不一定叫inject).
MainActivity.java 部分代码

@Override  
   protected void initInjects() {  
       DaggerMainActivityComponent.builder()  
               .appComponent(getAppComponent())  
               .mainActivityModule(new MainActivityModule(this))  
               .build()  
               .inject(this);  
   }

这样才完成了注入.
在DaggerMainActivityComponent中会先对AppBaseActivity进行注入,然后再对MainActivity进行注入.
这里我简单的讲述了封装,如果还有什么不懂的地方可以再交流~~~github: https://github.com/javalong/Retrofit2-RxJava-Dagger2-MVP

作者：javalong
链接：https://www.jianshu.com/p/05a17f0ce606

點擊查看更多內容