写一个最基本的注入过程，分别有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对象
两种注入的方式分析结束