Dagger2源码分析一_r2dare 源码分析-优快云博客

本文链接：https://blog.youkuaiyun.com/irXiang/article/details/80756334

本文深入探讨了Dagger2的注入机制，通过分析ClassA、ModuleA和ComponentA的实例化过程，展示了Dagger如何将Module中的对象注入到MainActivity。详细解释了DaggerComponentA的创建和Builder模式，以及MembersInjector如何执行注入操作。同时对比了使用Module和直接构造方法注入的区别。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

写一个最基本的注入过程，分别有ClassA,ModuleA,ComponentA三个类

public class ClassA {

}

@Module
public class ModuleA {

    @Provides
    public ClassA provideA(){
        return new ClassA();
    }

}

@Component(modules = ModuleA.class)
public interface ComponentA {

    void inject(MainActivity activity);
}

然后在MainActivity中注入ClassA

public class MainActivity extends AppCompatActivity {

    @Inject
    ClassA a;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);


        DaggerComponentA.create().inject(this);

    }

}

下面从 DaggerComponentA.create().inject(this)这句代码开始分析

public final class DaggerComponentA implements ComponentA {
  private ModuleA moduleA;

  private DaggerComponentA(Builder builder) {
    initialize(builder);
  }

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

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

  @SuppressWarnings("unchecked")
  private void initialize(final Builder builder) {
    this.moduleA = builder.moduleA;
  }

  @Override
  public void inject(MainActivity activity) {
    injectMainActivity(activity);
  }

  private MainActivity injectMainActivity(MainActivity instance) {
    MainActivity_MembersInjector.injectA(instance, ModuleA_ProvideAFactory.proxyProvideA(moduleA));
    return instance;
  }

  public static final class Builder {
    private ModuleA moduleA;

    private Builder() {}

    public ComponentA build() {
      if (moduleA == null) {
        this.moduleA = new ModuleA();
      }
      return new DaggerComponentA(this);
    }

    public Builder moduleA(ModuleA moduleA) {
      this.moduleA = Preconditions.checkNotNull(moduleA);
      return this;
    }
  }
}

可以看到inject的过程是调用了

MainActivity_MembersInjector.injectA(instance, ModuleA_ProvideAFactory.proxyProvideA(moduleA));

下面分析MembersInjector源码

public final class MainActivity_MembersInjector implements MembersInjector<MainActivity> {
  private final Provider<ClassA> aProvider;

  public MainActivity_MembersInjector(Provider<ClassA> aProvider) {
    this.aProvider = aProvider;
  }

  public static MembersInjector<MainActivity> create(Provider<ClassA> aProvider) {
    return new MainActivity_MembersInjector(aProvider);
  }

  @Override
  public void injectMembers(MainActivity instance) {
    injectA(instance, aProvider.get());
  }

  public static void injectA(MainActivity instance, ClassA a) {
    instance.a = a;
  }
}

可以看到injectA就是将ClassA 对象赋给了MainActivity对象中的a成员

再看Module_ProvideAFactory.ProxyProvideA(moduleA);

public final class ModuleA_ProvideAFactory implements Factory<ClassA> {
  private final ModuleA module;

  public ModuleA_ProvideAFactory(ModuleA module) {
    this.module = module;
  }

  @Override
  public ClassA get() {
    return provideInstance(module);
  }

  public static ClassA provideInstance(ModuleA module) {
    return proxyProvideA(module);
  }

  public static ModuleA_ProvideAFactory create(ModuleA module) {
    return new ModuleA_ProvideAFactory(module);
  }

  public static ClassA proxyProvideA(ModuleA instance) {
    return Preconditions.checkNotNull(
        instance.provideA(), "Cannot return null from a non-@Nullable @Provides method");
  }
}

可以看到，ClassA 对象实际是来自moduleA的provideA方法。

如此，dagger框架将Module中的ClassA对象注入到了MainActivity中

再看另一种情况，不用Module类注入对象

写一个类ClassB

public class ClassB {

    @Inject
    public ClassB(){

    }
}

注意，在这个类的构造方法上写上@Inject

编译后，再看DaggerComponentA

private MainActivity injectMainActivity(MainActivity instance) {
  MainActivity_MembersInjector.injectA(instance, ModuleA_ProvideAFactory.proxyProvideA(moduleA));
  MainActivity_MembersInjector.injectB(instance, new ClassB());
  return instance;
}