Dagger2解析2-Component的依赖关系
如果还没入门的,可以先去搜搜基本用法,本系列主要偏向原理
Dagger版本:2.11
上文简单讲解了最基本的用法和生成的代码解析,这里再次总结为一张图
这图不关注生成代码的部分Dagger2依赖注入的结构,必不可少的元素有三种(Module,Component,以及被注入的目标本身)
-
被注入的目标本身,对应上文中例子的Target,Target所需要的元素,
需要标记@Inject才能自动初始化,@Inject在Dagger2中一般标记构造方法和成员变量 -
Module可以说是原材料工厂,所有被注入元素的实现都是Module生成的,无论Target的依赖关系多复杂,只要原材料够,就能实现注入(例如图中MemberA的依赖A,B,C,由ModuleA和ModuleB一起才能够提供全),甚至这个原材料有多余的也不怕
-
具体的注入执行由Component完成(准确的说是里面的Injector完成)
总而言之,对于需要注入的目标类,Component只要能够提供足够的素材(目标里的整个依赖树),就可以实现注入,dagger生成代码的部分可以去看Dagger2解析-1
1.Component的依赖关系
和需要注入的目标一样,Component也有依赖关系(本身就是代表依赖关系的组件),包括
- 在@Module中,由@Provides注解的方法
- 任何类型,被@Inject注解构造函数
- 其他的组件
2.Component的依赖关系--Module
先来看看Module注解里的内容
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Module {
/**
* Additional {@code @Module}-annotated classes from which this module is
* composed. The de-duplicated contributions of the modules in
* {@code includes}, and of their inclusions recursively, are all contributed
* to the object graph.
* 就是Module还能再包括其他的Module
*/
Class<?>[] includes() default {};
/**
* Any {@link Subcomponent}- or {@code @ProductionSubcomponent}-annotated classes which should be
* children of the component in which this module is installed. A subcomponent may be listed in
* more than one module in a component.
*
* @since 2.7
* 其他子组件(实际上是继承该模块所在的组件,也就是父组件的依赖关系)
*/
@Beta
Class<?>[] subcomponents() default {};
}
简单的Module上一篇文章Dagger2解析-1已经提过
class Member @Inject constructor(val name: String)
@Module
class MemberModule {
@Provides
fun provideMember(): Member = Member("from module Module provider")
}
在这里例子中,你也能让这个Module的构造函数添加参数
@Module
class MemberModule(val name:String) {
@Provides
fun provideMember(): Member = Member(name)
}
这样的话,生成DaggerTargetComponent后,Builder需要传入的Module就得你自己创建了
val target = Target()
DaggerTargetComponent.builder()
.memberModule(MemberModule("from module constructor"))
.build()
.inject(target)
这里需要注意的是,和之前不同,Module在Dagger无法帮你创建的情况下,如果创建Builder时不传入这个Module,就会在运行时崩溃
关于Module添加SubComponent,这种子组件必须是用@SubComponent注解的,而且它的内部也必须拥有一个被@SubComponent.Builder注解的,这部分以后再详细介绍
2.1.多Module的情况
不多说,上代码
class MemberB @Inject constructor(val name: String)
class MemberA @Inject constructor(val name: String)
@Module
class MemberAModule(val name: String) {
@Provides
fun provideMemberA(): MemberA = MemberA(name)
}
@Module
class MemberBModule(val name: String) {
@Provides
fun provideMemberB(): MemberB = MemberB(name)
}
@Component(modules = arrayOf(MemberAModule::class, MemberBModule::class))
interface TargetComponent {
fun inject(target: Target)
}
class Target {
@Inject
lateinit var memberA: MemberA
@Inject
lateinit var memberB: MemberB
}
还是比较简单的,这里提下需要注意地方
- components所依赖的所有module里不能有重复的@Provides方法(重载,或者同返回类型的),这里还包括后面讲到的依赖的其他的Component也不能有重复的,因为Dagger无法判断你究竟想要那个作为依赖(也就是依赖迷失)
那么等待你的将会是无尽的编译错误
-
无用的依赖会生成过时的代码
强行多依赖一个MemberCModule
3.Component的依赖关系--Component
同样的,先看Component注解里的内容
@Retention(RUNTIME) // Allows runtimes to have specialized behavior interoperating with Dagger.
@Target(TYPE)
@Documented
public @interface Component {
/** 包含的module模块 */
Class<?>[] modules() default {};
/** 依赖的其他component组件 */
Class<?>[] dependencies() default {};
/** 关于builder的注解,这里先不关注它 */
@Target(TYPE)
@Documented
@interface Builder {}
}
可以看出Component不光能依赖Module,甚至还能依赖其他的组件,那么开始代码
class MemberA @Inject constructor()
/** 这里要让MemberB必须由其他组件提供,构造函数就不标注@Inject了 */
class MemberB constructor(val name: String)
class Target {
@Inject
lateinit var memberA: MemberA
@Inject
lateinit var memberB: MemberB
}
弄多一个组件SubComponent用来提供MemberB
@Module
class MemberBModule {
@Provides
fun provideMemberB(): MemberB = MemberB("memberB")
}
@Component(modules = arrayOf(MemberBModule::class))
interface SubComponent {
// 这里不用injectXxx()方法了,因为这个组件是作为TargetComponent的依赖组件存在的
// 定义这种返回MemberB类型的方法,其实就有点类似把Component当做Module用了,只不过不需要标注@Provides罢了
fun provideMemberB(): MemberB
}
然后是TargetComponent
@Component(dependencies = arrayOf(SubComponent::class))
interface TargetComponent {
fun inject(target: Target)
}
编译后,生成的DaggerTargetComponent
实际上就是按照依赖组件SubComponent中的方法生成的Provider<方法返回类型>(当然必须是SubComponent的依赖关系所能够提供的类型)
注入的代码:
val target = Target()
val subComponent = DaggerSubComponent.builder().build()
DaggerTargetComponent.builder().subComponent(subComponent).build().inject(target)
之前提过,依赖关系里只要能够提供足够的"材料",就可以完成注入,那么SubComponent里已经有了能够提供MemberB的MemberBModule了,是否可以不写那个fun provideMemberB(): MemberB
呢?把它注释掉试试
@Component(modules = arrayOf(MemberBModule::class))
interface SubComponent {
// fun provideMemberB(): MemberB
}
然而却并不可以
在这个例子中,TargetComponent并不能够拿到SubComponent里的MemberBModule,而且它本身的依赖关系中又无法或者不足以提供MemberB的Provider,所以就挂了
反过来说,就算TargetComponent里有别的module能够提供MemberB创建所依赖的元素,甚至是直接提供MemberB的方法,例如下面这个, 结果也是不能编译通过的
@Module
class MemberNameModule {
@Provides
fun provideMemberName(): String = "name from parent component"
@Provides
fun provideMemberB(): MemberB = MemberB(provideMemberName())
}
提示cannot be provided without an @Inject constructor or from an @Provides-annotated method.
或者是提示前面那种依赖迷失
这就表示依赖组件Component里面的依赖关系与组件是相互隔离的,或者说他们互是不可见的,这就好像两家公司合作生产一款产品一样,除非有约定,否则他们之间的供应商是不可能共同提供原材料生产的
依赖关系图说到隔绝,前面提到Module里也是可以包含Component的,那么结果会是怎样呢,下篇再细说
4.总结:
本篇主要还是上篇的一点扩展,从Component依赖关系的角度,分为Module和Component两个维度:
- Module内可以再包含其他的Module或者Component
- Component里可以依赖Module或者其他的Component
- ParentComponent里的SubComponent的依赖关系是互相隔绝的
- Module里的SubComponent(这部分还没搞懂)