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-androiddagger-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.javaMainActivity_MembersInjector.javaDaggerClassAComponent.java。我们一个个地来探究。
ClassA_Factory.java

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

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

  public static Factory<ClassA> create() {
    return INSTANCE;
  }
}

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

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

再看看Provider<T>接口:

/**
 * 注释已省略
 */
public interface Provider<T> {

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

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

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();
  }
}

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

public final class DaggerClassAComponent implements ClassAComponent {
  private MembersInjector<MainActivity> 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类也将崭露头角。

推荐阅读更多精彩内容