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

本文链接：https://blog.youkuaiyun.com/ljx1400052550/article/details/146166248

前言：

在上一篇Dagger 2 系列（五）——进阶之@Scope 和 @Singleton，了解了@Scope 和 @Singleton，这篇文章，我们来了解一下Component 依赖、@SubComponent 与多 Component 下的 Scope 使用限制

在这篇文章中你会了解到：

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

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

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

1. Component 依赖

Component 依赖是通过 @Component 的注解中 dependencies 选项来标识的，意思是指该 Component 依赖 dependencies 指定的 Component 。
举个例子，看以下代码：

1.1 SubComponent

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

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

1.2 AllComponent

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

如果要想让依赖 AllComponent 的 SubComponent 提供注入 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 。

1.3 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

2. @SubComponent

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

具体使用如下：

2.1 SubComponent

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

2.2 AllComponent

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

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

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

2. 3 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

3. Component 依赖和 @SubComponent 的不同

关于两者的不同 Dependency injection with Dagger 2 - Custom scopes 有以下解释：
在这里插入图片描述
大致意思如下：

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 的使用

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

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