Dagger2:上手就爱不释手

概览

• 什么是Dagger2？
  既然有Dagger2那么必然有Dagger1的存在，Dagger1是大名鼎鼎的Square公司受到Guice启发而开发的依赖注入框架，而Dagger2是Dagger1的分支，由谷歌公司接手开发。
  

  • 为什么使用Dagger2?
    1.有利于模块间的解耦，组件依赖的注入独立于业务模块之外
    2.能够清晰地管理实例的有效范围
    3.因为对象的实例化独立于业务，所以当对象的实例化方法改变时，不需要大量地修改业务代码
    4.在编译期即完成依赖的注入，完全静态（说白了就是抛弃了反射）

深入研究

前言讲了那么多，接下来着重从原理和代码方面进行分析

引入Dagger2

Dagger2的引入也非常方便，首先在项目的gradle中配置：

dependencies {          classpath 'com.neenbedankt.gradle.plugins:android-apt:1.4' }

然后在app的gradle中配置:

apply plugin: 'com.neenbedankt.android-apt'...  dependencies {     apt 'com.google.dagger:dagger-compiler:2.0'     compile 'com.google.dagger:dagger:2.0'}

可以看到gradle中出现了apt相关的配置，可以猜到Dagger2的生成与apt技术相关，即通过定义编译期的注解，再通过继承Proccesor生成代码逻辑，有兴趣的同学可以深入学习一番

使用详解

引入了Dagger2之后，首先解释一下Dagger2中的四种常用用法

• @Inject
  主要有两种用法：一是标注相关的构造方法，那么Dagger2在使用时会找到标注有@Inject的构造方法来实例化；第二种是标注在相关的变量，告知Dagger2为其提供依赖

• @Component
  @Component用于标注接口，是依赖需求方和依赖提供方之间的桥梁。被Component标注的接口在编译时会生成该接口的实现类（如果@Component标注的接口为ApplicationComponent，则编译期生成的实现类为DaggerApplicationComponent）,我们通过调用这个实现类的方法完成依赖注入；

• @Module
  @Module用于标注提供依赖的类，但涉及到一些第三方包中的构造方法，或者有参数的构造方法时，我们无法使用@Inject，转而使用@Module进行标注

• @Provide
  @Provide
  用于标注@Module中的方法，提供实例化的操作，并在需要时将依赖注入标注了@Inject的变量

随后这几种注解结合上述基本用法，有意想不到的妙用

• @Qulifier
  @Qulifier 为了区分不同使用不同类型生成的实例，比如@ForActivity 或@ForApplication

• @Scope
  可限定变量的生效范围，形成局部单例

• @Singleton
  这个就比较好理解了，Application级别的单例

只是介绍了基本用法，可能理解起来还是一头雾水，我们接下来结合代码进行进一步阐述

1.仅使用@Inject
首先定义实体类Coke,并用@Inject标注构造方法

public class Coke {    @Inject    public Coke() {                Log.d("process", "a cup of coke was made");          }}

第二步创建Component，命名为CokeComponent。inject方法即代表依赖注入至MainActivity

@Componentpublic interface CokeComponent {    void inject(MainActivity activity);}

在MainActivity中定义变量，并用@Inject标注

public class MainActivity extends AppCompatActivity {   //定义变量并标注@Inject  Coke coke;    @Override    protected void onCreate(Bundle savedInstanceState) {  super.onCreate(savedInstanceState);          setContentView(R.layout.activity_main); //DaggerCokeComponent由CokeComponent生成，调用下面的方法实现依赖注入  DaggerCokeComponent.builder().build().inject(this);    }}

运行程序，则log中打印出：

D/process: a cup of coke was made

然而事实上，我们更多遇到是构造函数含参或者无法直接打上@Inject标记的情况，那么此时就要使用@Module进行依赖注入

2.结合@Module使用

假设我们现在制造一瓶可乐的构造方法为：public Coke(String ingredient)，然后创建一个Module，并命名为CokeModule。用@Provide标注提供实例的方法,并在方法体内加入实例化相关的代码

@Module  public class CokeModule{    public CokeModule() {} @Provides    Coke provideCoke()  {            return new Coke("with suger");      }  }

并对Component进行一点修改，告知Dagger2使用CokeModule提供依赖

@Component (modules = {CokeModule.class})public interface CokeComponent {    void inject(MainActivity activity);}

运行程序，结果为:

D/process: a cup of coke was made with suger

3.结合@Qulifier使用

首先用@Qulifier定义两个注解

@Qualifier@Retention (RetentionPolicy.RUNTIME)public @interface QulifierNonSuger {}

@Qualifier@Retention(RetentionPolicy.RUNTIME)public @interface QulifierSuger {}

其次对CokeModule进行一点改造，支持两种实例化方式

@Modulepublic class CokeModule {     public CokeModule() {}    @QulifierSuger    @Provides   Coke provideCokeWithSuger() {        return new Coke("with suger");    }    @QulifierNonSuger    @Provides    Coke provideCokeWithoutSuger() {            return new Coke("without suger");     }}

在MainActivity创建两个Coke变量，并分别用两种Qulifier注解

@QulifierSuger @InjectCoke cokeA;@QulifierNonSuger@InjectCoke cokeB;

运行程序，两杯不同的可乐就制造出来啦

D/process: a cup of coke was made with suger
D/process: a cup of coke was made without suger

通过上图，我们可以清晰地看出，Module中通过两种Qulifier注解表示了两种实例化对象的方法，Component通过Module中提供的方法将依赖注入标注了不同Qulifier的两个变量

4.结合@Scope使用

好吧，我们继续进行改造~
第一步，定义注解ActivityScope

@Scope@Retention (RetentionPolicy.RUNTIME)public @interface ActivityScope {}

然后用该Scope标注Component和Module

@Modulepublic class CokeModule {        public CokeModule() {}    @ActivityScope    @Provides    Coke provideCokeWithSuger() {        return new Coke("with suger");      }}

@ActivityScope@Component(modules = {CokeModule.class})public interface CokeComponent {    void inject(MainActivity activity);}

我们在MainActivity中定义了两个Coke变量，但可以看到Log只打印了一次，即代表Coke变量在MainActivity范围内是局部单例的

5.扩展应用

如图，Component之间也可以有依赖关系，Dagger2的实际运用中，我们常定义一个应用级别单例的ApplicationComponent来保持对Application的依赖，根据不同粒度（Activity级别或者页面级别）创建依赖于ApplicationComponent的其余Component进行整个应用的依赖注入控制

至此，一个简单的依赖注入使用案例已经结束，但大多数的同学应该还意犹未尽吧，因此我们接下来从Dagger2自动生成的代码层面深入了解Dagger2是如何工作的。

原理探究

这里我们以例子中的情况2作样本，Dagger2生成的代码可以在Build->generated->source->apt中找到

• CokeModule_ProvideCokeWithSugerFactory

@Generated("dagger.internal.codegen.ComponentProcessor")public final class CokeModule_ProvideCokeWithSugerFactory implements Factory<Coke> {  private final CokeModule module;  public CokeModule_ProvideCokeWithSugerFactory(CokeModule module) {       assert module != null;      this.module = module;    }  @Override  public Coke get() {  Coke provided = module.provideCokeWithSuger();      if (provided == null) {      throw new NullPointerException("Cannot return null from a non-@Nullable @Provides method");    }      return provided;  }  public static Factory<Coke> create(CokeModule module) {      return new CokeModule_ProvideCokeWithSugerFactory(module);    }}

代码比较简单，构造方法中传入了CokeModule，get()中通过我们在Module创建的provideCokeWithSugaer()拿到Coke的实例，而create方法我们稍后进行解释

• MainActivity_MembersInjector

@Generated("dagger.internal.codegen.ComponentProcessor")public final class MainActivity_MembersInjector implements MembersInjector<MainActivity> {  private final MembersInjector<AppCompatActivity> supertypeInjector;  private final Provider<Coke> cokeAndCokeAProvider;  public MainActivity_MembersInjector(MembersInjector<AppCompatActivity> supertypeInjector, Provider<Coke> cokeAndCokeAProvider) {     assert supertypeInjector != null;    this.supertypeInjector = supertypeInjector;    assert cokeAndCokeAProvider != null;   this.cokeAndCokeAProvider = cokeAndCokeAProvider;    }  @Override  public void injectMembers(MainActivity instance) {      if (instance == null) {      throw new NullPointerException("Cannot inject members into a null reference");    }    //依赖注入supertypeInjector.injectMembers(instance);     instance.coke = cokeAndCokeAProvider.get();    }  public static MembersInjector<MainActivity> create(MembersInjector<AppCompatActivity> supertypeInjector, Provider<Coke> cokeAndCokeAProvider) {        return new MainActivity_MembersInjector(supertypeInjector, cokeAndCokeAProvider);    }}

构造方法中传入了Injector和Provider，injectMembers()中将instance(MainActivity)通过回调传给Injector，并从Provider中取出Coke的实例赋值给instance。代码最后又出现了create，我们可以肯定有一个桥梁将两者串联在一起，那就是——请继续往下看

• DaggerCokeComponent

@Generated("dagger.internal.codegen.ComponentProcessor")public final class DaggerCokeComponent implements CokeComponent {  private Provider<Coke> provideCokeWithSugerProvider;  private MembersInjector<MainActivity> mainActivityMembersInjector;  private DaggerCokeComponent(Builder builder) {      assert builder != null;    initialize(builder);  }  public static Builder builder() {      return new Builder();  }  public static CokeComponent create() {      return builder().build();  }  private void initialize(final Builder builder) {      this.provideCokeWithSugerProvider = ScopedProvider.create(CokeModule_ProvideCokeWithSugerFactory.create(builder.cokeModule));    this.mainActivityMembersInjector = MainActivity_MembersInjector.create((MembersInjector) MembersInjectors.noOp(), provideCokeWithSugerProvider);  }  @Override  public void inject(MainActivity activity) {     mainActivityMembersInjector.injectMembers(activity);  }  public static final class Builder {   private CokeModule cokeModule;      private Builder() {      }     public CokeComponent build() {        if (cokeModule == null) {        this.cokeModule = new CokeModule();      }      return new DaggerCokeComponent(this);    }      public Builder cokeModule(CokeModule cokeModule) {        if (cokeModule == null) {        throw new NullPointerException("cokeModule");      }      this.cokeModule = cokeModule;      return this;        }    }}

谜底揭开了，结合我们在MainActivity中注入依赖的方法：
DaggerCokeComponent.builder().cokeModule(new CokeModule()).build().inject(this)
在Builder中，传入创建的CokeModule，可以看到Dagger2贴心地帮我们做了缺省设置，直接调用build()也可以生成CokeModule。然后调用DaggerCokeComponent的构造方法，在initialize中我们终于看到了刚才的两个create方法，也就是通过这座桥梁完成了实例的提供和注入。

后记

1.文中的图摘自CodePath Android Cliffnotes，原文为：Dependency Injection with Dagger 2
2.注意事项：当更新Dagger2的版本时，需重新clean项目，否则会出现actual and former argument lists different in length