网上关于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<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的实例，然后赋值。很明显，这样的话ClassA在MainActivity不能是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类也将崭露头角。
