本文是自己的Dagger2学习总结，可能有很多误解和偏差，欢迎交流指正~
什么是Dagger2？
简单来说，Dagger2是一个通过注解的方式来实现依赖注入的框架。注解大家肯定都见过，我们常用的ButterKnife就是通过注解的方式来避免繁琐的findView,同时google释放的源码中也有诸多注解（@hide,@override,@param等等）。至于依赖注入，就是就是一种减少类与类之间耦合的手段。总结一下就是避免在一个类中直接new另一个类的实例，因为当另一个类因为业务调整需要修改时，其他类就可以避免做相应修改，减少代码的耦合程度和维护成本。语言表达能力有限，直接看code：
public class Zoo {
Lion lion;
Tiger tiger;
public Zoo() {
lion = new Lion();
tiger = new Tiger();
}
public String showPerformance(){
return lion.perform()+" "+tiger.perform();
}
}
public class Lion {
public Lion() {
}
public String perform(){
return "跳火圈";
}
}
public class Tiger {
public Tiger() {
}
public String perform(){
return "舞蹈";
}
}
我们花巨资新建了一个动物园，现在动物园里每周末会有狮子和老虎的节目表演，经过一段时间后，为了让动物更方便与游客互动，决定给动物起名字。所以我们的Lion、Tiger类需要做如下修改：
public class Lion {
String name;
public Lion(String name) {
this.name=name;
}
public String perform(){
return name+"跳火圈";
}
}
public class Tiger {
String name;
public Tiger(String name) {
this.name = name;
}
public String perform(){
return name+"舞蹈";
}
}
给动物起完名字之后，突然发现动物园的结构（构造方法）
public Zoo() {
lion = new Lion();
tiger = new Tiger();
}
也需要做修改，修改成
public Zoo() {
lion = new Lion("blink");
tiger = new Tiger("dagger");
}
这也就相当于我们给动物起了个名字，居然影响到了动物园，需要请工人重新设计装修动物园，这显然是不合理的。所以为了解除动物园与动物之间的耦合，我们需要做如下修改：
public class Zoo {
Lion lion;
Tiger tiger;
public Zoo(Lion lion,Tiger tiger) {
this.lion = lion;
this.tiger = tiger;
}
public String showPerformance(){
return lion.perform()+" "+tiger.perform();
}
}
我们将lion与tiger的赋值工作直接交给了构造函数的参数，同理我们也可以使用set方式，甚至通过为Lion、Tiger添加get方法来为zoo中的lion、tiger赋值，这样无论动物怎么换名字，都与我们的zoo结构无关，你只需要关心传入什么参数。
至此，对什么是依赖注入应该有了一个大体的理解。
简单使用Dagger2
使用前先为我们的as添加如下依赖配置：
Project级的gradle中添加
classpath 'com.neenbedankt.gradle.plugins:android-apt:1.4'
Module级的gradle中添加
apply plugin: 'com.neenbedankt.android-apt'
apt 'com.google.dagger:dagger-compiler:2.0'
compile 'com.google.dagger:dagger:2.0'
provided 'javax.annotation:javax.annotation-api:1.2'
上面说了Dagger是一个通过注解的方式来实现依赖注入的框架，所以想要它为我们实现依赖注入，我们要先了解几个简单的注解。
1.@Inject
2.@Module
3.@Provides
4.@Component
老规矩先大体说下上述每个注解的作用，接着直接show code!
@Inject 注解在某个具体的变量上，表示该变量需要Dagger2帮我们来实例化；注解在某个类的构造方法上，表示我们在需要该实例的时候，Dagger2框架会自动寻找到标注有@Inject注解的构造，并将其实例化提供给我们
@Module @Module专门用来管理向外界提供依赖的类，@Module可以给不能修改源码的类提供依赖，需要与@Provides配合使用。
@Provides 在@Module注解的类中，我们通过@Provides注解可以向外界提供依赖注入的对象。
@Component 连接依赖方和提供依赖方之间的匕首，当我们定义好了依赖方和提供依赖方之后，还需要通过@Component注解作为一种媒介，使得Dagger2框架能正常工作。
先看下@Inject的使用：
先用@Inject标注构造方法
public class Doggie {
@Inject
public Doggie() {
}
public String yelp(){
return "汪汪汪";
}
}
public class Cat {
@Inject
public Cat() {
}
public String yelp(){
return "喵喵喵";
}
}
接着直接在MainActivity中标注相关变量，看能不能获取到实例
@Inject
Doggie doggie;
@Inject
Cat cat;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Log.d(TAG,"doggie :"+doggie.yelp());
Log.d(TAG,"cat :"+cat.yelp());
}
run一下试试~直接nullpoint崩了，少了最重要的"插入匕首"的那步！那就要通过@Component自己锻一把注入的匕首：
@Component
public interface DaggerComponent {
void inject(MainActivity mainActivity);
}
要手动rebuild一哈，as才会帮我自动编译生成DaggerComponent类，从而才能接着完成注入。
DaggerDaggerComponent.create().inject(this);
看一下运行Log:
01-01 16:00:22.449 21066-21066/com.blink.lucky.dagger2 D/blink: doggie :汪汪汪
01-01 16:00:22.449 21066-21066/com.blink.lucky.dagger2 D/blink: cat :喵喵喵
@Module && @Provides完成依赖注入：
首先要创建一个专门向外界提供依赖对象的Module类
@Module
public class MyModule {
@Provides
public Doggie providerDoggie(){
Log.d("blink","doggie created by module");
return new Doggie();
}
@Provides
public Cat providerCat(){
Log.d("blink","cat created by module");
return new Cat();
}
}
接着要修改下我们的Component类，通过添加（modules = MyModule.class）属性，让Dagger2从MyModule类中获取提供的依赖对象。
@Component (modules = MyModule.class)
public interface DaggerComponent {
void inject(MainActivity mainActivity);
}
运行Log
01-01 16:30:34.071 8309-8309/com.blink.lucky.dagger2 D/blink: doggie created by module
01-01 16:30:34.072 8309-8309/com.blink.lucky.dagger2 D/blink: cat created by module
01-01 16:30:34.073 8309-8309/com.blink.lucky.dagger2 D/blink: doggie :汪汪汪
01-01 16:30:34.073 8309-8309/com.blink.lucky.dagger2 D/blink: cat :喵喵喵
通过分析log我们也能得出一个很重要的规则，注解了@Inject的对象，会优先寻找@Module类中是否有@Provides返回对应类型的对象，次优先寻找@Inject注解的构造方法为我们提供所依赖的对象。
上面是最简单的单重依赖，接下来我们看下多重依赖（比如说Doggie类里又依赖其他类）的话要怎么修改代码：
我们为Doggie添加一个Kind的依赖类，来表示他是什么类型的小狗，需要注意不能直接new DogKind,我们把它注入进构造函数：
public class Doggie {
DogKind dogKind;
@Inject
public Doggie(DogKind dogKind) {
this.dogKind = dogKind;
}
public String yelp(){
return "汪汪汪";
}
}
public class DogKind {
public DogKind(String kind) {
Log.d("blink","我是"+kind);
}
}
一定要在Module类中向外提供DogKind：
@Provides
public DogKind providerDogkind() {
return new DogKind("柴犬");
}
最后Inject后，直接看log结果：
01-02 10:05:54.768 3255-3255/com.blink.lucky.dagger2 D/blink: 我是柴犬
01-02 10:05:54.768 3255-3255/com.blink.lucky.dagger2 D/blink: doggie created by module
01-02 10:05:54.769 3255-3255/com.blink.lucky.dagger2 D/blink: cat created by module
01-02 10:05:54.769 3255-3255/com.blink.lucky.dagger2 D/blink: doggie :汪汪汪
01-02 10:05:54.769 3255-3255/com.blink.lucky.dagger2 D/blink: cat :喵喵喵
到这里，双重依赖的原理也就显而易见了，就是不断依赖注入，然后通过Dagger框架帮我们去解析@Provides 或 @Inject注解，为我们实例化对象。
Dagger2进阶
- @Qulifier和@Scope
@Qulifier表示限定注解，当我们的Module类中，有多个相同返回类型的方法时，Dagger2自然无法分辨需要通过哪个@Provides来提供依赖变量（Dagger2会根据Module中标记了@Provide的方法的返回值来确定由谁为这个变量提供实例），这时候@Qulifier就能登场了。我们通过@Qulifier自定义一个注解，来手动地为Dagger2框架指明，当返回类型相同时，通过哪个@Provides来提供依赖变量。
首先定义一个注解：
@Qualifier//限定符
@Retention(RetentionPolicy.RUNTIME)
public @interface CustomType {
String value() default "";//默认值为""
}
接着在Module中，通过为@CustomType注解写入不同的value，来为Dagger2指明方向：
@Provides
@CustomType
public Doggie providerUnnamedDoggie () {
return new Doggie();
}
@Provides
@CustomType ("name")
public Doggie providerNamedDoggie () {
return new Doggie("嘻嘻");
}
最后，就能愉快地使用了~：
@CustomType
Doggie doggie;
@Inject
@CustomType ("name")
Doggie doggie2;
贴一下log,发现确实根据不同限定符为我们实例化了两条小狗：
01-02 13:51:51.105 7148-7148/com.blink.lucky.dagger2 D/blink: 我是一条小狗~
01-02 13:51:51.105 7148-7148/com.blink.lucky.dagger2 D/blink: 我是一条叫嘻嘻的小狗~
01-02 13:51:51.105 7148-7148/com.blink.lucky.dagger2 D/blink: doggie :汪汪汪
01-02 13:51:51.105 7148-7148/com.blink.lucky.dagger2 D/blink: doggie2 :汪汪汪
@Scope
Dagger2通过@Scope注解来实现局部单例，当我们需要同一类变量时，@Scope让依赖方向我们提供同一个单例，栗子：
同样，先定义一个注解
@Scope
@Retention(RetentionPolicy.RUNTIME)
public @interface CustomScope {
}
接着在Moudle类中，我们需要Dagger2为我们提供同一只小猫，所以在providerCat()方法上添加@CustomScope注解
@Provides
@CustomScope
public Cat providerCat(){
Log.d("blink","cat created by module");
return new Cat();
}
另外有一点需要注意，因为@Scope是局部的单例注解，即仅在Component的生命周期内提供单例，所以我们需要在Component 接口中做一下修改：
@CustomScope
@Component (modules = MyModule.class)
public interface DaggerComponent {
void inject(MainActivity mainActivity);
}
使用（Cat使用了@Scope注解，Doggie未使用）：
@Inject
Cat cat;
@Inject
Cat cat2;
@Inject
Doggie doggie_1;
@Inject
Doggie doggie_2;
Log.d("blink","cat ?= cat 2 "+ (cat==cat2));
Log.d("blink","doggie_1 ?= doggie_2 "+ (doggie_1==doggie_2));
运行后的log如下
01-02 15:53:23.014 25597-25597/com.blink.lucky.dagger2 D/blink: cat ?= cat 2 true
01-02 15:53:23.014 25597-25597/com.blink.lucky.dagger2 D/blink: doggie_1 ?= doggie_2 false
这里再额外补充下Component的生命周期：
DaggerDaggerComponent.create().inject(this);
其实这句话就展示了Component的所有生命周期，
DaggerDaggerComponent.create() -- 创建
.inject(this); -- 注入，可以理解为状态活跃中
最后当onCreate()结束后 -- 我们的Component也一并被销毁了，周期结束
我们可以这样验证下：
Cat tmpCat;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
DaggerDaggerComponent.create().inject(this);
Log.d("blink","cat ?= cat 2 "+ (cat==cat2));
tmpCat = cat;
Log.d("blink","doggie_1 ?= doggie_2 "+ (doggie_1==doggie_2));
//Log.d(TAG,"doggie :"+doggie.yelp());
//Log.d(TAG,"doggie2 :"+doggie2.yelp());
//Log.d(TAG,"cat :"+cat.yelp());
}
@Override
protected void onResume() {
super.onResume();
DaggerDaggerComponent.create().inject(this);
Log.d("blink","tmpCat:"+tmpCat.yelp());
Log.d("blink","tmpCat ?= cat 2 "+ (tmpCat==cat2));
}
01-02 16:35:54.652 2717-2717/com.blink.lucky.dagger2 D/blink: tmpCat:喵喵喵
01-02 16:33:50.294 31204-31204/com.blink.lucky.dagger2 D/blink: tmpCat ?= cat 2 false
通过上述Log我们可以发现，在onResume时候，上一个Component的周期显然结束了，所以此时onResume的两个cat虽然是单例的，但是与onCreate中的单例cat是两个不同的对象！
@Singleton
有局部单例肯定也会有全局单例，这就是@Singleton的作用了。使用方法和@Scope完全一致：首先通过@Singleton自定义一个注解，接着在Moudle类中，通过自定义的@Singleton注解标记相关Provides方法，最后在Component匕首接口中添加@Singleton描述，使用后，就能得到全局单例的变量了！这里就不添重复代码了。