Wonder4 Life

Dagger 注入对象的原理

这篇文章采用循序渐进的方式,分析下 Dagger 注入对象的原理,看看 Dagger 是如何完成编译时依赖注入。这里仍然采用上篇文章的例子,在 MainActivity 中 注入 Stool 对象。

Provider 提供被依赖对象(@Inject 方式)

为了避免落入一上来就名词解释的深渊,直接上代码。

首先,创建被依赖的类 Stool :

1
2
3
4
5
6
7
public class Stool {
@Inject
public Stool() {
}
}

在 build 项目之后,会在 app/build/generated/source/apt/debug/{package_name} 下生成对应的工厂类 Stool_Factory :

1
2
3
4
5
6
7
8
9
10
11
12
public final class Stool_Factory implements Factory<Stool> {
private static final Stool_Factory INSTANCE = new Stool_Factory();
@Override
public Stool get() {
return new Stool();
}
public static Factory<Stool> create() {
return INSTANCE;
}
}

这个工厂类的类图如下 :

Stool_Factory

可以看到,这个工厂类实现了 Dagger 框架中的 Factory 接口,而 Dagger 的 Factory 接口继承了 javax.inject 包中的 Provider 接口。Stool_Factory 实现了接口的 get 方法,创建 Stool 对象。

所以在这里,Stool_Factory 这个自动生成的类,就是 Dagger 库对 Provider 接口的实现,提供被依赖的对象。

同时这个类提供 create 静态方法创建并返回自身对象。

这里简要介绍下 javax.inject 包:

Java 依赖注入有一套标准 JSR-330javax.inject 是一套遵循该标准的注解框架。 定义了依赖注入的核心部分 @Inject 注解和 Provider 接口,而没有具体的注入器 (injector) 的实现。具体的依赖配置 (dependency configuration) 取决于注入器 (injector) 的实现。实现的方式有多种:有的是通过反射,有的是编译时生成代码。Dagger 也遵从这套标准,采用编译时生成代码的方式实现这部分接口。

javax.inject 包中,后续还会遇到Qualifier,Scope,Singleton注解。

Injector 提供被依赖对象的注入方式

接下来,在 MainActivity 中注入 Stool 成员变量:

1
2
3
4
5
6
7
8
9
10
11
12
13
import javax.inject.Inject;
public class MainActivity extends AppCompatActivity {
@Inject
Stool mStool;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
}

在 build 项目之后会在 app/build/generated/source/apt/debug/{package_name} 下生成 MainActivity 成员变量的注入器类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import dagger.MembersInjector;
import javax.inject.Provider;
public final class MainActivity_MembersInjector implements MembersInjector<MainActivity> {
private final Provider<Stool> mStoolProvider;
public MainActivity_MembersInjector(Provider<Stool> mStoolProvider) {
assert mStoolProvider != null;
this.mStoolProvider = mStoolProvider;
}
public static MembersInjector<MainActivity> create(Provider<Stool> mStoolProvider) {
return new MainActivity_MembersInjector(mStoolProvider);
}
@Override
public void injectMembers(MainActivity instance) {
if (instance == null) {
throw new NullPointerException("Cannot inject members into a null reference");
}
instance.mStool = mStoolProvider.get();
}
public static void injectMStool(MainActivity instance, Provider<Stool> mStoolProvider) {
instance.mStool = mStoolProvider.get();
}
}

下面是注入器的类图:

Stool_Factory

这个注入器类实现了 Dagger 框架中 MembersInjector 接口,并通过 mStoolProvider 持有之前的工厂对象。

在 injectMembers 接口方法中,传入 MainActivity 对象,通过 mStoolProvider 创建 Stool 对象,并赋值给 MainActivity 的 mStool 字段:

1
2
3
4
5
6
7
@Override
public void injectMembers(MainActivity instance) {
if (instance == null) {
throw new NullPointerException("Cannot inject members into a null reference");
}
instance.mStool = mStoolProvider.get();
}

注:由上面这段代码可以发现,因为要直接通过 instance.mStool 完成赋值,所以在平时使用时需要注意,用 Dagger 注入字段时不能像下面这样将字段设为 private

1
2
@Inject
private Stool mStool;//Wrong

这样做会遇到 Error: Dagger does not support injection into private fields

这个类还提供了 create 静态方法创建并返回自身 MembersInjector 对象,同时传入需要的 Provider 对象,即之前的 Stool 工厂对象。

1
2
3
public static MembersInjector<MainActivity> create(Provider<Stool> mStoolProvider) {
return new MainActivity_MembersInjector(mStoolProvider);
}

所以,这个方法是将 Injector 和 Provider 联系起来的关键。

接下来就是一个重要的接口,负责创建 Provider 和 Injector 对象并绑定二者,调用 Injector 的注入方法完成注入。

Component 完成绑定和注入

在引入完整版 Component 之前,先定义一个空的 Component 接口,看看发生了什么:

1
2
3
@Component()
public interface MainActivityComponent {
}

在 build 项目之后会在 app/build/generated/source/apt/debug/{package_name} 下生成接口的实现类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public final class DaggerMainActivityComponent implements MainActivityComponent {
private DaggerMainActivityComponent(Builder builder) {
assert builder != null;
}
public static Builder builder() {
return new Builder();
}
public static MainActivityComponent create() {
return new Builder().build();
}
public static final class Builder {
private Builder() {}
public MainActivityComponent build() {
return new DaggerMainActivityComponent(this);
}
}
}

可以看到 Component 的实现类采用了 Builder 模式,用来创建自身对象。同时提供了 DaggerMainActivityComponent.create() 方法代替 DaggerMainActivityComponent.builder.build()

接下来,加入 inject 方法:

1
2
3
4
@Component()
public interface MainActivityComponent {
void inject(MainActivity activity);
}

在 build 项目之后会在 app/build/generated/source/apt/debug/{package_name} 下生成接口的实现类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public final class DaggerMainActivityComponent implements MainActivityComponent {
private MembersInjector<MainActivity> mainActivityMembersInjector;
private DaggerMainActivityComponent(Builder builder) {
assert builder != null;
initialize(builder);
}
public static Builder builder() {
return new Builder();
}
public static MainActivityComponent create() {
return new Builder().build();
}
@SuppressWarnings("unchecked")
private void initialize(final Builder builder) {
this.mainActivityMembersInjector = MainActivity_MembersInjector.create(Stool_Factory.create());
}
@Override
public void inject(MainActivity activity) {
mainActivityMembersInjector.injectMembers(activity);
}
public static final class Builder {
private Builder() {}
public MainActivityComponent build() {
return new DaggerMainActivityComponent(this);
}
}
}

在添加了这个接口之后,生成的 DaggerMainActivityComponent 类添加了两个新方法:

  1. initialize 创建了 Injector 对象和 Stool_Factory 对象,并将它们关联起来;
  1. 提供 inject 方法,用于被依赖对象最终注入。

几个类的关系图如下:

Stool_Factory

由此可见,通过自动生成的这三个类协作,完成了对象的注入。

Provider 提供被依赖对象(@Module 方式 + static 方法)

这次,被依赖的类 Stool 构造函数没有 @Inject 注解:

1
2
3
4
5
6
public class Stool {
public Stool() {
}
}

然后添加 StoolModule 类,用于创建 Stool 对象:

1
2
3
4
5
6
7
8
9
10
11
import dagger.Module;
import dagger.Provides;
@Module
public class StoolModule {
@Provides
static Stool provideStool() {
return new Stool();
}
}

在 build 项目之后,会在 app/build/generated/source/apt/debug/{package_name} 下生成对应的工厂类 StoolModule_ProvideStoolFactory :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public final class StoolModule_ProvideStoolFactory implements Factory<Stool> {
private static final StoolModule_ProvideStoolFactory INSTANCE =
new StoolModule_ProvideStoolFactory();
@Override
public Stool get() {
return Preconditions.checkNotNull(
StoolModule.provideStool(), "Cannot return null from a non-@Nullable @Provides method");
}
public static Factory<Stool> create() {
return INSTANCE;
}
/** Proxies {@link StoolModule#provideStool()}. */
public static Stool proxyProvideStool() {
return StoolModule.provideStool();
}
}

这个工厂类与采用注解方式生成的 Stool_Factory 大同小异,只不过实现的 get 接口直接调用 StoolModule.provideStool() 创建 Stool 对象。

Component 完成被依赖对象到依赖者的绑定(@Module 方式 + static 方法)

由于采用了 Module 方式创建被依赖对象,Component 接口也需要做出些修改:

1
2
3
4
@Component(modules = StoolModule.class)
public interface MainActivityComponent {
void inject(MainActivity activity);
}

在 build 项目之后会在 app/build/generated/source/apt/debug/{package_name} 下生成接口的实现类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
public final class DaggerMainActivityComponent implements MainActivityComponent {
private MembersInjector<MainActivity> mainActivityMembersInjector;
private DaggerMainActivityComponent(Builder builder) {
assert builder != null;
initialize(builder);
}
public static Builder builder() {
return new Builder();
}
public static MainActivityComponent create() {
return new Builder().build();
}
@SuppressWarnings("unchecked")
private void initialize(final Builder builder) {
this.mainActivityMembersInjector =
MainActivity_MembersInjector.create(StoolModule_ProvideStoolFactory.create());
}
@Override
public void inject(MainActivity activity) {
mainActivityMembersInjector.injectMembers(activity);
}
public static final class Builder {
private Builder() {}
public MainActivityComponent build() {
return new DaggerMainActivityComponent(this);
}
/**
* @deprecated This module is declared, but an instance is not used in the component. This
* method is a no-op. For more, see https://google.github.io/dagger/unused-modules.
*/
@Deprecated
public Builder stoolModule(StoolModule stoolModule) {
Preconditions.checkNotNull(stoolModule);
return this;
}
}
}

可以看到,除了直接改为调用 StoolModule_ProvideStoolFactory.create() 创建工厂对象外,基本没有变化。另外,增加一个 @Deprecated 方法:

1
2
@Deprecated
public Builder stoolModule(StoolModule stoolModule)

如上篇文章所说,因为在 StoolModule 中定义的是一个静态方法,并不需要传递一个 StoolModule 对象,于是 Dagger 会自动加上 @Deprecated 警示。

Provider 提供被依赖对象(@Module 方式 + 非 static 方法)

这次,将 StoolModule 类的 provide 方法改为非静态方法:

1
2
3
4
5
6
7
8
@Module
public class StoolModule {
@Provides
Stool provideStool() {
return new Stool();
}
}

在 build 项目之后,会在 app/build/generated/source/apt/debug/{package_name} 下生成对应的工厂类 StoolModule_ProvideStoolFactory :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public final class StoolModule_ProvideStoolFactory implements Factory<Stool> {
private final StoolModule module;
public StoolModule_ProvideStoolFactory(StoolModule module) {
assert module != null;
this.module = module;
}
@Override
public Stool get() {
return Preconditions.checkNotNull(
module.provideStool(), "Cannot return null from a non-@Nullable @Provides method");
}
public static Factory<Stool> create(StoolModule module) {
return new StoolModule_ProvideStoolFactory(module);
}
/** Proxies {@link StoolModule#provideStool()}. */
public static Stool proxyProvideStool(StoolModule instance) {
return instance.provideStool();
}
}

相对于采用静态方法的 Module 生成的 StoolModule_ProvideStoolFactory,这个 Factory 对象在创建时需要传入 StoolModule 对象:

1
2
3
public static Factory<Stool> create(StoolModule module) {
return new StoolModule_ProvideStoolFactory(module);
}

同时,在获取 Stool 对象时,需要通过对象调用方法:

1
2
3
4
5
@Override
public Stool get() {
return Preconditions.checkNotNull(
module.provideStool(), "Cannot return null from a non-@Nullable @Provides method");
}

所以,Component 势必也会作出改变,以传入 Module 对象。

Component 完成被依赖对象到依赖者的绑定(@Module 方式 + 非 static 方法)

在 build 项目之后会在 app/build/generated/source/apt/debug/{package_name} 下生成接口的实现类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
public final class DaggerMainActivityComponent implements MainActivityComponent {
private Provider<Stool> provideStoolProvider;
private MembersInjector<MainActivity> mainActivityMembersInjector;
private DaggerMainActivityComponent(Builder builder) {
assert builder != null;
initialize(builder);
}
public static Builder builder() {
return new Builder();
}
public static MainActivityComponent create() {
return new Builder().build();
}
@SuppressWarnings("unchecked")
private void initialize(final Builder builder) {
this.provideStoolProvider = StoolModule_ProvideStoolFactory.create(builder.stoolModule);
this.mainActivityMembersInjector = MainActivity_MembersInjector.create(provideStoolProvider);
}
@Override
public void inject(MainActivity activity) {
mainActivityMembersInjector.injectMembers(activity);
}
public static final class Builder {
private StoolModule stoolModule;
private Builder() {}
public MainActivityComponent build() {
if (stoolModule == null) {
this.stoolModule = new StoolModule();
}
return new DaggerMainActivityComponent(this);
}
public Builder stoolModule(StoolModule stoolModule) {
this.stoolModule = Preconditions.checkNotNull(stoolModule);
return this;
}
}
}

采用非静态方法的 Module,Component 的 Builder 类会接收并持有 Module 对象。在创建 Component 对象时,可以传入 Module 对象创建:

1
DaggerMainActivityComponent.builder().stoolModule(new StoolModule()).build().inject(this);

如果未传入 Module,调用 Builder.build() 方法时会自动创建 Module 对象。create() 封装了 Builder.builder() 也可直接调用 create() 方法:

1
DaggerMainActivityComponent.create().inject(this);

如果 Module 构造时需要传入参数:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Module
public class StoolModule {
String name;
public StoolModule(String name) {
this.name = name;
}
@Provides
Stool provideStool() {
return new Stool();
}
}

自动生成的 DaggerMainActivityComponent 就没这么智能了:

1
2
3
4
5
6
public MainActivityComponent build() {
if (stoolModule == null) {
throw new IllegalStateException(StoolModule.class.getCanonicalName() + " must be set");
}
return new DaggerMainActivityComponent(this);
}

Builder.build() 不会自动创建 Module 对象,同时也删除了 create() 方法。那么就必须在创建 Component 对象时手动创建 Module 对象:

1
DaggerMainActivityComponent.builder().stoolModule(new StoolModule("Stool")).build().inject(this);

综上,上一篇文章中描述的 Dagger 基本使用方法背后的原理就分析完了。