本文是自己的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描述，使用后，就能得到全局单例的变量了！这里就不添重复代码了。

Ｏver~~