写一个最基本的注入过程,分别有ClassA,ModuleA,ComponentA三个类
public class ClassA {
}
@Module
public class ModuleA {
@Provides
public ClassA provideA(){
return new ClassA();
}
}
@Component(modules = ModuleA.class)
public interface ComponentA {
void inject(MainActivity activity);
}
然后在MainActivity中注入ClassA
public class MainActivity extends AppCompatActivity {
@Inject
ClassA a;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
DaggerComponentA.create().inject(this);
}
}
下面从 DaggerComponentA.create().inject(this)这句代码开始分析
public final class DaggerComponentA implements ComponentA {
private ModuleA moduleA;
private DaggerComponentA(Builder builder) {
initialize(builder);
}
public static Builder builder() {
return new Builder();
}
public static ComponentA create() {
return new Builder().build();
}
@SuppressWarnings("unchecked")
private void initialize(final Builder builder) {
this.moduleA = builder.moduleA;
}
@Override
public void inject(MainActivity activity) {
injectMainActivity(activity);
}
private MainActivity injectMainActivity(MainActivity instance) {
MainActivity_MembersInjector.injectA(instance, ModuleA_ProvideAFactory.proxyProvideA(moduleA));
return instance;
}
public static final class Builder {
private ModuleA moduleA;
private Builder() {}
public ComponentA build() {
if (moduleA == null) {
this.moduleA = new ModuleA();
}
return new DaggerComponentA(this);
}
public Builder moduleA(ModuleA moduleA) {
this.moduleA = Preconditions.checkNotNull(moduleA);
return this;
}
}
}
可以看到inject的过程是调用了
MainActivity_MembersInjector.injectA(instance, ModuleA_ProvideAFactory.proxyProvideA(moduleA));
下面分析MembersInjector源码
public final class MainActivity_MembersInjector implements MembersInjector<MainActivity> {
private final Provider<ClassA> aProvider;
public MainActivity_MembersInjector(Provider<ClassA> aProvider) {
this.aProvider = aProvider;
}
public static MembersInjector<MainActivity> create(Provider<ClassA> aProvider) {
return new MainActivity_MembersInjector(aProvider);
}
@Override
public void injectMembers(MainActivity instance) {
injectA(instance, aProvider.get());
}
public static void injectA(MainActivity instance, ClassA a) {
instance.a = a;
}
}
可以看到injectA就是将ClassA 对象赋给了MainActivity对象中的a成员
再看Module_ProvideAFactory.ProxyProvideA(moduleA);
public final class ModuleA_ProvideAFactory implements Factory<ClassA> {
private final ModuleA module;
public ModuleA_ProvideAFactory(ModuleA module) {
this.module = module;
}
@Override
public ClassA get() {
return provideInstance(module);
}
public static ClassA provideInstance(ModuleA module) {
return proxyProvideA(module);
}
public static ModuleA_ProvideAFactory create(ModuleA module) {
return new ModuleA_ProvideAFactory(module);
}
public static ClassA proxyProvideA(ModuleA instance) {
return Preconditions.checkNotNull(
instance.provideA(), "Cannot return null from a non-@Nullable @Provides method");
}
}
可以看到,ClassA 对象实际是来自moduleA的provideA方法。
如此,dagger框架将Module中的ClassA对象注入到了MainActivity中
再看另一种情况,不用Module类注入对象
写一个类ClassB
public class ClassB {
@Inject
public ClassB(){
}
}
注意,在这个类的构造方法上写上@Inject
编译后,再看DaggerComponentA
private MainActivity injectMainActivity(MainActivity instance) {
MainActivity_MembersInjector.injectA(instance, ModuleA_ProvideAFactory.proxyProvideA(moduleA));
MainActivity_MembersInjector.injectB(instance, new ClassB());
return instance;
}
可以看到在injectB时是直接new一个ClassB对象
两种注入的方式分析结束