Dagger2源码分析一

本文深入探讨了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;
}

可以看到在injectB时是直接new一个ClassB对象

两种注入的方式分析结束
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值