Dagger 2 系列（六） -- 进阶篇：Component 依赖、@SubComponent 与多 Component 下的 Scope 使用限制

• 该系列博客的最终目标： 搭建 MVP + Dagger2 框架
• 该系列博客包含以下几篇内容：

1. Dagger 2 系列（一） – 前奏篇：依赖注入的基本介绍
2. Dagger 2 系列（二） – 基础篇：@Inject、@Component
3. Dagger 2 系列（三） – 基础篇：@Module 和@Provides
4. Dagger 2 系列（四） – 基础篇：@Named 和 @Qualifier
5. Dagger 2 系列（五） – 进阶篇：@Scope 和 @Singleton
6. Dagger 2 系列（六） – 进阶篇：Component 依赖、@SubComponent 与多 Component 下的 Scope 使用限制

在这篇文章中你会看到什么：

1. Module 依赖 是什么
2. @SubComponent 是什么
3. Module 依赖和 @SubComponent 不同
4. 多 Component 下的 Scope 的使用限制

---

通过该系列的前几篇博客的学习，应该基本掌握了 Dagger2 的基本概念、基本使用方法、Scope 的概念等，这些足够我们搭建一个简单 Demo 去了解 Dagger2 ,但是在正常的业务开发中仅仅了解这些就显得力不从心。

在这篇中我们就来了解一下 Component 依赖、@SubComponent 的基本使用以及多 Compone 下的 Scope 的使用。

Component 依赖、@SubComponent 均是在多 Component 下通过两者来组织 Component 的依赖关系，具体的依赖关系的建立是根据业务依赖建立。

1. Component 依赖

Component 依赖 是通过 @Component 的注解中 dependencies 选项来标识的，意思是指 该 Component 依赖 dependencies 指定的 Component 。

举个例子，看以下代码：

• SubComponent

@Component(dependencies = AllComponent.class, modules = SubModule.class)
public interface SubComponent {
    void injectSubComponentActivity(ComponentDepActivity mDepActivity);
}

通过 dependencies = AllComponent.class 可知，SubComponent 依赖 AllComponent 。

• AllComponent

@Component(modules = AllModule.class)
public interface AllComponent {
    AllBean getAllBean();
}

如果要想让依赖 AllComponent 的 SubComponent 提供注入 AllModule 提供的 AllBean 实例对象，那么需要在 AllComponent 显式 的提供获得 AllBean 的方法，在本例中为 AllBean getAllBean()，否则将报出类似以下的错误：

错误: xxxx.AllBean cannot be provided without an @Inject constructor or from an @Provides- or @Produces-annotated method.
xxxx.ComponentDepActivity.mAllBean
[injected field of type: xxxx.AllBean mAllBean]

意思大致为 ComponentDepActivity 中不能正确的注入 AllBean 。

• ComponentDepActivity

public class ComponentDepActivity extends AppCompatActivity {

    @Inject
    SubBean mSubBean;
    @Inject
    AllBean mAllBean;
    AllComponent mAllComponent;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_component_dep);
        mAllComponent =  DaggerAllComponent.builder().allModule(new AllModule()).build();
        DaggerSubComponent.builder().allComponent(mAllComponent).build().injectSubComponentActivity(this);
        mSubBean.test();
        mAllBean.test();
    }
}

• 打印日志

E/TAG: test :  SubBean
E/TAG: test :  AllBean

具体代码见： Dagger2Demo

2. @SubComponent

@SubComponent 也是管理 Component 间的依赖，不同的是这种方式不需要 在被依赖的 Component 中显式的声明可以获取相应类实例的方法。通过 @SubComponent 来管理的 Component 之间是一种 继承关系，子 Component 理所当然的可以使用父 Component 的可以提供的类实例。

具体使用如下：

• SubComponent

@Subcomponent(modules = SubModule.class)
public interface SubComponent {
    void injectSubComponentActivity(ComponentSubActivity mDepActivity);
}

• AllComponent

@Component(modules = AllModule.class)
public interface AllComponent {
    SubComponent addSub(SubModule mSubModule);
}

要在父 Component 中显式的声明 子 Component ，其具体格式为 :

子Component 方法名 (子Component 对应的 Module);

• ComponentSubActivity

public class ComponentSubActivity extends AppCompatActivity {

    @Inject
    AllBean mAllBean;

    @Inject
    SubBean mSubBean;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_component_sub);
        AllComponent mAllComponent = DaggerAllComponent.builder().build();
        mAllComponent.addSub(new SubModule()).injectSubComponentActivity(this);
        mAllBean.test();
        mSubBean.test();
    }
}

• 运行结果

test :  AllBean
test :  SubBean

具体代码见：Dagger2Demo

3. Component 依赖 和 @SubComponent 的不同

关于两者的不同 Dependency injection with Dagger 2 - Custom scopes 有以下解释：

In general we have two ways to do this - with @Subcomponent annotation or with Components dependencies. The main difference between them is an objects graph sharing. Subcomponents have access to entire objects graph from their parents while Component dependency gives access only to those which are exposed in Component interface.

大致意思如下：

Subcomponent 可以访问到 父 Component 的全部对象图，而 Component 只可以访问到在所依赖的 Component 中暴露出来的类。

我们看另外一段解释：

And what is more important all scoping stuff happens here. All instances taken from UserComponent inherited from AppComponent still are singletons (in Application scope). But those which are produced by UserModule (which is a part of UserComponent) will be “local singletons” which live as long as this UserComponent instance.

大致意思如下：

更重要的是，所有范围内的事情都发生在这里。从AppComponent继承的UserComponent获取的所有实例仍然是单例（在应用程序范围内）。但是由UserModule（它是UserComponent的一部分）生成的那些将是“本地单例”，其存在与此UserComponent实例一样长。

我们也可以这样概括：子组件可以访问到父组件中提供的实例，并且该实例的scope 和父组件定义的scope 相同。

4. 多 Component 与 Scope 的使用

两者同时使用有以下限制：

1. Component 和他所依赖的 Component 不能公用相同的 Scope，每个Component 都要有自己的 Scope，编译时会报错，因为这有可能破坏Scope的范围。
2. @Singleton 的 Component 不能依赖其他 Component。正常来说使用 @Singleton 注解的Component应为全局的Component 。
3. 无Scope的Component不能依赖有Scope的Component，因为这也会导致Scope 被破坏。
4. Module 或通过构造函数注入依赖图的类和其 Component 必须使用相同的Scope 。

5. 总结

在日常的项目开发过程中，我们需要认真的考虑 Component 间的依赖关系，一般的，这些依赖关系的建立是根据具体的业务，就比如在 GitHubClient 项目中，UserComponent 依赖 AppComponent ，RepositoriesListActivityComponent 和 RepositoryDetailsActivityComponent 依赖 UserComponent ，这就是按照业务线： 库列表 和库详情 是依赖于 用户 的，而 用户 是被 App 所管理。

在多 Component 下 Scope 的使用是有限制的， 其最终的标准都是不可以导致 Scope 被破坏。

---

参考资料

Dependency injection with Dagger 2 - the API

Dependency injection with Dagger 2 - Custom scopes

Dependency injection with Dagger 2 - Custom scopes

Dagger2：Scope、Component 间依赖和 @SubComponent