android关于dagger2原理的浅聊

基于注解的编码思想，是现在一种降低模块间耦合度的通用方式。形成了多种应用和框架技术，其中包括典型Spring的DI和IOC特色。

现在基本讲解一下最简单的例子。

1. 首先准备依赖：

implementation "com.google.dagger:dagger:2.6"
annotationProcessor ‘com.google.dagger:dagger-compiler:2.6‘
注意：如果使用kotlin编程，应该使用
apply plugin: ‘kotlin-kapt‘

kapt ‘com.google.dagger:dagger-compile:2.6‘
kapt是一种注解处理器，用于在编译时生成辅助代码。

2. 准备model
class Cat{}

3. 准备CatModule，依赖对象的提供方
@Module
class CatModule {
　　@Provides
　　fun provideCar(): Car = Car()
}

4. 准备Component，依赖注入组件,将提供方的资源提供给需求方Activity
@Component{modules = [CarModule::class]}
interface CommonComponent {
　　fun inject(activity: MainActivity)
}

6. 最后直接在需求方MainActivity中注入
class MainActivity: AppCompatActivity() {
　　override fun onCreate(saveInstanceState: Bundle?) {
　　　　super.onCreate()
　　　　DaggerCommonComponent.create().inject(this)
　　}
}

流程搞定。

二、dagger2原理
Dagger的核心类是DaggerCommonComponent
首先@Component会在编译时生成一个DaggerCommonComponent的实现类。包含两个成员

private Provider<Car> provideCarProvider;  // 注入对象provider

private MembersInjector<MainActivity> mainActivityMembersInjector;  // 向需求方的依赖注入组件

调用create()，

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

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

public static final class Builder {
  private CarModule carModule;

  private Builder() {}

  public MainComponent build() {
    if (carModule == null) {
      this.carModule = new CarModule();
    }
    return new DaggerMainComponent(this);
  }

  public Builder carModule(CarModule carModule) {
    this.carModule = Preconditions.checkNotNull(carModule);
    return this;
  }
}
从源码调用实现来看，首先生成builder类，而builder类中包含依赖提供方。然后初始化

private void initialize(final Builder builder) {

  this.provideCarProvider = CarModule_ProvideCarFactory.create(builder.carModule);

  this.mainActivityMembersInjector = MainActivity_MembersInjector.create(provideCarProvider);
}

CarModule_ProvideCarFactory和MainActivity_MembersInjector都是编译时自动生成的，首先看CarModule_ProvideCarFactory这个工厂类

public final class CarModule_ProvideCarFactory implements Factory<Car> {
  private final CarModule module;

  public CarModule_ProvideCarFactory(CarModule module) {
    assert module != null;
    this.module = module;
  }

  @Override
  public Car get() {
    return Preconditions.checkNotNull(
        module.provideCar(), "Cannot return null from a non-@Nullable @Provides method");
  }

  public static Factory<Car> create(CarModule module) {
    return new CarModule_ProvideCarFactory(module);
  }
}
create()直接将依赖提供方对象Provider实例化，大致作用就是将Provider对象传递给

MainActivity_MembersInjector中，MainActivity_MembersInjector就是将provider对象和activity关联起来的，
通过使用inject注入依赖需求方，然后MainActivity的car对象到此注入成功。