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无法判断你究竟想要那个作为依赖（也就是依赖迷失）

强行弄多一个提供MemberB的方法

那么等待你的将会是无尽的编译错误

无用的依赖会生成过时的代码

强行多依赖一个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(这部分还没搞懂)