以下内容为原创,欢迎转载,转载请注明

来自天天博客:http://www.cnblogs.com/tiantianbyconan/p/6266442.html

在Dagger 2中Activities和Subcomponents的多绑定

原文:http://frogermcs.github.io/activities-multibinding-in-dagger-2

几个月前,在MCE^3会议中,Gregory Kick在他的演讲中展示了一个提供Subcomponents(比如,为Activity)的新概念。新的方式给我们带来了一个创建不使用AppComponent对象引用(以前时Activities Subcomponents的工厂)的方式。为了让它成为现实,我们不得不等到了新的Dagger release版本:version 2.7

问题

在Dagger 2.7之前,创建Subcomponent(比如,AppComponent的subcomponent MainActivityComponent)我们必须要在父Component中声明它的工厂:

@Singleton
@Component(
modules = {
AppModule.class
}
)
public interface AppComponent {
MainActivityComponent plus(MainActivityComponent.ModuleImpl module); //...
}

多亏Dagger理解这个声明,MainActivityComponent能够访问从AppComponent的依赖。

有了这个,MainActivity中的注入看起来如下:

@Override
protected ActivityComponent onCreateComponent() {
((MyApplication) getApplication()).getComponent().plus(new MainActivityComponent.ModuleImpl(this));
component.inject(this);
return component;
}

这个代码的问题在于:

  • Activity依赖于AppComponent(通过((MyApplication) getApplication()).getComponent())返回 - 我们是否想要去创建Subcomponent,我们需要去访问父Component的对象)。

  • AppComponent必须要去声明所有Subcomponents(或者它们的builders),比如:MainActivityComponent plus(MainActivityComponent.ModuleImpl module);

Modules.subcomponents

从Dagger 2.7开始,我们有了一个新的方法来声明subcomponents的父级。@Module注解有一个可选的subcomponents属性,它可以得到subcomponents类的列表,它们应该是安装此module组件的子component。

Example:

@Module(
subcomponents = {
MainActivityComponent.class,
SecondActivityComponent.class
})
public abstract class ActivityBindingModule {
//...
}

ActivityBindingModuleAppComponent中被安装。这表示MainActivityComponentSecondActivityComponent两者都是AppComponent的Subcomponents。

Subcomponents的声明在这种方法中不需要明确地在AppComponent中进行声明(就像本章开头的代码)。

Activities的多绑定

让我们来看看我们怎么样使用Modules.subcomponents来构建Activities多绑定并且摆脱AppComponent对象传入Activity(这在这个演讲中也解释到)。我将只浏览代码中最重要的部分。整个实现已在Github中可用:Dagger2Recipes-ActivitiesMultibinding

我们的app包含两个屏幕:MainActivitySecondActivity。我们想要去给它们两者提供Subcomponents且并不传入AppComponent对象。

让我们从为所有Activity Components builders构建一个基本的接口来开始:

public interface ActivityComponentBuilder<M extends ActivityModule, C extends ActivityComponent> {
ActivityComponentBuilder<M, C> activityModule(M activityModule);
C build();
}

Subcomponents:MainActivityComponent的例子看起来如下:

@ActivityScope
@Subcomponent(
modules = MainActivityComponent.MainActivityModule.class
)
public interface MainActivityComponent extends ActivityComponent<MainActivity> { @Subcomponent.Builder
interface Builder extends ActivityComponentBuilder<MainActivityModule, MainActivityComponent> {
} @Module
class MainActivityModule extends ActivityModule<MainActivity> {
MainActivityModule(MainActivity activity) {
super(activity);
}
}
}

现在我们可以使用Subcomponents builders的Map来得到每一个Activity类的意图builder。让我们如下使用Multibinding特性:

@Module(
subcomponents = {
MainActivityComponent.class,
SecondActivityComponent.class
})
public abstract class ActivityBindingModule { @Binds
@IntoMap
@ActivityKey(MainActivity.class)
public abstract ActivityComponentBuilder mainActivityComponentBuilder(MainActivityComponent.Builder impl); @Binds
@IntoMap
@ActivityKey(SecondActivity.class)
public abstract ActivityComponentBuilder secondActivityComponentBuilder(SecondActivityComponent.Builder impl);
}

ActivityBindingModuleAppComponent中被安装。就如它被解释的那样,多亏MainActivityComponentSecondActivityComponent将会是AppComponent的Subcomponent。

现在我们可以注入Subcomponents builder的Map(比如,注入到MyApplication class):

public class MyApplication extends Application implements HasActivitySubcomponentBuilders {

    @Inject
Map<Class<? extends Activity>, ActivityComponentBuilder> activityComponentBuilders; private AppComponent appComponent; public static HasActivitySubcomponentBuilders get(Context context) {
return ((HasActivitySubcomponentBuilders) context.getApplicationContext());
} @Override
public void onCreate() {
super.onCreate();
appComponent = DaggerAppComponent.create();
appComponent.inject(this);
} @Override
public ActivityComponentBuilder getActivityComponentBuilder(Class<? extends Activity> activityClass) {
return activityComponentBuilders.get(activityClass);
}
}

我们创建了HashActivitySubcomponentBuilders接口作为额外的抽象(因为builders的Map不一定是注入到Appliction类的):

public interface HasActivitySubcomponentBuilders {
ActivityComponentBuilder getActivityComponentBuilder(Class<? extends Activity> activityClass);
}

然后最后在Activity class中进行注入的实现:

public class MainActivity extends BaseActivity {

    //...

    @Override
protected void injectMembers(HasActivitySubcomponentBuilders hasActivitySubcomponentBuilders) {
((MainActivityComponent.Builder) hasActivitySubcomponentBuilders.getActivityComponentBuilder(MainActivity.class))
.activityModule(new MainActivityComponent.MainActivityModule(this))
.build().injectMembers(this);
}
}

它非常类似于我们的第一个实现,但如上,最重要的事是我们不再传入ActivityComponent对象到我们的Activities中。

用例example —— instrumentation tests mocking

除了解耦和解决循环依赖(Activity <-> Application),这不是一个大的问题,尤其是在较小的项目/团队中,让我们思考一个这个实现有帮助的真实用例 —— 在instrumentation testing中的mocking依赖。

目前在Android Instrumentation测试中mocking依赖最著名的方式之一是使用DaggerMock(Github 项目地址)。虽然DaggerMock是一个强大的工具,但是非常难理解它面具之下是怎么工作的。其中有一些反射代码不容易被追踪。

在Activity中直接构建Subcomponent,而不需要访问AppComponent类给了我们一个方式来测试单独的Activity并从我们app的其它部分解耦。

听起来很酷,现在我们来看下代码。

在我们的instrumentation test中使用Applicaton类:

public class ApplicationMock extends MyApplication {

    public void putActivityComponentBuilder(ActivityComponentBuilder builder, Class<? extends Activity> cls) {
Map<Class<? extends Activity>, ActivityComponentBuilder> activityComponentBuilders = new HashMap<>(this.activityComponentBuilders);
activityComponentBuilders.put(cls, builder);
this.activityComponentBuilders = activityComponentBuilders;
}
}

putActivityComponentBuilder()方法给我们一个对给定Activity类替换ActivityComponentBuilder的实现的方法。

现在来看下我们Espresso Instrumentation Test例子:

@RunWith(AndroidJUnit4.class)
public class MainActivityUITest { @Rule
public MockitoRule mockitoRule = MockitoJUnit.rule(); @Rule
public ActivityTestRule<MainActivity> activityRule = new ActivityTestRule<>(MainActivity.class, true, false); @Mock
MainActivityComponent.Builder builder;
@Mock
Utils utilsMock; private MainActivityComponent mainActivityComponent = new MainActivityComponent() {
@Override
public void injectMembers(MainActivity instance) {
instance.mainActivityPresenter = new MainActivityPresenter(instance, utilsMock);
}
}; @Before
public void setUp() {
when(builder.build()).thenReturn(mainActivityComponent);
when(builder.activityModule(any(MainActivityComponent.MainActivityModule.class))).thenReturn(builder); ApplicationMock app = (ApplicationMock) InstrumentationRegistry.getTargetContext().getApplicationContext();
app.putActivityComponentBuilder(builder, MainActivity.class);
}

一步一步来:

  • 我们提供了MainActivityComponent.Builder的Mock和所有我们必须要mock的依赖(在本例中只是Utils)。我们mockedBuilder返回一个MainActivityComponent的一个自定义实现,它用于注入MainActivityPresenter(其中使用了mocked Utils)。

  • 然后我们的MainActivityComponent.Builder替换了在MyApplication(28行)中被注入的原始Builder:app.putActivityComponentBuilder(builder, MainActivity.class);

  • 最后测试 —— 我们mockUtil.getHardcodedText()方法。注入过程发生在Activity被创建(36行):activityRule.launchActivity(new Intent());接着在最后我们使用Espresso来检验结果。

以上就是全部。如你所见,几乎一切都发生在MainActivityUITest类中,而且代码相当简单和可读。

源码

如果你想自己去测试这个实现,源码与工作例子展示怎么去创建Activities Multibinding和在Instrumentation Tests中mock依赖见Github:Dagger2Recipes-ActivitiesMultibinding

感谢阅读!

作者

Miroslaw Stanek

Head of Mobile Development @ Azimo

> __[Android]使用Dagger 2依赖注入 - DI介绍(翻译):__

> __[Android]使用Dagger 2依赖注入 - API(翻译):__

> __[Android]使用Dagger 2依赖注入 - 自定义Scope(翻译):__

> __[Android]使用Dagger 2依赖注入 - 图表创建的性能(翻译):__

> __[Android]Dagger2Metrics - 测量DI图表初始化的性能(翻译):__

> __[Android]使用Dagger 2进行依赖注入 - Producers(翻译):__

> __[Android]在Dagger 2中使用RxJava来进行异步注入(翻译):__

> __[Android]使用Dagger 2来构建UserScope(翻译):__

> __[Android]在Dagger 2中Activities和Subcomponents的多绑定(翻译):__

[Android]在Dagger 2中Activities和Subcomponents的多绑定(翻译)的更多相关文章

  1. [Android]使用Dagger 2依赖注入 - 图表创建的性能(翻译)

    以下内容为原创,欢迎转载,转载请注明 来自天天博客:http://www.cnblogs.com/tiantianbyconan/p/5098943.html 使用Dagger 2依赖注入 - 图表创 ...

  2. [Android]在Dagger 2中使用RxJava来进行异步注入(翻译)

    以下内容为原创,欢迎转载,转载请注明 来自天天博客: # 在Dagger 2中使用RxJava来进行异步注入 > 原文: 几星期前我写了一篇关于在Dagger 2中使用*Producers*进行 ...

  3. Android 和 Dagger 2 中的依赖注入

    原文:Dependency Injection in Android with Dagger 2 作者:Joe Howard 译者:kmyhy 在现代开发团队中到处充斥着"你一定要用依赖注入 ...

  4. [Android]使用Dagger 2来构建UserScope(翻译)

    以下内容为原创,欢迎转载,转载请注明 来自天天博客:http://www.cnblogs.com/tiantianbyconan/p/6237731.html 使用Dagger 2来构建UserSco ...

  5. [Android]使用Dagger 2进行依赖注入 - Producers(翻译)

    以下内容为原创,欢迎转载,转载请注明 来自天天博客:http://www.cnblogs.com/tiantianbyconan/p/6234811.html 使用Dagger 2进行依赖注入 - P ...

  6. [Android]使用Dagger 2依赖注入 - DI介绍(翻译)

    以下内容为原创,欢迎转载,转载请注明 来自天天博客:http://www.cnblogs.com/tiantianbyconan/p/5092083.html 使用Dagger 2依赖注入 - DI介 ...

  7. [Android]使用Dagger 2依赖注入 - API(翻译)

    以下内容为原创,欢迎转载,转载请注明 来自天天博客:http://www.cnblogs.com/tiantianbyconan/p/5092525.html 使用Dagger 2依赖注入 - API ...

  8. [Android]使用Dagger 2依赖注入 - 自定义Scope(翻译)

    以下内容为原创,欢迎转载,转载请注明 来自天天博客:http://www.cnblogs.com/tiantianbyconan/p/5095426.html 使用Dagger 2依赖注入 - 自定义 ...

  9. Android 4.4(KitKat)中apk包的安装过程

    原文地址:http://blog.csdn.net/jinzhuojun/article/details/25542011 事实上对于apk包的安装.4.4和之前版本号没大的区别. Android中a ...

随机推荐

  1. CentOS7 yum安装配置

    一.安装必要包 yum install gcc 二.linux下安装 #下载 wget http://download.redis.io/releases/redis-3.0.0.tar.gz tar ...

  2. cgi创建web应用(一)之传递表单数据与返回html

    主旨: 0.环境说明 1.创建一个cgi本地服务 2.创建一个html表单页 3.创建一个对应的cgi 脚本文件 4.运行调试 0.环境说明: 系统:win7 32位家庭版 python:2.7 代码 ...

  3. CSS display:inline和float:left两者区别探讨

     本文和大家重点讨论一下CSS display:inline和float:left两者的区别,CSS display是指显示状态,inline表示内联,特点是紧贴着前一个内联元素,通常默认的内联元素有 ...

  4. Java遍历所有网卡打印对应IP

    import java.util.Enumeration; import java.net.*; public class Test { /** * @param args */ public sta ...

  5. python中 “与,或,异或”

    在python编程语言里面: 按位的运算,都按位的运算,都是把参加运算的数的二进制形式进行运算. 1.与运算:A与B值均为1时,A.B与的运算结果才为1,否则为0 (运算符:&) 2.或运算: ...

  6. hdu 3944 DP? 组合数取模(Lucas定理+预处理+帕斯卡公式优化)

    DP? Problem Description Figure 1 shows the Yang Hui Triangle. We number the row from top to bottom 0 ...

  7. uCGUI窗口初始化过程

    一.相关结构体和变量 重要的uCGUI系统全局变量 NextDrawWin                      下一个需要重绘的窗口句柄 WM__NumWindows       系统当前的总共 ...

  8. 开发设计模式(二) ActiveObject模式

    ActiveObject模式: ActiveObject模式和Command模式的配合使用是实现多线程控制的一项古老的技术,该模式有多种使用方式,为许多工业系统提供了一个简单的多任务核心. // 活动 ...

  9. 一步步学习NHibernate(3)——NHibernate增删改查

    请注明转载地址:http://www.cnblogs.com/arhat 在上一章中,我们配置了以下NHibernate的运行环境, 并介绍了NHibernate的中两个非常中重要的接口"I ...

  10. C++引用计数

    简介 引用计数就是对一个对象记录其被引用的次数,其的引用计数可加可减,那什么时候加什么时候减呢?所以引用计数的重点在于在哪里加,在哪里减: 加: 减: 实现 // // Ref.hpp // Ref ...