上一期我们用最简单的例子来实现了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是如何应对多参数以及同类型参数的。
网友评论