Dagger2——基础用法的生成类

构造函数注入

public class BMW {

    IWheel wheel;

    @Inject
    public BMW(IWheel wheel) {
        super();
        this.wheel = wheel;
    }
}

Dagger生成的类为BMW_Factory：

public final class BMW_Factory implements Factory<BMW> {
  private final Provider<IWheel> wheelProvider;

  public BMW_Factory(Provider<IWheel> wheelProvider) {
    this.wheelProvider = wheelProvider;
  }

  @Override
  public BMW get() {
    return newInstance(wheelProvider.get());
  }

  public static BMW_Factory create(Provider<IWheel> wheelProvider) {
    return new BMW_Factory(wheelProvider);
  }

  public static BMW newInstance(IWheel wheel) {
    return new BMW(wheel);
  }
}

它实现了Factory接口，并实现了get()方法，用于返回一个BMW对象，其中提供了两个静态方法，用于提供构造BMW需要的参数。

@Module类提供依赖：

@Module
public  class WheelModel {
    @Provides
    public static IWheel provideBMWWheel(){
        return new BMWWheel();
    }
}

Dagger生成的类为：WheelModel_ProvideBMWWheelFactory

public final class WheelModel_ProvideBMWWheelFactory implements Factory<IWheel> {
  @Override
  public IWheel get() {
    return provideBMWWheel();
  }

  public static WheelModel_ProvideBMWWheelFactory create() {
    return InstanceHolder.INSTANCE;
  }

  public static IWheel provideBMWWheel() {
    return Preconditions.checkNotNull(WheelModel.provideBMWWheel(), "Cannot return null from a non-@Nullable @Provides method");
  }

  private static final class InstanceHolder {
    private static final WheelModel_ProvideBMWWheelFactory INSTANCE = new WheelModel_ProvideBMWWheelFactory();
  }
}

它实现了Factory接口，并实现了get()方法会返回一个IWheel对象。而provideBMWWheel是一个静态方法，用于提供IWheel对象，其中它会调用WheelModel的静态方法provideBMWWheel()。

@Component桥梁

@Component(modules = WheelModel.class)
public interface CarComponent {
    BMW makeBmw();
}

Dagger生成的类DaggerCarComponent：

public final class DaggerCarComponent implements CarComponent {
  private DaggerCarComponent() {

  }

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

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

  @Override
  public BMW makeBmw() {
    return new BMW(WheelModel_ProvideBMWWheelFactory.provideBMWWheel());}

  public static final class Builder {
    private Builder() {
    }

    /**
     * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules.
     */
    @Deprecated
    public Builder wheelModel(WheelModel wheelModel) {
      Preconditions.checkNotNull(wheelModel);
      return this;
    }

    public CarComponent build() {
      return new DaggerCarComponent();
    }
  }
}

它实现了CarComponent接口，并实现了makeBmw()方法（这里并没有用到BMW_Factory这个工厂类），用于返回一个BMW对象，而BMW对象需要的构造参数来自于WheelModel_ProvideBMWWheelFactory的provideBMWWheel()方法。所以，可以看到@Componet把@Module和@Inject连接起来。

类变量注入：

public class BMW {
    @Inject
    public BMW(){
        super();
    }

    @Inject
    IWheel wheel;
}

生成的BMW_Factory如下：

public final class BMW_Factory implements Factory<BMW> {
  private final Provider<IWheel> wheelProvider;

  public BMW_Factory(Provider<IWheel> wheelProvider) {
    this.wheelProvider = wheelProvider;
  }

  @Override
  public BMW get() {
    BMW instance = newInstance();
    BMW_MembersInjector.injectWheel(instance, wheelProvider.get());
    return instance;
  }

  public static BMW_Factory create(Provider<IWheel> wheelProvider) {
    return new BMW_Factory(wheelProvider);
  }

  public static BMW newInstance() {
    return new BMW();
  }
}

可以看到，增加了一步设置变量的过程。

生成的DaggerCarComponent也类似，增加了一步变量设置的过程：

public final class DaggerCarComponent implements CarComponent {
  private DaggerCarComponent() {

  }

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

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

  @Override
  public BMW makeBmw() {
    return injectBMW(BMW_Factory.newInstance());}

  private BMW injectBMW(BMW instance) {
    BMW_MembersInjector.injectWheel(instance, WheelModel_ProvideBMWWheelFactory.provideBMWWheel());
    return instance;
  }

  public static final class Builder {
    private Builder() {
    }

    /**
     * @deprecated This module is declared, but an instance is not used in the component. This method is a no-op. For more, see https://dagger.dev/unused-modules.
     */
    @Deprecated
    public Builder wheelModel(WheelModel wheelModel) {
      Preconditions.checkNotNull(wheelModel);
      return this;
    }

    public CarComponent build() {
      return new DaggerCarComponent();
    }
  }
}

那么这个变量是如何设置的，由BMW_MembersInjector实现：

public final class BMW_MembersInjector implements MembersInjector<BMW> {
  private final Provider<IWheel> wheelProvider;

  public BMW_MembersInjector(Provider<IWheel> wheelProvider) {
    this.wheelProvider = wheelProvider;
  }

  public static MembersInjector<BMW> create(Provider<IWheel> wheelProvider) {
    return new BMW_MembersInjector(wheelProvider);}

  @Override
  public void injectMembers(BMW instance) {
    injectWheel(instance, wheelProvider.get());
  }

  @InjectedFieldSignature("com.hero.BMW.wheel")
  public static void injectWheel(BMW instance, IWheel wheel) {
    instance.wheel = wheel;
  }
}

可以看到，它实现了MembersInjector接口，并实现了**injectMembers()**方法，通过传入BMW和IWheel实例，完成变量的设置过程。