前言

上一篇文章中Android開發(fā)之Dagger2--源碼角度分析inject過程（二），主要通過源碼分析了注入過程，但是還有一個遺留問題，那就是Module和Component各有什么用，該怎么理解，我們將在這篇文章中討論。

代碼回顧分析

• 1.Student類，構造方法上添加@Inject注解

public class Student {

    private String mess="Student的實例是注解方式注入的";

   @Inject
    public Student(){

    }

    public String showMessage(){
        return mess;
    }

}

• 2.Module類，Module類上必須加上@Module注解，Module是模塊的意思，說明這是一個模塊，但是我們目前在這里面什么也沒做。

@Module
public class MainModule {

}

• 3.Component類，是一個接口，Component是零件，組件的意思，說明這個接口的作用是連接各個組件，更形象的稱法是注入器，前面必須加上@Component(modules = MainModule.class)注解，說明這是個是把MainModule模塊提供的數(shù)據(jù)注入到目的地的。

@Singleton
@Component(modules = MainModule.class)
public interface MainComponent {
    void inject(Daggertest1Activity daggertest1Activity);
}

• 4.Activity類

@Inject
    Student mStudent;  // 注入Studnet的實例

  DaggerMainComponent.builder()
                .mainModule(new MainModule())
                .build()
                .inject(this);

Module&Component

那么Module到底是做什么的呢，我們修改一下代碼。

• 1.去掉Student類的@Inject注解

public class Student {

    private String mess="Student的實例是注解方式注入的";

    public Student(){

    }

    public String showMessage(){
        return mess;
    }

• 2. Module類增加一個Provide注解方法，提供Student的實例

@Module
public class MainModule {

    public MainModule(){

    }

    @Provides
    @Singleton
    Student provideStudent(){
        return new Student();
    }
}

其他地方都不變，先把app/build文件夾刪除，我們編譯后重新運行。
效果圖就不貼了，一樣的效果。
這時打開app\build\generated\source\apt\debug\com\jackson\daggertest目錄，可以看到照樣是生成了三個文件， MainModule_ProvideStudentFactory.java，DaggerMainComponent.java，Daggertest1Activity_MembersInjector.java，我們繼續(xù)簡要的分析一下源碼。

• 1.MainModule_ProvideStudentFactory

public final class MainModule_ProvideStudentFactory implements Factory<Student> {
  private final MainModule module;

  public MainModule_ProvideStudentFactory(MainModule module) {
    this.module = module;
  }

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

  public static MainModule_ProvideStudentFactory create(MainModule module) {
    return new MainModule_ProvideStudentFactory(module);
  }

  public static Student proxyProvideStudent(MainModule instance) {
    return Preconditions.checkNotNull(
        instance.provideStudent(), "Cannot return null from a non-@Nullable @Provides method");
  }
}

我們是在MainModule里緹歐拱了一個Provide方法，在方法里提供了Student的實體類，可以看到，編譯以后生成一個MainModule_ProvideStudentFactory工廠，只不過這個工廠必須要傳入MainModule的實例才能實例化。

同樣，create()方法提供工廠實例

 public static MainModule_ProvideStudentFactory create(MainModule module) {
    return new MainModule_ProvideStudentFactory(module);
  }

get()方法獲取Student實例

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

• 2.DaggerMainComponent

public final class DaggerMainComponent implements MainComponent {
  private Provider<Student> provideStudentProvider;

  private DaggerMainComponent(Builder builder) {
    initialize(builder);
  }

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

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

  @SuppressWarnings("unchecked")
  private void initialize(final Builder builder) {
    this.provideStudentProvider =
        DoubleCheck.provider(MainModule_ProvideStudentFactory.create(builder.mainModule));
  }

  @Override
  public void inject(Daggertest1Activity daggertest1Activity) {
    injectDaggertest1Activity(daggertest1Activity);
  }

  private Daggertest1Activity injectDaggertest1Activity(Daggertest1Activity instance) {
    Daggertest1Activity_MembersInjector.injectMStudent(instance, provideStudentProvider.get());
    return instance;
  }

  public static final class Builder {
    private MainModule mainModule;

    private Builder() {}

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

    public Builder mainModule(MainModule mainModule) {
      this.mainModule = Preconditions.checkNotNull(mainModule);
      return this;
    }
  }
}

變化不大，多了一個initialize()方法

@SuppressWarnings("unchecked")
  private void initialize(final Builder builder) {
    this.provideStudentProvider =
        DoubleCheck.provider(MainModule_ProvideStudentFactory.create(builder.mainModule));
  }

我們看到有個DoubleCheck，調(diào)用了DoubleCheck.provider（）方法，我們點進去

 /** Returns a {@link Provider} that caches the value from the given delegate provider. */
  // This method is declared this way instead of "<T> Provider<T> provider(Provider<T> delegate)"
  // to work around an Eclipse type inference bug: https://github.com/google/dagger/issues/949.
  public static <P extends Provider<T>, T> Provider<T> provider(P delegate) {
    checkNotNull(delegate);
    if (delegate instanceof DoubleCheck) {
      /* This should be a rare case, but if we have a scoped @Binds that delegates to a scoped
       * binding, we shouldn't cache the value again. */
      return delegate;
    }
    return new DoubleCheck<T>(delegate);
  }

可以看到，這是一個雙重鎖提供的單例方法，這是延遲加載的需要，更詳細的請參考<Effective Java 2> item 71。

• 3.Daggertest1Activity_MembersInjector
  沒有變化

總結

綜上，通過對上述兩種注入方法的分析，可以看到，要注入一個類，可以通過兩種方法：

• 1 在類的構造方法上添加@Inject注解

• 2 @Module +@Providers注入工廠的方式

• @Inject 在需要依賴注入的地方使用，配合注入方法將要注入的對象注入

• @Module 用次注解的類，提供@Provides注解的以provide開頭的方法，具體提供依賴

• @Component 用來將@Inject和@Module聯(lián)系起來的橋梁，從@Module中獲取依賴并將依賴注入給@Inject
  好了，本文結束，前面提過了，Dagger2適合在mvp模式中使用，下一篇文章，將會在mvp里使用Dagger。