Dagger 2学习与探索（一）

网上关于Dagger 2（以下简称Dagger）的文章可谓多如牛毛，其中也有不少深入浅出的精品。只是别人的终究是别人的，纸上得来终觉浅，绝知此事要躬行。

什么是Dagger？

简而言之，就是一个依赖注入框架。Github主页。
什么是依赖注入？
比如说，我们经常会在编程时用到：Obj obj = new Obj(para1, para2, ...);这表示当前编程的对象依赖于这个obj对象。而依赖注入就是把para1, para2, ...等丢给别人，让别人来给自己一个Obj obj。Dagger的特色就是使用标记、自动生成等一系列手段。

为什么要使用Dagger？

上面提到，Dagger首先是依赖注入框架，因此是依赖注入的子类。
那么使用依赖注入有哪些好处？
一次注入所有依赖。想象一下你需要一个A，然后A依赖于B，B依赖于C，C依赖于D……于是你只好一个个把它们给new出来。而有了依赖框架，你可以一口气一次注入。当然，复杂度其实是被转移到其他文件了，不过这样有利于保持代码的清晰简洁。
易于复用。一旦依赖注入框架搭建好，在新的地方可以很方便地复用。
易于测试。因为测试对象不自己创建依赖对象，而是向外界要，测试框架可以很方便地mock出来然后给测试对象。
好，那么Dagger有什么好处？很明显就是标记和自动生成使得代码量减小。

使用Dagger

说了这么多没营养的话，还是开始写代码吧。

添加Gradle依赖

这个主页上写的很明白了。现在最新版本是2.11，那么在app的build.gradle里添加以下几行：

    compile 'com.google.dagger:dagger:2.11'
    annotationProcessor 'com.google.dagger:dagger-compiler:2.11'

    compile 'com.google.dagger:dagger-android:2.11'
    compile 'com.google.dagger:dagger-android-support:2.11' // if you use the support libraries
    annotationProcessor 'com.google.dagger:dagger-android-processor:2.11'

如果你细心的话会发现，我们导入了两个东西，一个是dagger本体，还有一个dagger-android。dagger-android是dagger为安卓开发特制的一些工具，以后再说。

写一个最简单的例子

创建一个新的空白Activity的工程。
接着，我们要使用Dagger在MainActivity里来注入一个最简单的无参对象ClassA。
记住Dagger不是神仙，代码里面也没有魔法或者巫术，一切归根结底还是你熟悉的那套东西。那么要想Dagger帮你注入，起码得解决这几个问题：

• 注入什么？
• 注入到哪里去？
• 注入参数有什么？
• 参数从哪里找？
• 如何实现注入？

先来看问题1：注入什么？也就是如何让Dagger知道注入的依赖对象。答案就是在MainActivity里对ClassA加上@Inject标记，表面这个就是要注入的东西。即：

public class MainActivity extends AppCompatActivity {
  @Inject ClassA classA;
...

问题2：注入到哪里去？MainActivity里面有了@Inject，这样dagger是不是就知道要注入到这里呢？
答案是否定的，因为dagger并没有使用反射。Dagger需要你明确地告诉它要注入到哪里去。这里就涉及到Component标记的接口了：

@Component
public interface ClassAComponent {
  void inject(MainActivity activity);
}

其实Component有一个很重要的搭档Module，不过现在还没涉及，暂时不提。
Component的字面意思是组件，其实我觉得叫injector之类的更贴切，因为Dagger就是根据Component来生成注入器实现注入的。
此外这里使用的是MainActivity类而不是AppCompatActivity类，也是值得注意的一点。
问题3：注入参数有什么？这里的ClassA没有参数，但是Dagger如何知道呢？
答案就是给ClassA的构造器也加上@Inject标记：

public class ClassA {

  @Inject
  public ClassA() {
  }
}

问题4：参数从哪里找？由于ClassA没有参数所以暂时略过。
问题5：如何实现注入？Dagger会用Component来生成一个Dagger+[ComponentName]的类，然后用该类来实现注入：

DaggerClassAComponent.builder().build().inject(this);

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().build().inject(this);
    Log.d(TAG, classA.getClass().getSimpleName());
  }
}

运行可以发现，Log执行了打印，也就是说ClassA注入成功了。

探究生成代码

很神奇吗？其实背后的工作都被生成的代码承担了。
如果翻翻工程的generated文件夹，会发现多出下列几个文件：
ClassA_Factory.java，MainActivity_MembersInjector.java，DaggerClassAComponent.java。我们一个个地来探究。
ClassA_Factory.java：

public final class ClassA_Factory implements Factory {
  private static final ClassA_Factory INSTANCE = new ClassA_Factory();

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

  public static Factory create() {
    return INSTANCE;
  }
}

这是一个ClassA的工厂类。可以看到实现了Factory接口，那么再深挖一下这个接口：

/**
 * 注释已省略
 */
public interface Factory extends Provider {
}

再看看Provider接口：

/**
 * 注释已省略
 */
public interface Provider {

    /**
     * 注释已省略
     */
    T get();
}

这个接口就是用来获取某个类的实例。
再来看看MainActivity_MembersInjector.java：

public final class MainActivity_MembersInjector implements MembersInjector {
  private final Provider classAProvider;

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

  public static MembersInjector create(Provider 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 classAProvider) {
    instance.classA = classAProvider.get();
  }
}

从字面意思来看，这个类就是MainActivity的成员注入器。可以看到其构造器依赖于一个Provider的实现类，然后注入的手段就是调用MainActivity的实例，然后赋值。很明显，这样的话ClassA在MainActivity不能是private的，否则就没法实现了。
现在真相已经渐渐浮出水面，最后一块拼图将把上面两个类连接起来：

public final class DaggerClassAComponent implements ClassAComponent {
  private MembersInjector mainActivityMembersInjector;

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

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

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

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

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

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

  public static final class Builder {
    private Builder() {}

    public ClassAComponent build() {
      return new DaggerClassAComponent(this);
    }
  }
}

DaggerClassAComponent使用的是建造者模式，其构造器是私有的。
回想其调用：DaggerClassAComponent.builder().build().inject(this);
调用静态的builder()方法获取new Builder()，然后执行build()方面获取new DaggerClassAComponent(this)触发initialize(builder)，此时把上面介绍的两个生成类注入进来，然后在inject(MainActivity activity)方法里面实现注入。
可以看到，代码还是使用我们熟悉的工厂、建造者模式，甚至我们也可以自己写一套。当然有了Dagger的自动生成这一切的代码量大大减少。

下期预告

当然了，本期使用的可以说是最最最简单的Dagger例子了，不过麻雀虽小五脏俱全，至少展现出了Dagger完整工作的流程。
下一期，我们将对ClassA添加参数，届时Module类也将崭露头角。