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

Dagger2 系列文章

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


一、资料推荐

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

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

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

还有前同事 Johnny ShiehDagger2系列,里面提到了后来新增的一些用法:

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

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

二、导入依赖

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

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


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

三、依赖注入的两种方式

下面,我们用一个简单的例子来演示使用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();
    }

}

流程如下图所示:


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);
}

第四步

而在目标类中,RemoteSourceLocalSource一样,都需要加上@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();
    }
}

流程如下图所示:


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<RemoteSource> provideRemoteSourceProvider;
  private MembersInjector<DataRepository> 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是在构造时传入的:

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

3.5 依赖查找的过程

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

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

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

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

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



更多文章,欢迎访问我的 Android 知识梳理系列:

推荐阅读更多精彩内容