如果还没入门的，可以先去搜搜基本用法，本系列主要偏向原理
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(这部分还没搞懂)
