理解 Dagger2 的源码
Dagger2 帮助我们将被注入类自动地注入到目标类，有利解耦，从而让维护项目的依赖关系变得轻松。

通过代码实现一下 dagger 是如何实现依赖注入，我们创建一个类 DataManager 用作被注入的类。

public class DataManager {

    private static final String TAG = "DataManager";

    public DataManager() {
        Log.d(TAG, "DataManager: ininial");
    }
}

然后我们需要 DataManager 注入到目标中 MainActivity，因为 MainActivity 并不是由我们开发人员直接创建的，是由系统创建，所以我们需要将一些依赖以属性的形式进行注入

public class MainActivity extends AppCompatActivity {

    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
       
    }
}

好我们就开始来实现，要进行注入，如果熟悉 dagger 知道我们需要一个 module 类和一个 component 接口

首先 Module 负责提供要注入的类的对象，在 Dagger 中我们需要 @Module 来修饰为了是 apt 能够识别到这个类进行代码生成工作。

public class AppModule {

    public DataManager provideManager(){
        return new DataManager();
    }
}

然后 Component 负责将被注入类注入到目标类中，在 Dagger 中我们需要注解 @Component 以及将 @Component 以及已经定义依赖的 module

public interface AppComponent {
    void inject(MainActivity activity);
}

最后我们还需要 MainActivity 中做一些事

public class MainActivity extends AppCompatActivity {

    public DataManager dataManager;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        ScAppComponent.builder()
                .appMoudle(new AppModule())
                .build() //使用构建者模式创建一个 Component 实例
                .inject(this);
    }
}

需要做两件事

1. 将 DataManager 作为属性，需要是 public 类型

在编译过程会用到 apt 技术生成一些类用来实现，这里我们就手动写这些类

通常使用时我们通常会以这种形式来实现，

DaggerAppComponent
    .builder()
    .appModule(new AppModule())
    .build()
    .inject(this)

appModule 应该代码生成时根据 AppModule 生成方法，通过 builder 可看出来这里使用构建者的设计模式。我们这里手动地完成代码生成以便了解 dagger 是如何将类 DataManager 注入到 MainActivity

我们先写 ScAppComponent 这个自动生成的类，在 Dagger 命名应该为 DaggerAppComponent，这里我用我习惯的 Sc 开头以便区别，这里 ScAppComponent 实现之前定义好的 AppComponent 接口，实现 inject 方法，这个方法指定要将 DataManager 注入的位置。

public class ScAppComponent implements AppComponent{

    private Provider<DataManager> provideManagerProvider;
    private MembersInjector<MainActivity> mainActivityMembersInjector;

    public ScAppComponent(Builder builder) {
        assert builder != null;
        initialize(builder);
    }

    private void initialize(final Builder builder){
        this.provideManagerProvider = (Provider<DataManager>) AppModule_ProvideManagerFactory.create(builder.appModule);
        this.mainActivityMembersInjector = MainActivity_MembersInjector.create(provideManagerProvider);
    }

    @Override
    public void inject(MainActivity activity) {
        mainActivityMembersInjector.injectMembers(activity);
    }

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

    public static AppComponent create(){
        return builder().build();
    }

    public static final class Builder{

        private AppModule appModule;

        private Builder(){}

        public AppComponent build(){
            if(appModule == null){
                this.appModule = new AppModule();
            }

            return new ScAppComponent(this);
        }

        public Builder appMoudle(AppModule appModule){
//            this.appModule = Preconditions.checkNotNull(appModule)
            return this;
        }

    }
}

1. 调用 builder 方法时，会返回一个内部静态类 Builder 的实例

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

1. 内部静态类 Builder ,这是一般构建者的模式的 Builder，然后调用 Builder 类的 build 方法看代码会给我们返回一个 AppComponent 然后我们看代码 build

   1. 先创建了一个 AppModule
   2. 然后将 Builder 自己作为参数传入给 AppComponent 构造函数创建一个 AppComponent 实例。

2. 在 AppComponent 构造函数中会调用 initialize 方法

    private void initialize(final Builder builder){
       this.provideManagerProvider = (Provider<DataManager>) AppModule_ProvideManagerFactory.create(builder.appModule);
       this.mainActivityMembersInjector = MainActivity_MembersInjector.create(provideManagerProvider);
   }
   

在 initialize 方法中，会初始化

private Provider<DataManager> provideManagerProvider;
private MembersInjector<MainActivity> mainActivityMembersInjector;

这里我们在分别看一下这两个 AppModule_ProvideManagerFactory 和 MainActivity_MembersInjector 他们俩也是通过 APT 生成，所以我们一步一步写一写，来了解他们都做了什么，先看 AppModule_ProvideManagerFactory ，看名字应该是一个工厂类，用于生成 DataManager 实例的吧。

public final class AppModule_ProvideManagerFactory implements Factory<DataManager> {

    private final AppModule module;

    public AppModule_ProvideManagerFactory(AppModule module) {
        assert module != null;
        this.module = module;
    }

    @Override
    public DataManager get() {
        return module.provideManager();
    }

    public static Factory<DataManager> create(AppModule module){
        return new AppModule_ProvideManagerFactory(module);
    }
}

我们从 create 入手，这里返回一个 Factory<DataManager> 类型的对象那么我们就简单定义一下。Factory<T> 作为一个接口扩展了 Provider<T>接口

public interface Factory<T> extends Provider<T>{
}

所以定义一下Provider<T> 有一个方法 get 用于返回我们创建好的（要注入的）实例

public interface Provider<T> {
    T get();
}

好准备好了所需的接口，我们再回到 AppModule_ProvideManagerFactory 这需要实现 Factory<T> 接口，用于提供产品的工厂吧
这里的 get 方法中是调用我们 module（AppModule)的 provideManager 方法来返回 DataManager 那么我们就需要有一个 AppModule 的实例，实现起来也是一套

1. create 创建自己然后 module 传入
2. module 作为 AppModule_ProvideManagerFactory 参数在构造赋值
3. 调用 get 实际就是调用 AppModule.provideManager

然后再看 MainActivity_MembersInjector 这个类，需要实现 MembersInjector<T> 接口

public interface MembersInjector<T> {

    void injectMembers(T t);
}

public class MainActivity_MembersInjector implements MembersInjector<MainActivity> {

    private final Provider<DataManager> dataManagerProvider;

    public MainActivity_MembersInjector(Provider<DataManager> dataManagerProvider) {
        assert dataManagerProvider != null;
        this.dataManagerProvider = dataManagerProvider;
    }

    public static MembersInjector<MainActivity> create(Provider<DataManager> dataManagerProvider){
        return new MainActivity_MembersInjector(dataManagerProvider);
    }


    @Override
    public void injectMembers(MainActivity instance) {
        if(instance == null){
            throw new NullPointerException("空指针");
        }
        instance.dataManager = dataManagerProvider.get();

    }

    public static void injectDataManager(
            MainActivity instance, Provider<DataManager> dataManagerProvider
    ){
        instance.dataManager = dataManagerProvider.get();
    }
}

这里 create 需要传入 Provider<DataManager> 的 dataManagerProvider 提供 DataManger ，调用 dataManagerProvider.get 方法就可以得到 DataManager 的实例让然后在 injectDataManager 方法中将这个实例赋值给 MainActivity的dataManager 属性来完成注入。所以这个类需要一个 Provider<DataManager> 实例这是在构造函数传入的 create 的方式与上面的 AppModule_ProvideManagerFactory 的 create 套路相同,injectMembers(MainActivity instance) 是将 MainActivity 导入进入，然后我们就可以轻松地将 provider 提供 DataManager 实例赋给 MainActivity 的属性。

3. 这里调用 inject方法是 ScAppComponent的 inject 方法 也就是
mainActivityMembersInjector 的 injectMembers 方法来将 MainActivity 传入到类供注入

ScAppComponent.builder()
.appMoudle(new AppModule())
.build() //使用构建者模式创建一个 Component 实例
.inject(this);

运行代码

: DataManager: ininial