上一期講到了不改變對(duì)象代碼的注入方式，其實(shí)就是成員注入（field injection）。Dagger提供了3種注入方式，即構(gòu)造器注入（constructor injection），方法注入（method injection）與成員注入。之前在對(duì)象構(gòu)造器代碼上添加@Inject的就屬于構(gòu)造器注入，而方法注入說(shuō)來(lái)也很簡(jiǎn)單，一般用一個(gè)get方法來(lái)獲取需要的東西就算是方法注入了，成員注入就是在成員變量上加@Inject符號(hào)，Dagger會(huì)通過(guò)賦值來(lái)實(shí)現(xiàn)注入。

主體代碼

那么現(xiàn)在來(lái)探索更復(fù)雜的交叉依賴關(guān)系。假設(shè)現(xiàn)在有一個(gè)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;
  }
}

同時(shí)我們要求ClassA的第一個(gè)變量也得是a。
你可能說(shuō)，那有何難？反正加個(gè)@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關(guān)于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());
  }
}

一切看起來(lái)很完美，直到點(diǎn)擊運(yùn)行，編譯出錯(cuò)：

Error:(10, 8) 錯(cuò)誤: 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)

看這個(gè)錯(cuò)誤提示，好像有點(diǎn)摸不著頭腦：@Provides不是已經(jīng)標(biāo)給ClassB了嗎？
其實(shí)后面幾行才是重點(diǎn)。后面幾行提醒你，ClassAComponent已經(jīng)負(fù)責(zé)注入MainActivity了。
把ClassAComponent的inject函數(shù)刪除，果然程序正常運(yùn)行。那到底是怎么回事呢？
在網(wǎng)上搜索一下發(fā)現(xiàn)，之前已經(jīng)有人有這樣的疑問(wèn)了：https://stackoverflow.com/questions/32341839/multiple-independent-component-injection，而且Github上也有人提了issue，總而言之就是，兩個(gè)沒(méi)有關(guān)系的Component是不能負(fù)責(zé)注入同一個(gè)對(duì)象的。
那么問(wèn)題來(lái)了：如果我們既想注入ClassA又想注入ClassB怎么辦？
答案就是放到一個(gè)Component里面去。問(wèn)題轉(zhuǎn)化成為，一個(gè)Component如何注入多個(gè)對(duì)象？
仔細(xì)思考發(fā)現(xiàn)，其實(shí)ClassA的提供方法已經(jīng)在ModuleB里面了，有沒(méi)有什么方法告訴Dagger讓它順帶把ClassA也注入了？
有，其實(shí)也很簡(jiǎn)單，就像之前那樣在MainActivity里面給ClassA標(biāo)注即可。
現(xiàn)在可以把之前的ClassAComponent與ModuleA刪掉了。現(xiàn)在的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);
}

運(yùn)行即可同時(shí)注入ClassA與ClassB。假如只想要一個(gè)，只留一個(gè)標(biāo)注類即可。
這也告訴我們使用Dagger時(shí)的一個(gè)比較好的習(xí)慣：把所有依賴放在一個(gè)Component里一次注入。

生成代碼

還是照例來(lái)看一下生成代碼。記得rebuild一下，不然原來(lái)的ClassA的Dagger生成代碼還存在。
首先是4個(gè)工廠類，分別負(fù)責(zé)提供整數(shù)a，整數(shù)b，ClassA與ClassB。和之前代碼是一個(gè)套路，就不貼了。
然后新的注入器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();
  }
}

可見(jiàn)其還可以單獨(dú)注入ClassA和ClassB。不過(guò)我們一般不直接用這個(gè)類。
再來(lái)看一下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;
    }
  }
}

現(xiàn)在有一個(gè)問(wèn)題：假如我們希望注入一個(gè)單例對(duì)象，如何實(shí)現(xiàn)呢？怎么防止其被初始化多次呢？這就不得不提Dagger的@Scope標(biāo)注了，下期再探討這個(gè)話題。