上一期讲到了不改变对象代码的注入方式，其实就是成员注入（field injection）。Dagger提供了3种注入方式，即构造器注入（constructor injection），方法注入（method injection）与成员注入。之前在对象构造器代码上添加@Inject的就属于构造器注入，而方法注入说来也很简单，一般用一个get方法来获取需要的东西就算是方法注入了，成员注入就是在成员变量上加@Inject符号，Dagger会通过赋值来实现注入。

主体代码

那么现在来探索更复杂的交叉依赖关系。假设现在有一个ClassB：

public class ClassB {
  private ClassA classA;
  private int a;

  public ClassB(ClassA classA, int a) {
    this.classA = classA;
    this.a = a;
  }

  public ClassA getClassA() {
    return classA;
  }

  public int getA() {
    return a;
  }
}

同时我们要求ClassA的第一个变量也得是a。
你可能说，那有何难？反正加个@Provides方法到ModuleB里面让Dagger自己找呗：

@Module
public class ModuleB {

  private int a;
  private int b;

  public ModuleB(int a, int b) {
    this.a = a;
    this.b = b;
  }

  @Provides
  @Named("a")
  int provideIntA() {
    return a;
  }

  @Provides
  @Named("b")
  int provideIntB() {
    return b;
  }

  @Provides
  ClassA provideClassA(@Named("a") int a, @Named("b") int b) {
    return new ClassA(a, b);
  }

  @Provides
  ClassB provideClassB(ClassA classA, @Named("a") int a) {
    return new ClassB(classA, a);
  }
}

然后ClassBComponent依样画葫芦：

@Component(modules = ModuleB.class)
public interface ClassBComponent {

  void inject(MainActivity mainActivity);
}

然后把之前MainActivity关于ClassA的代码掉：

public class MainActivity extends AppCompatActivity {

  @Inject ClassB classB;
  private static final String TAG = "MainActivity";

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

    DaggerClassBComponent.builder()
        .moduleB(new ModuleB(2, 3))
        .build().inject(this);
    Log.d(TAG, classB.getClassA().getA() + ":" + classB.getClassA().getB() + ":" + classB.getA());
  }
}

一切看起来很完美，直到点击运行，编译出错：

Error:(10, 8) 错误: daggerplay.com.daggerplay.classes.ClassB cannot be provided without an @Inject constructor or from an @Provides- or @Produces-annotated method.
daggerplay.com.daggerplay.classes.ClassB is injected at
daggerplay.com.daggerplay.MainActivity.classB
daggerplay.com.daggerplay.MainActivity is injected at
daggerplay.com.daggerplay.components.ClassAComponent.inject(mainActivity)

看这个错误提示，好像有点摸不着头脑：@Provides不是已经标给ClassB了吗？
其实后面几行才是重点。后面几行提醒你，ClassAComponent已经负责注入MainActivity了。
把ClassAComponent的inject函数删除，果然程序正常运行。那到底是怎么回事呢？
在网上搜索一下发现，之前已经有人有这样的疑问了：https://stackoverflow.com/questions/32341839/multiple-independent-component-injection，而且Github上也有人提了issue，总而言之就是，两个没有关系的Component是不能负责注入同一个对象的。
那么问题来了：如果我们既想注入ClassA又想注入ClassB怎么办？
答案就是放到一个Component里面去。问题转化成为，一个Component如何注入多个对象？
仔细思考发现，其实ClassA的提供方法已经在ModuleB里面了，有没有什么方法告诉Dagger让它顺带把ClassA也注入了？
有，其实也很简单，就像之前那样在MainActivity里面给ClassA标注即可。
现在可以把之前的ClassAComponent与ModuleA删掉了。现在的MainActivity是这样：

public class MainActivity extends AppCompatActivity {
  @Inject ClassA classA;
  @Inject ClassB classB;
  private static final String TAG = "MainActivity";

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

    ClassBComponent daggerClassBComponent = DaggerClassBComponent.builder()
        .moduleB(new ModuleB(2, 3))
        .build();
    daggerClassBComponent.inject(this);
    Log.d(TAG, classA.getClass().getSimpleName());
    Log.d(TAG, classB.getClass().getSimpleName());
  }
}

ModuleB：

@Component(modules = ModuleB.class)
public interface ClassBComponent {

  void inject(MainActivity mainActivity);
}

运行即可同时注入ClassA与ClassB。假如只想要一个，只留一个标注类即可。
这也告诉我们使用Dagger时的一个比较好的习惯：把所有依赖放在一个Component里一次注入。

生成代码

还是照例来看一下生成代码。记得rebuild一下，不然原来的ClassA的Dagger生成代码还存在。
首先是4个工厂类，分别负责提供整数a，整数b，ClassA与ClassB。和之前代码是一个套路，就不贴了。
然后新的注入器MainActivity_MembersInjector：

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

  private final Provider<ClassB> classBProvider;

  public MainActivity_MembersInjector(
      Provider<ClassA> classAProvider, Provider<ClassB> classBProvider) {
    assert classAProvider != null;
    this.classAProvider = classAProvider;
    assert classBProvider != null;
    this.classBProvider = classBProvider;
  }

  public static MembersInjector<MainActivity> create(
      Provider<ClassA> classAProvider, Provider<ClassB> classBProvider) {
    return new MainActivity_MembersInjector(classAProvider, classBProvider);
  }

  @Override
  public void injectMembers(MainActivity instance) {
    if (instance == null) {
      throw new NullPointerException("Cannot inject members into a null reference");
    }
    instance.classA = classAProvider.get();
    instance.classB = classBProvider.get();
  }

  public static void injectClassA(MainActivity instance, Provider<ClassA> classAProvider) {
    instance.classA = classAProvider.get();
  }

  public static void injectClassB(MainActivity instance, Provider<ClassB> classBProvider) {
    instance.classB = classBProvider.get();
  }
}

可见其还可以单独注入ClassA和ClassB。不过我们一般不直接用这个类。
再来看一下DaggerClassBComponent：

public final class DaggerClassBComponent implements ClassBComponent {
  private Provider<Integer> provideIntAProvider;

  private Provider<Integer> provideIntBProvider;

  private Provider<ClassA> provideClassAProvider;

  private Provider<ClassB> provideClassBProvider;

  private MembersInjector<MainActivity> mainActivityMembersInjector;

  private DaggerClassBComponent(Builder builder) {
    assert builder != null;
    initialize(builder);
  }

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

  @SuppressWarnings("unchecked")
  private void initialize(final Builder builder) {

    this.provideIntAProvider = ModuleB_ProvideIntAFactory.create(builder.moduleB);

    this.provideIntBProvider = ModuleB_ProvideIntBFactory.create(builder.moduleB);

    this.provideClassAProvider =
        ModuleB_ProvideClassAFactory.create(
            builder.moduleB, provideIntAProvider, provideIntBProvider);

    this.provideClassBProvider =
        ModuleB_ProvideClassBFactory.create(
            builder.moduleB, provideClassAProvider, provideIntAProvider);

    this.mainActivityMembersInjector =
        MainActivity_MembersInjector.create(provideClassAProvider, provideClassBProvider);
  }

  @Override
  public void inject(MainActivity mainActivity) {
    mainActivityMembersInjector.injectMembers(mainActivity);
  }

  public static final class Builder {
    private ModuleB moduleB;

    private Builder() {}

    public ClassBComponent build() {
      if (moduleB == null) {
        throw new IllegalStateException(ModuleB.class.getCanonicalName() + " must be set");
      }
      return new DaggerClassBComponent(this);
    }

    public Builder moduleB(ModuleB moduleB) {
      this.moduleB = Preconditions.checkNotNull(moduleB);
      return this;
    }
  }
}

现在有一个问题：假如我们希望注入一个单例对象，如何实现呢？怎么防止其被初始化多次呢？这就不得不提Dagger的@Scope标注了，下期再探讨这个话题。