转发请注明出处：https://www.jianshu.com/p/b989e2cb88f6
Dagger2作为Android界最具杀伤力的匕首，本系列文章将用最通俗的语言带领你揭开它的真面目。
边缘OB：从零单排带你从低分局打到高分局，从First Blood(第一滴血)到Holy Shit(超越神的杀戮)，每盘Rampage(暴走)不在话下！
Android Dagger2 从零单排(一) 基础注解
Android Dagger2 从零单排(二) @Qualifier
Android Dagger2 从零单排(三) @Scope
Android Dagger2 从零单排(四) Dependencies与SubComponent
上一篇我们详细介绍了作用域@Scope的使用，本篇我们来研究Dependencies与SubComponent的用法。
在前几篇的例子里，@Component都是跟@Module一一对应的提供依赖，如果一个@Component需要用另一个@Component提供依赖，这种情况该如何处理？比如，在Activity注入的依赖，依赖于Applicaton维护的全局单例对象，可能会第一时间想到，先用全局@Component在Activity注入全局单例对象，在注入Activity依赖时把对象传进去......首先在Activity维护这个全局单例对象是毫无意义，仅作为注入时的依赖使用，再者如果需要更多的@Component提供依赖的时候，此时代码逻辑就会变得非常混乱，至少，我如果看到一个Activity有很多个@Component在注入依赖，我绝对会头大。
此时引出本文的主题，Dependencies与SubComponent，两者都能解决刚才的问题，但是两者处理的方式又大有不同。
例子一，我们先来了解Dependencies，中文翻译是依赖关系，我们可以理解为：@Component为其他@Component提供了依赖对象。
public class Father {
}
@Module
public class FatherModule {
@Provides
public Father provideFather() {
return new Father();
}
}
@Component(modules = FatherModule.class)
public interface FatherComponent {
Father offerFather();
}
public class Child {
public Child(Father father) {
}
}
@Module
public class ChildModule {
@Provides
public Child provideChild(Father father) {
return new Child(father);
}
}
@Component(modules = ChildModule.class, dependencies = FatherComponent.class)
public interface ChildComponent {
void inject(ChildActivity activity);
}
public class ChildActivity extends Activity {
@Inject
Child mChild;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_dagger);
FatherComponent fatherComponent = DaggerFatherComponent.create();
DaggerChildComponent.builder().fatherComponent(fatherComponent).build().inject(this);//Component类需要编译才会生成
((TextView) findViewById(R.id.text)).setText("注入成功 = " + mChild.toString());
}
}
例子中Child依赖于Father，最终为了注入Child，我们看下过程：
(1)在ChildComponent类的注解，用dependencies表示ChildComponent依赖于FatherComponent，可以使用FatherComponent显式暴露出来的依赖。
(2)在FatherComponent类，需要写抽象方法暴露依赖，例子中要提供Father实例，所以有个返回值为Father的方法，方法名字可以自己命名，看得懂就好，不被打就好...
(3)注入的时候，必须先实例FatherComponent，再当做参数实例ChildComponent进行注入，如果@Module是有参构造方法的，按照正常调用在build()方法调用前实例化即可。
注意：
(1)FatherComponent依然是可以独立作为一个容器注入依赖。
(2)无@Scope的@Component可以依赖有@Scope的@Component，有@Scope的@Component只能依赖有@Scope的@Component，并且两者的@Scope不能相同。
(3)@Singleton的@Component只能被依赖而不能依赖任何@Component。
总结，反正我是不太喜欢这种方式，需要在@Component暴露才能被依赖，我需要一种不暴露都能直接全部用的方式！简单！粗暴！
例子二，满足愿望来了，下面介绍SubComponent，子Component，可以理解为继承或者拓展的意思，先看例子：
public class Father {
}
@Module(subcomponents = ChildComponent.class)
public class FatherModule {
@Provides
public Father provideFather() {
return new Father();
}
}
@Component(modules = FatherModule.class)
public interface FatherComponent {
ChildComponent.Builder buildChildComponent();
}
public class Child {
public Child(Father father) {
}
}
@Module
public class ChildModule {
@Provides
public Child provideChild(Father father) {
return new Child(father);
}
}
@Subcomponent(modules = ChildModule.class)
public interface ChildComponent {
void inject(ChildActivity activity);
@Subcomponent.Builder
interface Builder {
ChildComponent build();
}
}
public class ChildActivity extends Activity {
@Inject
Child mChild;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_dagger);
FatherComponent fatherComponent = DaggerFatherComponent.create();
fatherComponent.buildChildComponent().build().inject(this);
((TextView) findViewById(R.id.text)).setText("注入成功 = " + mChild.toString());
}
}
例子中还是Child依赖于Father，最终为了注入Child，我们看下过程：
(1)在ChildComponent类的注解换成@Subcomponent表示是一个子@Component，@Subcomponent注解不会在编译后生成Dagger前缀的容器类，而是体现在父@Component的私有内部类，并且如何在父@Component中构建@Subcomponent都需要我们自己写...(这里有点无解，官网也只是说要你写，为啥写也没给原因，在我的构想，既然是继承关系，完全可以自动生成，反正父@Component的依赖是完全暴露的...)
(2)依葫芦画瓢，还记得通常注入的方法builder().build()，生成Builder对象，传入@Module对象，调用build()方法生成@Component实例，此时我们按着这个步骤：
2.1.在ChildComponent类写一个内部接口Builder，必须要注解成@Subcomponent.Builder表示是顶级@Subcomponent的内部类。
2.2.Builder里面有build方法，返回值是ChildComponent，此时ChildComponent改造完毕。
(3)刚才说过，@Subcomponent是父@Component的私有内部类，所以我们要让父@Component有能够生成@Subcomponent类的方法，所以在父@Component中写一个方法返回值是刚才的内部接口ChildComponent.Builder，到这步继承关系正式成立。
(4)把父@Component的依赖全部暴露给@Subcomponent，在FatherModule类的注解，用subcomponents来表示开放全部依赖给ChildComponent。除非继承之后，@Subcomponent注入依赖时没有使用@Component的依赖，仅用于各自注入使用，此时可以不加(例如在ChildActivity同时注入Father与Child，并且Father与Child都是无参构造，@Subcomponent的依赖没有使用父@Component的情况，第4步可忽略)。
(5)注入的时候，先实例FatherComponent，获取ChildComponent.Builder，获取ChildComponent实例最后注入。
整个编译过程，FatherComponent在检测到ChildComponent.Builder返回值方法，同时检测ChildComponent类与其内部类的注解，如果是@Subcomponent注解，会在FatherComponent的实现类里维护ChildComponent类与其内部类的实现类，如果ChildComponent使用了FatherComponent的依赖，则检测FatherModule有没有注解开放“权限”。
注意：
(1)@Subcomponent不能再使用dependencies依赖其他@Component。
(2)@Subcomponent同样也可以被继承。
(3)@Subcomponent可以使用父@Component所有依赖，父@Component只有@Subcomponent.Builder实例，而不能使用@Subcomponent的依赖。
(4)@Scope的使用同样继承关系中也是不能相同，但没有子类不能使用@Singleton的限制。
(5)如果@Subcomponent指向的@Module是有参构造方法，写法如下，并且需要在build()方法调用前实例@Module：
@Subcomponent.Builder
interface Builder {
ChildComponent build();
Builder requestModule(ChildModule module);
}
总结，个人感觉@Subcomponent的方式在实际应用比较常用，如前文说的，Activity的注入依赖于Application的单例的情况。
要放大招了，@Subcomponent还有一种写法，抽象工厂方法定义：
@Subcomponent(modules = ChildModule.class)
public interface ChildComponent {
void inject(ChildActivity activity);
}
@Component(modules = FatherModule.class)
public interface FatherComponent {
ChildComponent buildChildComponent();
//如果ChildModule是有参构造方法
//ChildComponent buildChildComponent(ChildModule childModule);
}
这种方式最狠，就只需要作以上修改即可，调用的时候还是先实例父@Component获取@Subcomponent注入，作为例子三在Demo展示。
此时ChildComponent没有Builder接口，也没有build()方法，看了编译出来的文件，@Subcomponent作为父@Component的内部类，Builder的构建方式被构造方法传入代替，最后还是与build()方法相同构建出ChildComponent对象。
两种写法比较，例子二是Dagger2推荐写法，标准的建造者模式，官方建议写法，例子三则是相对简单，个人比较喜欢直接粗暴的方式。
官网提及比较重要的知识点：
(1)刚才所指的@Scope的使用在继承关系中不能相同，指的是父类与子类之间，如果父类有多个子类，子类与子类之间是可以相同，看Dagger2官网例子：
@Singleton
@Component
interface RootComponent {
SessionComponent.Builder sessionComponent();
}
@SessionScope
@Subcomponent
interface SessionComponent {
FooRequestComponent.Builder fooRequestComponent();
BarRequestComponent.Builder barRequestComponent();
}
@RequestScope
@Subcomponent
interface FooRequestComponent {...}
@RequestScope
@Subcomponent
interface BarRequestComponent {...}
(2)使用Subcomponent的重要原因是封装应用的不同部分。父@Component负责维护共享的数据、对象，不同处则由各自的@Subcomponent维护，这跟Android封装Base公共类的思想类似。
(3)父子Component中的@Module，或Subcomponent的工厂方法定义的@Module，均不能定义重复的@Module，还是列出官方的例子：
@Component(modules = {RepeatedModule.class, ...})
interface ComponentOne {
ComponentTwo componentTwo(RepeatedModule repeatedModule); // COMPILE ERROR!
ComponentThree.Builder componentThreeBuilder();
}
@Subcomponent(modules = {RepeatedModule.class, ...})
interface ComponentTwo { ... }
@Subcomponent(modules = {RepeatedModule.class, ...})
interface ComponentThree {
@Subcomponent.Builder
interface Builder {
Builder repeatedModule(RepeatedModule repeatedModule);
ComponentThree build();
}
}
DaggerComponentOne.create().componentThreeBuilder()
.repeatedModule(new RepeatedModule()) // UnsupportedOperationException!
.build();
最后总结：比原本的计划发布时间推迟了几天，为了能更清晰的说明例子二的演变过程，我这人也不太会说话，如果有说不明白的地方，你**来打我啊！
Demo源码截我 对应daggerFour包名
Dagger2 GitHub地址
Dagger2 官网地址
所有的测试实例均基于2.15版本。
下一篇，我们来研究一些其余用得比较少但还是需要了解的Dagger2知识。