使用 Dagger 库 基础篇
Dagger 注入对象的原理
在上篇文章介绍 Dagger 使用方法之后，这篇文章采用循序渐进的方式，分析下 Dagger 如何完成编译时依赖注入。这里仍然采用上篇文章的例子，在 MainActivity 中 注入 Stool 对象。
Provider 提供被依赖对象(@Inject 方式)
为了避免落入一上来就名词解释的深渊，直接上代码。
首先，创建被依赖的类 Stool ：
public class Stool {
@Inject
public Stool() {
}
}
在 build 项目之后，会在 app/build/generated/source/apt/debug/{package_name} 下生成对应的工厂类 Stool_Factory ：
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;
}
}
这个工厂类的类图如下 ：
可以看到，这个工厂类实现了 Dagger 框架中的 Factory 接口，而 Dagger 的 Factory 接口继承了 javax.inject 包中的 Provider 接口。Stool_Factory 实现了接口的 get 方法，创建 Stool 对象。
所以在这里，Stool_Factory 这个自动生成的类，就是 Dagger 库对 Provider 接口的实现，提供被依赖的对象。
同时这个类提供 create 静态方法创建并返回自身对象。
这里简要介绍下 javax.inject 包：
Java 依赖注入有一套标准 JSR-330，javax.inject 是一套遵循该标准的注解框架。 定义了依赖注入的核心部分 @Inject 注解和 Provider 接口，而没有具体的注入器 (injector) 的实现。具体的依赖配置 (dependency configuration) 取决于注入器 (injector) 的实现。实现的方式有多种：有的是通过反射，有的是编译时生成代码。Dagger 也遵从这套标准，采用编译时生成代码的方式实现这部分接口。
javax.inject 包中，后续还会遇到Qualifier，Scope，Singleton注解。
Injector 提供被依赖对象的注入方式
接下来，在 MainActivity 中注入 Stool 成员变量：
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 成员变量的注入器类：
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();
}
}
下面是注入器的类图：
这个注入器类实现了 Dagger 框架中 MembersInjector 接口，并通过 mStoolProvider 持有之前的工厂对象。
在 injectMembers 接口方法中，传入 MainActivity 对象，通过 mStoolProvider 创建 Stool 对象，并赋值给 MainActivity 的 mStool 字段：
@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
@Inject
private Stool mStool;//Wrong
这样做会遇到 Error: Dagger does not support injection into private fields 。
这个类还提供了 create 静态方法创建并返回自身 MembersInjector 对象，同时传入需要的 Provider 对象，即之前的 Stool 工厂对象。
public static MembersInjector<MainActivity> create(Provider<Stool> mStoolProvider) {
return new MainActivity_MembersInjector(mStoolProvider);
}
所以，这个方法是将 Injector 和 Provider 联系起来的关键。
接下来就是一个重要的接口，负责创建 Provider 和 Injector 对象并绑定二者，调用 Injector 的注入方法完成注入。
Component 完成绑定和注入
在引入完整版 Component 之前，先定义一个空的 Component 接口，看看发生了什么：
@Component()
public interface MainActivityComponent {
}
在 build 项目之后会在 app/build/generated/source/apt/debug/{package_name} 下生成接口的实现类：
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 方法：
@Component()
public interface MainActivityComponent {
void inject(MainActivity activity);
}
在 build 项目之后会在 app/build/generated/source/apt/debug/{package_name} 下生成接口的实现类：
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 类添加了两个新方法:
- initialize 创建了 Injector 对象和 Stool_Factory 对象，并将它们关联起来；
- 提供 inject 方法，用于被依赖对象最终注入。
几个类的关系图如下：
由此可见，通过自动生成的这三个类协作，完成了对象的注入。
Provider 提供被依赖对象（@Module 方式 + static 方法）
这次，被依赖的类 Stool 构造函数没有 @Inject 注解：
public class Stool {
public Stool() {
}
}
然后添加 StoolModule 类，用于创建 Stool 对象：
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 ：
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 接口也需要做出些修改：
@Component(modules = StoolModule.class)
public interface MainActivityComponent {
void inject(MainActivity activity);
}
在 build 项目之后会在 app/build/generated/source/apt/debug/{package_name} 下生成接口的实现类：
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 方法：
@Deprecated
public Builder stoolModule(StoolModule stoolModule)
如上篇文章所说，因为在 StoolModule 中定义的是一个静态方法，并不需要传递一个 StoolModule 对象，于是 Dagger 会自动加上 @Deprecated 警示。
Provider 提供被依赖对象（@Module 方式 + 非 static 方法）
这次，将 StoolModule 类的 provide 方法改为非静态方法：
@Module
public class StoolModule {
@Provides
Stool provideStool() {
return new Stool();
}
}
在 build 项目之后，会在 app/build/generated/source/apt/debug/{package_name} 下生成对应的工厂类 StoolModule_ProvideStoolFactory ：
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 对象：
public static Factory<Stool> create(StoolModule module) {
return new StoolModule_ProvideStoolFactory(module);
}
同时，在获取 Stool 对象时，需要通过对象调用方法：
@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} 下生成接口的实现类：
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 对象创建：
DaggerMainActivityComponent.builder().stoolModule(new StoolModule()).build().inject(this);
如果未传入 Module，调用 Builder.build() 方法时会自动创建 Module 对象。create() 封装了 Builder.builder() 也可直接调用 create() 方法：
DaggerMainActivityComponent.create().inject(this);
如果 Module 构造时需要传入参数：
@Module
public class StoolModule {
String name;
public StoolModule(String name) {
this.name = name;
}
@Provides
Stool provideStool() {
return new Stool();
}
}
自动生成的 DaggerMainActivityComponent 就没这么智能了：
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 对象：
DaggerMainActivityComponent.builder().stoolModule(new StoolModule("Stool")).build().inject(this);
综上，Dagger 基本使用方法背后的原理就分析完了。
