说在前面：别人都是从两个端出发开始连线，而我是从线开始寻找连接的端。
本文仅提供一个思考的方向，是我本人对Dagger2的理解，如若错误请留言指正，3Q。并且本文打算私藏，由于同桌好友需要阅读，姑且公开了吧。
阅读本文前需要先阅读 littleKang 的文章 http://www.jianshu.com/p/39d1df6c877d
1: Component
首先确定我们的目的：为了解耦，我们使用依赖注入的方式，去分离变量的声明和实例化。若分离了实例化，则实例化需要打参数必定是通过某种方式去获得。而下面我要讲的就是这个参数（this）的传递过程。
Component作为连接目标和源的桥梁，所以在Component必定包含了目标和源的引用。所以看Google为我们生成的代码（大部分是工厂类），没错我们直接从这部分代码开始。
// Ours
@Component(modules = MainModule.class)
public interface MainComponent {
void inject(MainActivity activity);
}
// Google
public final class DaggerMainComponent implements MainComponent {
private Provider<MainContract.View> provideMainViewProvider;
private Provider<MainPresenter> mainPresenterProvider;
private MembersInjector<MainActivity> mainActivityMembersInjector;
private DaggerMainComponent(Builder builder) {
assert builder != null;
initialize(builder);
}
public static Builder builder() {
return new Builder();
}
@SuppressWarnings("unchecked")
private void initialize(final Builder builder) {
this.provideMainViewProvider = MainModule_ProvideMainViewFactory.create(builder.mainModule);
this.mainPresenterProvider = MainPresenter_Factory.create(provideMainViewProvider);
this.mainActivityMembersInjector = MainActivity_MembersInjector.create(mainPresenterProvider);
}
@Override
public void inject(MainActivity activity) {
mainActivityMembersInjector.injectMembers(activity);
}
public static final class Builder {
private MainModule mainModule;
private Builder() {}
public MainComponent build() {
if (mainModule == null) {
throw new IllegalStateException(MainModule.class.getCanonicalName() + " must be set");
}
return new DaggerMainComponent(this);
}
public Builder mainModule(MainModule mainModule) {
this.mainModule = Preconditions.checkNotNull(mainModule);
return this;
}
}
}
根据
DaggerMainComponent.builder()
.mainModule(new MainModule(this))
.build()
.inject(this);
的调用顺序看Google生成的代码，
-
DaggerMainComponent调用静态方法builder()返回内部静态类Builder的对象 - 接着调用的是
Builder的方法mainModule()去实例化属性mainModule,而调用该方法时this参数传递到了Module - 接着调用
build()方法，使用静态内部类完成DaggerMainComponent的创建（直到这里可以发现Component已经连接到了Module），值得一说的就是在new DaggerMainComponent时调用了initialize() - 在
initialize()中，初始化了三个属性（三个工厂类对象），这里需要注意到的是参数，MainModule_ProvideMainViewFactory的参数是builder,这本类中已经完成builder的初始化；接着下面的两个属性的初始化都是以它上一个的对象作为参数，而且都是实例化完毕的！（直到这里知道，这里没有哪个是没有初始化的， That is good!） - 完成了
DaggerMainComponent的创建就可以使用inject()方法，该方法中调用了injectMembers()方法，注入activity参数，而改参数是MainActivity给予的，这在理解上完全没问题的。（直到这里可以看到DaggerMainComponent连接MainActivity的苗头了，好像这里没看出连接了啥，嗯，确实是，后面会接着说这个问题）
2: Module
在1.中已经知道了Module的工厂类的create()方法被调用，已经实现了初始化，那么我们下面直接从create()方法开始看
// Ours
@Module
public class MainModule {
private final MainContract.View mView;
public MainModule(MainContract.View view) {
mView = view;
}
@Provides
MainContract.View provideMainView() {
return mView;
}
}
// Google
public final class MainModule_ProvideMainViewFactory implements Factory<MainContract.View> {
private final MainModule module;
public MainModule_ProvideMainViewFactory(MainModule module) {
assert module != null;
this.module = module;
}
@Override
public MainContract.View get() {
return Preconditions.checkNotNull(
module.provideMainView(), "Cannot return null from a non-@Nullable @Provides method");
}
public static Factory<MainContract.View> create(MainModule module) {
return new MainModule_ProvideMainViewFactory(module);
}
}
-
create()方法调用了改工厂类的初始化方法，而参数module是1.中调用该工厂类的ceate()方法时给予的，所以不要再考虑谁给的参数用来实例化 - 实例化好该工厂类之后，将
module.provideMainView()返回，之后就可以供Factory<MainContract.View>的对象获取对象mView了
3: Presenter（或者是我们自己创建的类，供宿主（MainActivity）使用的类）
这里是一样的，在1.中调用了create()方法，直接从该方法开始分析
// Ours
public class MainPresenter {
MainContract.View mView;
@Inject
MainPresenter(MainContract.View view) {
mView = view;
}
}
// Google
public final class MainPresenter_Factory implements Factory<MainPresenter> {
private final Provider<MainContract.View> viewProvider;
public MainPresenter_Factory(Provider<MainContract.View> viewProvider) {
assert viewProvider != null;
this.viewProvider = viewProvider;
}
@Override
public MainPresenter get() {
return new MainPresenter(viewProvider.get());
}
public static Factory<MainPresenter> create(Provider<MainContract.View> viewProvider) {
return new MainPresenter_Factory(viewProvider);
}
}
-
create()方法中实例化并返回该工厂类的对象，而该类中的get()方法直接返回我们需要依赖的MainPresenter对象，而实例化所需要的参数在create()方法给出！（还没有思路的话就绕着这个参数返回阅读） - 直到这里，我们可以了解这么一个情况，从
MainActivity中给予的参数经过一系列的传递，最后传到了MainPresenter()中，那么也就是说，我们直接调用这里的get()方法便可以直接获取MainPresenter类的实例！ - 那么好，经过一系列的传递后该对象得到了初始化有了，然而怎么讲这么实例传回
MainActivity？
4: MembersInjector
在这里我们可以返回到1.中的最后的问题：连接！
终于到这一步了，看到前面参数一层一层传递，初始化了各种的工厂类，等着你一个get()的调用，我就给你初始化好的实例了！还是照样，代码搬上来说话。
public final class MainActivity_MembersInjector implements MembersInjector<MainActivity> {
private final Provider<MainPresenter> mainPresenterProvider;
public MainActivity_MembersInjector(Provider<MainPresenter> mainPresenterProvider) {
assert mainPresenterProvider != null;
this.mainPresenterProvider = mainPresenterProvider;
}
public static MembersInjector<MainActivity> create(
Provider<MainPresenter> mainPresenterProvider) {
return new MainActivity_MembersInjector(mainPresenterProvider);
}
@Override
public void injectMembers(MainActivity instance) {
if (instance == null) {
throw new NullPointerException("Cannot inject members into a null reference");
}
instance.mainPresenter = mainPresenterProvider.get();
}
public static void injectMainPresenter(
MainActivity instance, Provider<MainPresenter> mainPresenterProvider) {
instance.mainPresenter = mainPresenterProvider.get();
}
}
在这里我还得提示一点就是1.中的这个方法重写里面的调用
@Override
public void inject(MainActivity activity) {
mainActivityMembersInjector.injectMembers(activity);
}
- 在这里我们还是先看看已经在
1.中初始化了的MainActivity_MembersInjector对象的create()方法干了啥：调用构造方法，并直接返回该工厂类的对象！（这会儿，看看1.中调用injectMembers()，或许你会激动点啥的...） - 对应的，我们直接找
injectMembers()方法，该方法的实现就在这个工厂类里边儿，而且我们有点激动的发现，我们传进来的宿主MainActivity的对象（引用）的属性mainPresenter得到了赋值（初始化！），而等号右边的就是已经准备好了提供Present实例的get()方法！ - 知道这里可以想到了，
Component是连接两头的关键之处
