Dagger2 系列文章

Dagger2 知识梳理(1) - Dagger2 依赖注入的两种方式
Dagger2 知识梳理(2) - @Qulifier 和 @Named 解决依赖注入迷失
Dagger2 知识梳理(3) - 使用 dependencies 和 @SubComponent 完成依赖注入
Dagger2 知识梳理(4) - @Scope 注解的使用

一、资料推荐

最近这几天一直在看有关Dagger2有关的文章，感觉就是这东西真难用、真难懂，数次想要放弃，还好有网上大神的教程帮助，模模糊糊总算能把基本的几个概念跑通了。

这里首先推荐牛晓伟的下面一系列文章，其将Dagger2的基本思想讲的通俗易懂：

Android：dagger2 让你爱不释手 - 基础依赖注入框架篇
Android：dagger2 让你爱不释手 - 重点概念讲解、融合篇
Android：dagger2 让你爱不释手 - 终结篇

接下来是结合具体例子进行分析的两篇文章，适合在理解基本思想的前提下对Dagger2有个更直观的认识：

AItsuki 的 Dagger2 最清晰的使用教程
zFxiang_ 的 Dagger2 入门，以初学者角度

还有前同事 Johnny Shieh 的Dagger2系列，里面提到了后来新增的一些用法：

Dagger 2 完全解析（一），Dagger 2 的基本使用与原理
Dagger 2 完全解析（二），进阶使用 Lazy、Qualifier、Scope 等
Dagger 2 完全解析（三），Component 的组织关系与 SubComponent
Dagger 2 完全解析（四），Android 中使用 Dagger 2
Dagger 2 完全解析（五），Kotlin 中使用 Dagger 2

了解完以上这些基础文章，就可以尝试去啃一下官方的英文文档了，里面介绍了如何在Android中使用Dagger2，但是不得不说，写的真是晦涩难懂，网上找了很久，也没有把AndroidInjector说明白的：

Dagger & Android
User's Guide

虽然网上的例子很多，但是我们花了那么多时间去看这些文章，本质上还是要用到项目中，这里肯定要优先推荐Google的官方架构Demo：todo-mvp-dagger2，这里面涉及到了很多新的注解用法。

二、导入依赖

在导入依赖的时候，需要考虑当前工程中使用的Gradle插件的版本。如果当前的插件版本小于2.2，那么需要引入 android-apt 插件，Dagger2 入门，以初学者角度中就是用的这种方式。

在示例代码中，根目录下的build.gradle文件配置的Gradle插件版本为2.3.3：

因为大于 2.2，所以我只需要在 app模块中的 build.gradle文件中，引入以下两个依赖就好了：

Dagger2 知识梳理(1) - Dagger2 依赖注入的两种方式_第1张图片

三、依赖注入的两种方式

下面，我们用一个简单的例子来演示使用Dagger2完成依赖注入的两种方式：在进行数据的读写时，我们可以通过数据管理者DataRepository来管理数据源，外部通过调用这个数据仓库提供的方法来读写数据，完整的源码可以查看 Dagger2Sample 中第一章。

对于这些数据源的赋值，就可以采用依赖注入的方式来实现。

DataRepository：目标类。
DataRepository内部的数据源：目标依赖类。

3.1 在目标依赖类构造函数上使用 @Inject

我们先看第一种方法，通过“在目标依赖类构造函数上使用@Inject，来完成依赖注入”。

第一步

先创建一个LocalSource表示本地的数据源，并在它构造函数上加上@Inject注解。这样Dagger2在尝试创建一个LocalSource对象赋值给DataRepository中的mLocalSource变量时，就会调用这个构造函数。

public class LocalSource {

    @Inject
    public LocalSource() {}

    public String getData() {
        return "使用在构造函数上使用 @Inject 的方式，获取到了本地数据";
    }
}

第二步

接下来需要声明一个用@Component注解的接口或者抽象类，用于注入依赖，这个接口的方法名可以为任意值，但是其形参必须是目标类的具体类型，而返回值只能为void或者目标类的具体类型。

@Component
public interface SourceComponent {
    public void inject(DataRepository dataRepository);
}

第三步

做好前期这些准备，接下来需要按顺序进行以下几步操作：

在目标类中需要被注入的变量上加上@Inject注解。
make一下工程，让Dagger2根据SourceComponent中声明的接口创建一个DaggerSourceComponent实现类。
在需要注入的时候调用DaggerSourceComponent.create().inject(this)方法，完成依赖注入。

DataRepository文件如下所示：

public class DataRepository {

    @Inject
    LocalSource mLocalSource;

    public DataRepository() {
        DaggerSourceComponent.create().inject(this);
    }

    public String getData() {
        return mLocalSource.getData();
    }

}

流程如下图所示：

Dagger2 知识梳理(1) - Dagger2 依赖注入的两种方式_第2张图片

3.2 使用 @Module

3.1的实现方式有一个缺点，就是需要修改构造函数，但是这对于一些第三方的对象来说是不可能做到的，此时就需要通过另一种方法来创建对象。

我们通过下面这个例子来演示：在DataRepository中实例化一个远程数据源RemoteSource。

第一步

在RemoteSource的构造函数上不再需要添加@Inject注解：

public class RemoteSource {

    public String getData() {
        return "使用 @Module 的方式，获取到了网络数据";
    }
}

第二步

接下来创建一个RemoteSourceModule类，用于提供RemoteSource对象。Dagger2会根据它声明的方法的返回值类型去识别提供的是哪种类型的对象，这里有两点需要注意：

该Module类需要加上@Module注解
提供RemoteSource的方法需要加上@Provides注解

@Module
public class RemoteSourceModule {

    @Provides
    public RemoteSource provideRemoteSource() {
        return new RemoteSource();
    }
}

第三步

在SourceComponent中，我们需要告诉它哪些Module可以用来创建目标类所依赖的实例，这里和第一种方式的区别就是需要在@Component后面加上用来创建依赖实例的Module类名：

@Component(modules = {RemoteSourceModule.class})
public interface SourceComponent {
    public void inject(DataRepository dataRepository);
}

第四步

而在目标类中，RemoteSource和LocalSource一样，都需要加上@Inject注解：

public class DataRepository {

    @Inject
    LocalSource mLocalSource;

    @Inject
    RemoteSource mRemoteSource;

    public DataRepository() {
        DaggerSourceComponent.create().inject(this);
    }

    public String getData() {
        return mLocalSource.getData();
    }

    public String getNetData() {
        return mRemoteSource.getData();
    }
}

流程如下图所示：

Dagger2 知识梳理(1) - Dagger2 依赖注入的两种方式_第3张图片

3.3 Demo 演示

下面，我们用一个简单的程序来验证DataRepository中的mLocalSource/mRemoteSource是否注入成功：

public class RepositoryActivity extends AppCompatActivity {

    private static final String TAG = RepositoryActivity.class.getSimpleName();
    private Button mBtnGetData;
    private Button mBtnGetNetData;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_repository);
        mBtnGetData = (Button) findViewById(R.id.bt_get_data);
        mBtnGetData.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                DataRepository repository = new DataRepository();
                String data = repository.getData();
                Toast.makeText(RepositoryActivity.this, data, Toast.LENGTH_SHORT).show();
            }
        });
        mBtnGetNetData = (Button) findViewById(R.id.bt_get_net_data);
        mBtnGetNetData.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                DataRepository repository = new DataRepository();
                String data = repository.getNetData();
                Toast.makeText(RepositoryActivity.this, data, Toast.LENGTH_SHORT).show();
            }
        });
    }
}

运行结果为：

3.4 依赖注入的过程

下面，我们来看一下依赖注入的内部实现，整个依赖注入的入口函数为DaggerSourceComponent，在上面的例子中，它的源码为：

public final class DaggerSourceComponent implements SourceComponent {

  private Provider provideRemoteSourceProvider;
  private MembersInjector dataRepositoryMembersInjector;

  private DaggerSourceComponent(Builder builder) {
    assert builder != null;
    initialize(builder);
  }

  public static Builder builder() {
    return new Builder();
  }

  public static SourceComponent create() {
    return new Builder().build();
  }

  @SuppressWarnings("unchecked")
  private void initialize(final Builder builder) {

    this.provideRemoteSourceProvider =
        RemoteSourceModule_ProvideRemoteSourceFactory.create(builder.remoteSourceModule);

    this.dataRepositoryMembersInjector =
        DataRepository_MembersInjector.create(
            LocalSource_Factory.create(), provideRemoteSourceProvider);
  }

  @Override
  public void inject(DataRepository dataRepository) {
    dataRepositoryMembersInjector.injectMembers(dataRepository);
  }

  public static final class Builder {
    private RemoteSourceModule remoteSourceModule;

    private Builder() {}

    public SourceComponent build() {
      if (remoteSourceModule == null) {
        this.remoteSourceModule = new RemoteSourceModule();
      }
      return new DaggerSourceComponent(this);
    }

    public Builder remoteSourceModule(RemoteSourceModule remoteSourceModule) {
      this.remoteSourceModule = Preconditions.checkNotNull(remoteSourceModule);
      return this;
    }
  }
}

当我们调用静态的create()方法后会返回一个DaggerSourceComponent实例，它是前面声明的SourceComponent的实现类。其内部最关键的成员变量是DataRepository_MembersInjector类，它是依赖注入的实际执行者，其内部包含了所有需要注入的实例的Provider，这些Provider是在构造时传入的：

当我们调用DaggerSourceComponent的inject方法时，就会去调用DataRepository_MembersInjector类的injectMembers方法，它通过上面这两个Provider所提供的get()方法对目标类中被@Inject注解的成员变量进行赋值：

Dagger2 知识梳理(1) - Dagger2 依赖注入的两种方式_第4张图片

3.5 依赖查找的过程

对于以上两种依赖注入方法，其先后顺序为：3.2 > 3.1，即Component先会在和它关联的Module中寻找，这些关联的Module包括：

自己声明的Module
依赖的Component所关联的Module
通过@SubComponent继承的Component关联的Module

它会在以上三个维度中寻找Module是否提供了这个类的创建方法（也就是方法的返回值类型为这个类）

如果有，那么就通过该方法创建，例如例子中的RemoteModule。
如果没有，那么再通过该类带有@Inject注解标注的构造方法来创建，例如例子中的LocalSource。

Dagger2 知识梳理(1) - Dagger2 依赖注入的两种方式_第5张图片

对于每个目标依赖类，如果在它的创建过程中依赖于某个参数，那么就需要先实例化这个参数。这就类似于二叉树遍历的过程，在这一遍历过程中，如果出现了某个类型不能按照以上两种方式实例化的时候，那么会在编译时抛出异常。

Dagger2 知识梳理(1) - Dagger2 依赖注入的两种方式_第6张图片

Dagger2 知识梳理(1) - Dagger2 依赖注入的两种方式