前言
上一篇文章中Android开发之Dagger2--源码角度分析inject过程（二），主要通过源码分析了注入过程，但是还有一个遗留问题，那就是Module和Component各有什么用，该怎么理解，我们将在这篇文章中讨论。
代码回顾分析
- 1.Student类，构造方法上添加@Inject注解
public class Student {
private String mess="Student的实例是注解方式注入的";
@Inject
public Student(){
}
public String showMessage(){
return mess;
}
}
- 2.Module类，Module类上必须加上@Module注解，Module是模块的意思，说明这是一个模块，但是我们目前在这里面什么也没做。
@Module
public class MainModule {
}
- 3.Component类，是一个接口，Component是零件，组件的意思，说明这个接口的作用是连接各个组件，更形象的称法是注入器，前面必须加上@Component(modules = MainModule.class)注解，说明这是个是把MainModule模块提供的数据注入到目的地的。
@Singleton
@Component(modules = MainModule.class)
public interface MainComponent {
void inject(Daggertest1Activity daggertest1Activity);
}
- 4.Activity类
@Inject
Student mStudent; // 注入Studnet的实例
DaggerMainComponent.builder()
.mainModule(new MainModule())
.build()
.inject(this);
Module&Component
那么Module到底是做什么的呢，我们修改一下代码。
- 1.去掉Student类的@Inject注解
public class Student {
private String mess="Student的实例是注解方式注入的";
public Student(){
}
public String showMessage(){
return mess;
}
-
- Module类增加一个Provide注解方法，提供Student的实例
@Module
public class MainModule {
public MainModule(){
}
@Provides
@Singleton
Student provideStudent(){
return new Student();
}
}
其他地方都不变，先把app/build文件夹删除，我们编译后重新运行。
效果图就不贴了，一样的效果。
这时打开app\build\generated\source\apt\debug\com\jackson\daggertest目录，可以看到照样是生成了三个文件， MainModule_ProvideStudentFactory.java，DaggerMainComponent.java，Daggertest1Activity_MembersInjector.java，我们继续简要的分析一下源码。
- 1.MainModule_ProvideStudentFactory
public final class MainModule_ProvideStudentFactory implements Factory {
private final MainModule module;
public MainModule_ProvideStudentFactory(MainModule module) {
this.module = module;
}
@Override
public Student get() {
return Preconditions.checkNotNull(
module.provideStudent(), "Cannot return null from a non-@Nullable @Provides method");
}
public static MainModule_ProvideStudentFactory create(MainModule module) {
return new MainModule_ProvideStudentFactory(module);
}
public static Student proxyProvideStudent(MainModule instance) {
return Preconditions.checkNotNull(
instance.provideStudent(), "Cannot return null from a non-@Nullable @Provides method");
}
}
我们是在MainModule里缇欧拱了一个Provide方法，在方法里提供了Student的实体类，可以看到，编译以后生成一个MainModule_ProvideStudentFactory工厂，只不过这个工厂必须要传入MainModule的实例才能实例化。
同样，create()方法提供工厂实例
public static MainModule_ProvideStudentFactory create(MainModule module) {
return new MainModule_ProvideStudentFactory(module);
}
get()方法获取Student实例
@Override
public Student get() {
return Preconditions.checkNotNull(
module.provideStudent(), "Cannot return null from a non-@Nullable @Provides method");
}
- 2.DaggerMainComponent
public final class DaggerMainComponent implements MainComponent {
private Provider provideStudentProvider;
private DaggerMainComponent(Builder builder) {
initialize(builder);
}
public static Builder builder() {
return new Builder();
}
public static MainComponent create() {
return new Builder().build();
}
@SuppressWarnings("unchecked")
private void initialize(final Builder builder) {
this.provideStudentProvider =
DoubleCheck.provider(MainModule_ProvideStudentFactory.create(builder.mainModule));
}
@Override
public void inject(Daggertest1Activity daggertest1Activity) {
injectDaggertest1Activity(daggertest1Activity);
}
private Daggertest1Activity injectDaggertest1Activity(Daggertest1Activity instance) {
Daggertest1Activity_MembersInjector.injectMStudent(instance, provideStudentProvider.get());
return instance;
}
public static final class Builder {
private MainModule mainModule;
private Builder() {}
public MainComponent build() {
if (mainModule == null) {
this.mainModule = new MainModule();
}
return new DaggerMainComponent(this);
}
public Builder mainModule(MainModule mainModule) {
this.mainModule = Preconditions.checkNotNull(mainModule);
return this;
}
}
}
变化不大，多了一个initialize()方法
@SuppressWarnings("unchecked")
private void initialize(final Builder builder) {
this.provideStudentProvider =
DoubleCheck.provider(MainModule_ProvideStudentFactory.create(builder.mainModule));
}
我们看到有个DoubleCheck，调用了DoubleCheck.provider（）方法，我们点进去
/** Returns a {@link Provider} that caches the value from the given delegate provider. */
// This method is declared this way instead of " Provider provider(Provider delegate)"
// to work around an Eclipse type inference bug: https://github.com/google/dagger/issues/949.
public static , T> Provider provider(P delegate) {
checkNotNull(delegate);
if (delegate instanceof DoubleCheck) {
/* This should be a rare case, but if we have a scoped @Binds that delegates to a scoped
* binding, we shouldn't cache the value again. */
return delegate;
}
return new DoubleCheck(delegate);
}
可以看到，这是一个双重锁提供的单例方法，这是延迟加载的需要，更详细的请参考
- 3.Daggertest1Activity_MembersInjector
没有变化
总结
综上，通过对上述两种注入方法的分析，可以看到，要注入一个类，可以通过两种方法：
1 在类的构造方法上添加@Inject注解
2 @Module +@Providers注入工厂的方式
@Inject 在需要依赖注入的地方使用，配合注入方法将要注入的对象注入
@Module 用次注解的类，提供@Provides注解的以provide开头的方法，具体提供依赖
@Component 用来将@Inject和@Module联系起来的桥梁，从@Module中获取依赖并将依赖注入给@Inject
好了，本文结束，前面提过了，Dagger2适合在mvp模式中使用，下一篇文章，将会在mvp里使用Dagger。