淺析Dagger2依賴注入實現過程

　　Dragger2是Android應用開發中一個非常優秀的依賴注入框架。本文主要通過結合Google給出的MVP開發案例todo-mvp-dagger（GitHub連接地址：https://github.com/googlesamples/android-architecture/tree/todo-mvp-dagger/），簡要分析一下Dragger2的依賴注入實現過程。

　　如果是剛入手學習Dragger2，這里推薦三篇非常不錯的連載文章：http://www.jianshu.com/p/cd2c1c9f68d4，這三篇文章寫得非常用心，而且思路清晰，生動有趣，容易理解。

　　todo-mvp-dagger在功能上划分為addedittask，statistics，taskdetail，tasks四個模塊，由於每個模塊除了功能邏輯不同之外，實現方式相差不大，所以我就只分析其中的tasks模塊，其它模塊可參照此模塊的分析流程來分析。

　　Dragger2的依賴注入是通過Java注解的方式來實現的。Dragger2中提供了@Inject，@Component，@Module，@Provides等一系列注解，通過注解，Dragger2能夠在程序編譯階段利用程序員創建的Java文件，按照編譯模板自動生成對應的.class輔助文件，在這些.class輔助文件中會有相應代碼來自動完成依賴對象的創建。Dragger2正是以此種看似自動化的技術手段來代替手動new對象的過程。如下圖，紅色框中的.class文件就是Tasks模塊在編譯過后自動生成的.class輔助文件。

　　其實，現在有很多框架都利用了注解的方式，通過在編譯階段生成相應的.class文件來完成依賴注入或者其它某些操作，如阿里已經開源的路由框架ARouter。

　　那Dragger2的依賴注入究竟是怎樣的一個過程呢？我們先來看TasksActivity。下面是TasksActivity的部分代碼。

　　TasksActivity中依賴了一個對象：mTasksPresenter。mTasksPresenter用@Inject標注，表示在TasksActivity實例化時，mTasksPresenter需要被自動創建，然后注入到TasksActivity實例當中去。此時，我們可能會想，是不是用@Inject標注一下就實現依賴注入了？其實不然。我們看到上圖下方的紅色框中有一段代碼，這段代碼很長，因為DaggerTasksComponent這個類中使用了Builder模式，只要稍微拆分一下明白了，其實這段代碼就做了一件事情，就是調用了TasksComponent的inject()方法，而這里才是mTasksPresenter真正被實例化的地方。

　　我們再來看TasksComponent，這是一個很簡單的接口，里面聲明了一個inject(TasksActivity activity)方法：

package com.example.android.architecture.blueprints.todoapp.tasks;

import com.example.android.architecture.blueprints.todoapp.ToDoApplication;
import com.example.android.architecture.blueprints.todoapp.data.source.TasksRepositoryComponent;
import com.example.android.architecture.blueprints.todoapp.util.FragmentScoped;

import dagger.Component;

/**
 * This is a Dagger component. Refer to {@link ToDoApplication} for the list of Dagger components
 * used in this application.
 * <P>
 * Because this component depends on the {@link TasksRepositoryComponent}, which is a singleton, a
 * scope must be specified. All fragment components use a custom scope for this purpose.
 */
@FragmentScoped
@Component(dependencies = TasksRepositoryComponent.class, modules = TasksPresenterModule.class)
public interface TasksComponent {
    
    void inject(TasksActivity activity);

}

　　有接口，對應的一般就有實現類，TasksComponent的實現類在哪里呢？我們注意到TasksComponent 被@Component標注，@Component是干什么的？@Component是用來標識接口或者抽象類，被@Componen標注的接口或者抽象類，在程序編譯階段會自動生成帶Dragger前綴的.class文件，例如TasksComponent 被@Component標注，就會生成DraggerTasksComponent.class文件。生成的.class文件便是被@Component標注的接口或者抽象類的實現。我們點開DraggerTasksComponent.class，其中的代碼是這樣子的：

package com.example.android.architecture.blueprints.todoapp.tasks;

import com.example.android.architecture.blueprints.todoapp.data.source.TasksRepository;
import com.example.android.architecture.blueprints.todoapp.data.source.TasksRepositoryComponent;

import javax.annotation.Generated;
import javax.inject.Provider;

import dagger.MembersInjector;
import dagger.internal.Factory;
import dagger.internal.Preconditions;

@Generated(
        value = "dagger.internal.codegen.ComponentProcessor",
        comments = "https://google.github.io/dagger"
)
public final class DaggerTasksComponent implements TasksComponent {
    private MembersInjector<TasksPresenter> tasksPresenterMembersInjector;

    private Provider<TasksRepository> getTasksRepositoryProvider;

    private Provider<TasksContract.View> provideTasksContractViewProvider;

    private Provider<TasksPresenter> tasksPresenterProvider;

    private MembersInjector<TasksActivity> tasksActivityMembersInjector;

    private DaggerTasksComponent(Builder builder) {
        assert builder != null;
        initialize(builder);
    }

    public static Builder builder() {
        return new Builder();
    }

    @SuppressWarnings("unchecked")
    private void initialize(final Builder builder) {

        this.tasksPresenterMembersInjector = TasksPresenter_MembersInjector.create();

        this.getTasksRepositoryProvider =
                new Factory<TasksRepository>() {
                    private final TasksRepositoryComponent tasksRepositoryComponent =
                            builder.tasksRepositoryComponent;

                    @Override
                    public TasksRepository get() {
                        return Preconditions.checkNotNull(
                                tasksRepositoryComponent.getTasksRepository(),
                                "Cannot return null from a non-@Nullable component method");
                    }
                };

        this.provideTasksContractViewProvider =
                TasksPresenterModule_ProvideTasksContractViewFactory.create(builder.tasksPresenterModule);

        this.tasksPresenterProvider =
                TasksPresenter_Factory.create(
                        tasksPresenterMembersInjector,
                        getTasksRepositoryProvider,
                        provideTasksContractViewProvider);

        this.tasksActivityMembersInjector =
                TasksActivity_MembersInjector.create(tasksPresenterProvider);
    }

    @Override
    public void inject(TasksActivity activity) {
        tasksActivityMembersInjector.injectMembers(activity);
    }

    public static final class Builder {
        private TasksPresenterModule tasksPresenterModule;

        private TasksRepositoryComponent tasksRepositoryComponent;

        private Builder() {
        }

        public TasksComponent build() {
            if (tasksPresenterModule == null) {
                throw new IllegalStateException(
                        TasksPresenterModule.class.getCanonicalName() + " must be set");
            }
            if (tasksRepositoryComponent == null) {
                throw new IllegalStateException(
                        TasksRepositoryComponent.class.getCanonicalName() + " must be set");
            }
            return new DaggerTasksComponent(this);
        }

        public Builder tasksPresenterModule(TasksPresenterModule tasksPresenterModule) {
            this.tasksPresenterModule = Preconditions.checkNotNull(tasksPresenterModule);
            return this;
        }

        public Builder tasksRepositoryComponent(TasksRepositoryComponent tasksRepositoryComponent) {
            this.tasksRepositoryComponent = Preconditions.checkNotNull(tasksRepositoryComponent);
            return this;
        }
    }
}

　　DaggerTasksComponent采用了Builder模式進行設計，實現了inject(TasksActivity activity)方法。DaggerTasksComponent中的代碼有一點點多，而且成員變量都是泛型類對象，看似稍微有點復雜，我們可以整體大概看一下，然后還是從inject(TasksActivity activity)方法的實現入手。inject(TasksActivity activity)的實現很簡單，就一行代碼：

tasksActivityMembersInjector.injectMembers(activity);

　　這一行代碼調用了接口MembersInjector<T>的void injectMembers(T instance)方法，好，接下來我們看看MembersInjector<T>以及其中的void injectMembers(T instance)方法是用來做什么的。MembersInjector<T>的代碼如下：

package dagger;

/**
 * Injects dependencies into the fields and methods on instances of type {@code T}. Ignores the
 * presence or absence of an injectable constructor.
 *
 * @param <T> type to inject members of
 *
 * @author Bob Lee
 * @author Jesse Wilson
 * @since 2.0 (since 1.0 without the provision that {@link #injectMembers} cannot accept
 *      {@code null})
 */
public interface MembersInjector<T> {

  /**
   * Injects dependencies into the fields and methods of {@code instance}. Ignores the presence or
   * absence of an injectable constructor.
   *
   * <p>Whenever the object graph creates an instance, it performs this injection automatically
   * (after first performing constructor injection), so if you're able to let the object graph
   * create all your objects for you, you'll never need to use this method.
   *
   * @param instance into which members are to be injected
   * @throws NullPointerException if {@code instance} is {@code null}
   */
  void injectMembers(T instance);
}

　　看過注釋，我們知道了，原來這個接口就是用來將依賴注入到目標實體（即依賴對象所依附的實體，顯然，這里就是指TasksActivity）當中去。到這里，我們好像有點眉目了。不着急，我們繼續看MembersInjector<T>的實現。剛剛我們看了DaggerTasksComponent中inject(TasksActivity activity)方法的實現，里面的tasksActivityMembersInjector對象調用了injectMembers()方法，因此可斷定tasksActivityMembersInjector就是MembersInjector<T>的實現類對象，那么，tasksActivityMembersInjector是怎么得來的呢？繼續看DaggerTasksComponent的代碼，發現tasksActivityMembersInjector是這樣被創建的：

this.tasksActivityMembersInjector = TasksActivity_MembersInjector.create(tasksPresenterProvider);

　　TasksActivity_MembersInjector的create()方法創建了tasksActivityMembersInjector。於是，我們再來看TasksActivity_MembersInjector這個類，TasksActivity_MembersInjector代碼如下：

package com.example.android.architecture.blueprints.todoapp.tasks;

import javax.annotation.Generated;
import javax.inject.Provider;

import dagger.MembersInjector;

@Generated(
        value = "dagger.internal.codegen.ComponentProcessor",
        comments = "https://google.github.io/dagger"
)
public final class TasksActivity_MembersInjector implements MembersInjector<TasksActivity> {
    private final Provider<TasksPresenter> mTasksPresenterProvider;

    public TasksActivity_MembersInjector(Provider<TasksPresenter> mTasksPresenterProvider) {
        assert mTasksPresenterProvider != null;
        this.mTasksPresenterProvider = mTasksPresenterProvider;
    }

    public static MembersInjector<TasksActivity> create(
            Provider<TasksPresenter> mTasksPresenterProvider) {
        return new TasksActivity_MembersInjector(mTasksPresenterProvider);
    }

    @Override
    public void injectMembers(TasksActivity instance) {
        if (instance == null) {
            throw new NullPointerException("Cannot inject members into a null reference");
        }
        instance.mTasksPresenter = mTasksPresenterProvider.get();
    }

    public static void injectMTasksPresenter(
            TasksActivity instance, Provider<TasksPresenter> mTasksPresenterProvider) {
        instance.mTasksPresenter = mTasksPresenterProvider.get();
    }
}

　　TasksActivity_MembersInjector正是剛剛我們所看的MembersInjector<T>的一個實現類，TasksActivity_MembersInjector實現了injectMembers()，在injectMembers()的實現中干了這么一件事情：

instance.mTasksPresenter = mTasksPresenterProvider.get();

　　哦！原來TasksActivity中的mTasksPresenter是通過mTasksPresenterProvider.get()得來的！此時，迷霧變得逐漸清晰了！接下來再看mTasksPresenterProvider是如何來的。

　　mTasksPresenterProvider在TasksActivity_MembersInjector的構造方法中被賦值，而TasksActivity_MembersInjector的構造方法是在create()方法中被調用的，於是，我們回到DaggerTasksComponent中調用TasksActivity_MembersInjector的create()方法的地方。找到傳入create()方法的參數tasksPresenterProvider，發現tasksPresenterProvider又是由TasksPresenter_Factory的create()方法創建的。接下來，我們進一步看TasksPresenter_Factory的代碼：

package com.example.android.architecture.blueprints.todoapp.tasks;

import com.example.android.architecture.blueprints.todoapp.data.source.TasksRepository;

import javax.annotation.Generated;
import javax.inject.Provider;

import dagger.MembersInjector;
import dagger.internal.Factory;
import dagger.internal.MembersInjectors;

@Generated(
        value = "dagger.internal.codegen.ComponentProcessor",
        comments = "https://google.github.io/dagger"
)
public final class TasksPresenter_Factory implements Factory<TasksPresenter> {
    private final MembersInjector<TasksPresenter> tasksPresenterMembersInjector;

    private final Provider<TasksRepository> tasksRepositoryProvider;

    private final Provider<TasksContract.View> tasksViewProvider;

    public TasksPresenter_Factory(
            MembersInjector<TasksPresenter> tasksPresenterMembersInjector,
            Provider<TasksRepository> tasksRepositoryProvider,
            Provider<TasksContract.View> tasksViewProvider) {
        assert tasksPresenterMembersInjector != null;
        this.tasksPresenterMembersInjector = tasksPresenterMembersInjector;
        assert tasksRepositoryProvider != null;
        this.tasksRepositoryProvider = tasksRepositoryProvider;
        assert tasksViewProvider != null;
        this.tasksViewProvider = tasksViewProvider;
    }

    @Override
    public TasksPresenter get() {
        return MembersInjectors.injectMembers(
                tasksPresenterMembersInjector,
                new TasksPresenter(tasksRepositoryProvider.get(), tasksViewProvider.get()));
    }

    public static Factory<TasksPresenter> create(
            MembersInjector<TasksPresenter> tasksPresenterMembersInjector,
            Provider<TasksRepository> tasksRepositoryProvider,
            Provider<TasksContract.View> tasksViewProvider) {
        return new TasksPresenter_Factory(
                tasksPresenterMembersInjector, tasksRepositoryProvider, tasksViewProvider);
    }
}

　　我們發現，在TasksPresenter_Factory實現的get()方法中，一個匿名TasksPresenter對象被創建，這個匿名對象正是被注入到TasksActivity的依賴對象！

　　我們再回過頭來看，因為這里的get()方法其實就是Provider<TasksPresenter>的具體實現，在TasksActivity_MembersInjector中的injectMembers(TasksActivity instance)方法中被TasksActivity_MembersInjector的成員變量mTasksPresenterProvider調用，mTasksPresenterProvider調用get()方法后返回的結果被賦值給TasksActivity實例中的依賴對象mTasksPresenter。

　　至此，Dragger2中一個完整的依賴注入過程分析就此結束。誠然，本文只是簡單梳理了一下依賴注入的整個流程，對於更深層次的問題，如：Dragger是如何設計.class文件自動生成模板的，自動生成.class文件的具體過程是什么樣的等等，本文暫時沒有說明，這也是我接下來要做的事情，剛好這幾天也在看ARouter的源碼，發現其中的依賴注入實現和Dragger2差不多，所以，我打算從多個源碼框架中來對比分析和總結Android中的依賴注入實現，待領悟再深入一個層次之后再發一篇總結性文章。