上一期我們用最簡單的例子來實現了Dagger的依賴注入，雖然對過程大致有了了解，但是還有很多功能和部件還沒有被使用。
這一期我們更進一步，在ClassA里面添加一個參數，來看看Dagger是如何運作的。

代碼主體

首先在ClassA添加一個新的成員變量：

public class ClassA {

  private int a;

  @Inject
  public ClassA(int a) {
    this.a = a;
  }

  public int getA() {
    return a;
  }
}

那么之前的ClassA_Factory需要知道ClassA的參數，當然這里有@Inject可以讓Dagger讀取參數表。另一個問題就是，怎么傳入參數？
此時就不得不提到Module了。如果說Component是注入器的話，Module則是負責產生所需參數的部件。來看看代碼：

@Module
public class ModuleA {
  private int a;
  public ModuleA(int a) {
    this.a = a;
  }

  @Provides
  int provideInt() {
    return a;
  }
}

可以看到，與Component是接口不同，'Module'其實是用'@Module'標注的對象，有構造器。值得一提的是里面包含的用'@Provides'標注的方法，這就是提供參數時產生作用的函數，其名字無關緊要，只要返回類型能對上號就行。那么這里就有一個問題，有多個同類型的怎么辦呢？這就涉及到另外一些標注了，此處暫且不提。
那么Component是如何與'Module'相連接的？答案是通過標注參數：

@Component(modules = ModuleA.class)
public interface ClassAComponent {
  void inject(MainActivity activity);
}

同樣可以預見的是實現注入的代碼肯定也有變化：
DaggerClassAComponent.builder().moduleA(new ModuleA(2333)).build().inject(this);
即需要傳入'Module'從而提供注入所需參數。可能你說，這不還是new了嗎？這里new的是'Module'，可沒有new一個ClassA。ClassA的產生確實已經委托出去了。
MainActivity的代碼：

public class MainActivity extends AppCompatActivity {
  @Inject ClassA classA;
  private static final String TAG = "MainActivity";

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    DaggerClassAComponent.builder()
        .moduleA(new ModuleA(2333))
        .build().inject(this);
    Log.d(TAG, classA.getA() + "");
  }
}

生成代碼

'Module'的加入究竟導致了哪些變化？來看看生成代碼吧。

ClassA_Factory

public final class ClassA_Factory implements Factory<ClassA> {
  private final Provider<Integer> aProvider;

  public ClassA_Factory(Provider<Integer> aProvider) {
    assert aProvider != null;
    this.aProvider = aProvider;
  }

  @Override
  public ClassA get() {
    return new ClassA(aProvider.get());
  }

  public static Factory<ClassA> create(Provider<Integer> aProvider) {
    return new ClassA_Factory(aProvider);
  }
}

與上一次的ClassA_Factory有稍許不同，這次工廠構建方法需要一個Provider<Integer> aProvider來提供創建'ClassA'時所需的參數。

ModuleA_ProvideIntFactory

這是一個新的文件：

public final class ModuleA_ProvideIntFactory implements Factory<Integer> {
  private final ModuleA module;

  public ModuleA_ProvideIntFactory(ModuleA module) {
    assert module != null;
    this.module = module;
  }

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

  public static Factory<Integer> create(ModuleA module) {
    return new ModuleA_ProvideIntFactory(module);
  }

  /** Proxies {@link ModuleA#provideInt()}. */
  public static int proxyProvideInt(ModuleA instance) {
    return instance.provideInt();
  }
}

還是一個工廠，接受ModuleA，然后使用其provideInt()方法來產生int參數。你可能會問，那為什么不直接用ModuleA呢？嗯，好問題。我現在還不知道，繼續看。

MainActivity_MembersInjector

沒有變化，還是貼出來。

public final class MainActivity_MembersInjector implements MembersInjector<MainActivity> {
  private final Provider<ClassA> classAProvider;

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

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

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

  public static void injectClassA(MainActivity instance, Provider<ClassA> classAProvider) {
    instance.classA = classAProvider.get();
  }
}

DaggerClassAComponent

public final class DaggerClassAComponent implements ClassAComponent {
  private Provider<Integer> provideIntProvider;

  private Provider<ClassA> classAProvider;

  private MembersInjector<MainActivity> mainActivityMembersInjector;

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

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

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

    this.provideIntProvider = ModuleA_ProvideIntFactory.create(builder.moduleA);

    this.classAProvider = ClassA_Factory.create(provideIntProvider);

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

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

  public static final class Builder {
    private ModuleA moduleA;

    private Builder() {}

    public ClassAComponent build() {
      if (moduleA == null) {
        throw new IllegalStateException(ModuleA.class.getCanonicalName() + " must be set");
      }
      return new DaggerClassAComponent(this);
    }

    public Builder moduleA(ModuleA moduleA) {
      this.moduleA = Preconditions.checkNotNull(moduleA);
      return this;
    }
  }
}

可以看到，現在Builder就要求傳入一個ModuleA，然后在initialize方法里面把上面介紹的幾個組合起來，最終實現依賴注入。

下期我們將再添加一個int參數，來看看Dagger是如何應對多參數以及同類型參數的。