Dagger2解析2-Component的依赖关系

2017-11-18  本文已影响338人  大空ts翼

如果还没入门的,可以先去搜搜基本用法,本系列主要偏向原理

Dagger版本:2.11

上文简单讲解了最基本的用法和生成的代码解析,这里再次总结为一张图

这图不关注生成代码的部分

Dagger2依赖注入的结构,必不可少的元素有三种(Module,Component,以及被注入的目标本身)

总而言之,对于需要注入的目标类,Component只要能够提供足够的素材(目标里的整个依赖树),就可以实现注入,dagger生成代码的部分可以去看Dagger2解析-1

1.Component的依赖关系

和需要注入的目标一样,Component也有依赖关系(本身就是代表依赖关系的组件),包括

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
}

还是比较简单的,这里提下需要注意地方

强行弄多一个提供MemberB的方法
那么等待你的将会是无尽的编译错误

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两个维度:

上一篇下一篇

猜你喜欢

热点阅读