Dagger 注入对象的原理

使用 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 {
  private static final Stool_Factory INSTANCE = new Stool_Factory();

  @Override
  public Stool get() {
    return new Stool();
  }

  public static Factory create() {
    return INSTANCE;
  }
}

这个工厂类的类图如下：

Stool_Factory.png

可以看到，这个工厂类实现了 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 {
  private final Provider mStoolProvider;

  public MainActivity_MembersInjector(Provider mStoolProvider) {
    assert mStoolProvider != null;
    this.mStoolProvider = mStoolProvider;
  }

  public static MembersInjector create(Provider 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 mStoolProvider) {
    instance.mStool = mStoolProvider.get();
  }
}

下面是注入器的类图：

MembersInjector.png

这个注入器类实现了 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 create(Provider 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 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 方法，用于被依赖对象最终注入。

几个类的关系图如下：

InjectRelationship.png

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

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 {
  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 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 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 {
  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 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 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 provideStoolProvider;

  private MembersInjector 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 基本使用方法背后的原理就分析完了。

Dagger 注入对象的原理

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

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

Component 完成绑定和注入

Provider 提供被依赖对象（@Module 方式 + static 方法）

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

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

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

你可能感兴趣的:(Dagger 注入对象的原理)