上一期讲到了不改变对象代码的注入方式，其实就是成员注入（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标注了，下期再探讨这个话题。
