上一期我们用最简单的例子来实现了Dagger的依赖注入，虽然对过程大致有了了解，但是还有很多功能和部件还没有被使用。
这一期我们更进一步，在ClassA里面添加一个参数，来看看Dagger是如何运作的。
代码主体
首先在ClassA添加一个新的成员变量：
public class ClassA {
private int a;
@Inject
public ClassA(int a) {
this.a = a;
}
public int getA() {
return a;
}
}
那么之前的ClassA_Factory需要知道ClassA的参数，当然这里有@Inject可以让Dagger读取参数表。另一个问题就是，怎么传入参数？
此时就不得不提到Module了。如果说Component是注入器的话，Module则是负责产生所需参数的部件。来看看代码：
@Module
public class ModuleA {
private int a;
public ModuleA(int a) {
this.a = a;
}
@Provides
int provideInt() {
return a;
}
}
可以看到，与Component是接口不同，'Module'其实是用'@Module'标注的对象，有构造器。值得一提的是里面包含的用'@Provides'标注的方法，这就是提供参数时产生作用的函数，其名字无关紧要，只要返回类型能对上号就行。那么这里就有一个问题，有多个同类型的怎么办呢？这就涉及到另外一些标注了，此处暂且不提。
那么Component是如何与'Module'相连接的？答案是通过标注参数：
@Component(modules = ModuleA.class)
public interface ClassAComponent {
void inject(MainActivity activity);
}
同样可以预见的是实现注入的代码肯定也有变化：
DaggerClassAComponent.builder().moduleA(new ModuleA(2333)).build().inject(this);
即需要传入'Module'从而提供注入所需参数。可能你说，这不还是new了吗？这里new的是'Module'，可没有new一个ClassA。ClassA的产生确实已经委托出去了。
MainActivity的代码：
public class MainActivity extends AppCompatActivity {
@Inject ClassA classA;
private static final String TAG = "MainActivity";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
DaggerClassAComponent.builder()
.moduleA(new ModuleA(2333))
.build().inject(this);
Log.d(TAG, classA.getA() + "");
}
}
生成代码
'Module'的加入究竟导致了哪些变化？来看看生成代码吧。
ClassA_Factory
public final class ClassA_Factory implements Factory<ClassA> {
private final Provider<Integer> aProvider;
public ClassA_Factory(Provider<Integer> aProvider) {
assert aProvider != null;
this.aProvider = aProvider;
}
@Override
public ClassA get() {
return new ClassA(aProvider.get());
}
public static Factory<ClassA> create(Provider<Integer> aProvider) {
return new ClassA_Factory(aProvider);
}
}
与上一次的ClassA_Factory有稍许不同，这次工厂构建方法需要一个Provider<Integer> aProvider来提供创建'ClassA'时所需的参数。
ModuleA_ProvideIntFactory
这是一个新的文件：
public final class ModuleA_ProvideIntFactory implements Factory<Integer> {
private final ModuleA module;
public ModuleA_ProvideIntFactory(ModuleA module) {
assert module != null;
this.module = module;
}
@Override
public Integer get() {
return Preconditions.checkNotNull(
module.provideInt(), "Cannot return null from a non-@Nullable @Provides method");
}
public static Factory<Integer> create(ModuleA module) {
return new ModuleA_ProvideIntFactory(module);
}
/** Proxies {@link ModuleA#provideInt()}. */
public static int proxyProvideInt(ModuleA instance) {
return instance.provideInt();
}
}
还是一个工厂，接受ModuleA，然后使用其provideInt()方法来产生int参数。你可能会问，那为什么不直接用ModuleA呢？嗯，好问题。我现在还不知道，继续看。
MainActivity_MembersInjector
没有变化，还是贴出来。
public final class MainActivity_MembersInjector implements MembersInjector<MainActivity> {
private final Provider<ClassA> classAProvider;
public MainActivity_MembersInjector(Provider<ClassA> classAProvider) {
assert classAProvider != null;
this.classAProvider = classAProvider;
}
public static MembersInjector<MainActivity> create(Provider<ClassA> classAProvider) {
return new MainActivity_MembersInjector(classAProvider);
}
@Override
public void injectMembers(MainActivity instance) {
if (instance == null) {
throw new NullPointerException("Cannot inject members into a null reference");
}
instance.classA = classAProvider.get();
}
public static void injectClassA(MainActivity instance, Provider<ClassA> classAProvider) {
instance.classA = classAProvider.get();
}
}
DaggerClassAComponent
public final class DaggerClassAComponent implements ClassAComponent {
private Provider<Integer> provideIntProvider;
private Provider<ClassA> classAProvider;
private MembersInjector<MainActivity> mainActivityMembersInjector;
private DaggerClassAComponent(Builder builder) {
assert builder != null;
initialize(builder);
}
public static Builder builder() {
return new Builder();
}
@SuppressWarnings("unchecked")
private void initialize(final Builder builder) {
this.provideIntProvider = ModuleA_ProvideIntFactory.create(builder.moduleA);
this.classAProvider = ClassA_Factory.create(provideIntProvider);
this.mainActivityMembersInjector = MainActivity_MembersInjector.create(classAProvider);
}
@Override
public void inject(MainActivity activity) {
mainActivityMembersInjector.injectMembers(activity);
}
public static final class Builder {
private ModuleA moduleA;
private Builder() {}
public ClassAComponent build() {
if (moduleA == null) {
throw new IllegalStateException(ModuleA.class.getCanonicalName() + " must be set");
}
return new DaggerClassAComponent(this);
}
public Builder moduleA(ModuleA moduleA) {
this.moduleA = Preconditions.checkNotNull(moduleA);
return this;
}
}
}
可以看到，现在Builder就要求传入一个ModuleA，然后在initialize方法里面把上面介绍的几个组合起来，最终实现依赖注入。
下期我们将再添加一个int参数，来看看Dagger是如何应对多参数以及同类型参数的。
