Dagger2 的初步了解和使用

Dagger2？

Dagger 是 Java 平台的依赖注入库。在 J2EE 开发上流行甚广的 Spring 就是一个依赖注入库。此外还有 Google 的 Guice 和 Square 的 Dagger1。但它们都是是通过在运行时读取注解来实现依赖注入的，依赖的生成和注入需要依靠 Java 的反射机制，这对于对性能非常敏感的 Android 来说是一个硬伤。

Dagger 同样使用注解来实现依赖注入，但它利用 APT(Annotation Process Tool) 在编译时生成辅助类，这些类继承特定父类或实现特定接口，程序在运行时 Dagger 加载这些辅助类，调用相应接口完成依赖生成和注入。Dagger 对于程序的性能影响非常小，因此更加适用于 Android 应用的开发。

开始之前

在了解 Dagger2 之前，请务必先通晓两个概念：

1. 依赖注入（Dependency Injection : DI）：面向对象编程的一种模式，最大的作用是解耦。

2. Java 注解（Annotation）：了解到哪些是 Java 原生支持的注解。

Dagger2 带给我们的注解

下文尝试尽量抛开特定的场景（比如 MVP 模式），以更具有普适性的代码，从骨架开始，慢慢去丰满血肉，更全面的去理解这里这些注解的使用。

@Inject

假设 MainActivity 依赖一个 Tester 的类，代码应该如下：

public class Tester {
    @Inject
    public Tester() {
    }
}

public class MainActivity extends Activity {
    @Inject 
    Tester tester;
}

@Inject 有两个作用：

1. 标记 Tester 的构造方法，通知 Dagger2 在需要该类实例时可以通过该构造函数 new 出相关实例从而提供依赖。提供依赖的方式还有 @Provide ，下面细说。

2. 标记 MainActivity 的 Tester 变量，通知 Dagger2 该变量实例需要由它来提供，也就是上述的需要 Dagger2 去 new 出 Tester 的实例 tester 。

我们另外还需要一个中间件去连接依赖提供方和依赖使用方，这就是 @Component ，详细的内容在下面介绍，先看下这个例子中的 TestComponent：

@Component
public interface TestComponent {
    void inject(CActivity cActivity);
}

在 MainActivity 的 onCreate() 加入：

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    ...
    DaggerTestComponent.builder().build().inject(this);
    ...
}

DaggerTestComponent 是 Dagger2 帮我们生成的类，命名规则就是在我们定义的接口名称前加上Dagger，实现了我们之前定义的 TestComponent 接口。执行完这一行代码，tester 就已经不是 null 了。

@Provides

@Inject 标记构造方法来生成依赖对象的方式有它的局限性，如：

1. 接口（Interface），没有构造方法，自然无处标记。

2. 第三方库提供的类，不适合去直接修改源码，标记构造方法。

对于上述的问题，就需要 @Provide 来提供依赖：

@Module
public class TestModule {
    @Provides
    Tester provideTester() {
        return new Tester();
    }
}

需要注意的是：

1. @Provides 只能用于标记非构造方法，并且该方法必须在 @Moudle 内部。

2. @Provides 修饰的方法的方法名建议以 provide 开头。

@Component(modules = TestModule.class)
public interface TestComponent {
    void inject(CActivity cActivity);
}

这里跟之前使用 @Inject 提供依赖时的 Component 不同，标识了提供依赖的 TestModule。

public class MainActivity extends Activity {
    @Inject 
    Tester tester;
    
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        DaggerTestComponent.builder().testModule(new TestModule()).build().inject(this);
    }
}

DaggerTestComponent 也同样多了 testModule() 方法，参数就是我们自己定义的 TestModule。

@Module

@Module 一般用来标记类，该注解告知 Dagger2 可以到该类中寻找需要的依赖。上述的 @Provides 则标记提供依赖实例的方法。两者都是一起使用的。

@Component

Component一般用来标注接口，如上文所说，作用在于作为依赖提供方和依赖使用方沟通的桥梁。

更重要的一点在于：Component 可以组合不同的 Module 和 Component。

@Component(dependencies = ApplicationComponent.class, modules = ActivityModule.class)
public interface ActivityComponent {}

多个 Module 和 Component 的情况：

@Component(
dependencies = {Component1.class,Component2.class,...}, 
modules = {Module1.class,Module1.class,...})
public interface ActivityComponent {}

敲黑板，划重点：

• Component 和它依赖的其他 Component 的 @Scope 作用域（@Scope下文会详细介绍）不能相同。

• 如果在依赖使用方需要依赖的对象并不是由当前直接的 Component 的 Module 提供的，而是由其所依赖的其他 Component 的 Module 提供的。那么就在被依赖的 Component 中就需要提供一个返回值为这个被依赖的 Compnent 的 Module 提供的依赖对象的方法，方法名可以随意。（贼™绕，血崩！）

举个栗子：

这里有一个 AModule 和 AComponent：

@Module
public class AModule {
    @Provides
    Tester provideTester() {
        return new Tester();
    }
}

@Component(modules = AModule.class)
public interface AComponent {}

还有一个依赖于 AComponent 的 BComponent：

@Component(dependencies = AComponent.class)
public interface BComponent {
    void inject(MainActivity mainActivity);
}

在 MainActivity 中就依赖 Tester 对象：

public class MainActivity extends Activity {
    @Inject 
    Tester tester;
}

这么写的话，编译器就不干了...我们需要在被依赖的 ACompnent 中添加返回值为 Tester 的方法，如下：

@Component(modules = AModule.class)
public interface AComponent {
    Tester getTester();
}

栗子举完了，但是这里我仍有个疑惑，为何这里这么不智能？需要显示去提供依赖？明明 @Subcomponent （下文详述）就可以很智能的去父 Component 中查找缺失的依赖...

@Subcomponent

@Subcomponent 其功能效果类似 component 的 dependencies。但是使用 @Subcomponent 不需要在父 component 中显式添加子 component 需要用到的对象，只需要添加返回子 Component 的方法即可，子 Component 能自动在父 Component 中查找缺失的依赖。

// 父Component
@PerApp
@Component(modules = AppModule.class)
public AppComponent{
    ActivityComponent getActivityComponent();  // 1.只需要在父Component添加返回子Component的方法即可
}

// 子Component
@PerAcitivity   // 2.注意子 Component 的 Scope 范围小于父 Component 
@Subcomponent(modules = ActivityModule.class)   // 3.使用 @Subcomponent 注解
public ActivityComponent{
    void inject(MainActivity activity); 
}

public class App extends Application {

    AppComponent mAppComponent;
    
    @Inject
    ToastUtil toastUtil;
    
    @Override
    public void onCreate() {
        super.onCreate();

        mAppComponent = DaggerAppComponent.builder().appModule(new AppModule(this)).build();
    }

    public AppComponent getAppComponent(){
        return mAppComponent;
    }
}

public class SomeActivity extends Activity{
    public void onCreate(Bundle savedInstanceState){
        ...
        App.getAppComponent().getActivityComponent().inject(this);//4.调用getActivityComponent方法创建出子Component
    }    
}

@Subcomponent 和 Component 在使用最大的差异就在于：
当我们使用的 @Subcomponent，父 Component 可以完全不暴露自己，而只把子 Component 传递给其使用者。

@Qualifier

这段内容引自：Dagger 源码解析

如果有两类程序员，他们的能力值 power 分别是 5 和 1000，应该怎样让 Dagger 对他们做出区分呢？使用 @Qualifier 注解即可。

(1). 创建一个 @Qualifier 注解，用于区分两类程序员：

@Qualifier
@Documented
@Retention(RUNTIME)
public @interface Level {
  String value() default "";
}

(2). 为这两类程序员分别设置 @Provides 函数，并使用 @Qualifier 注解对他们做出不同的标记：

@Provides @Level("low") Coder provideLowLevelCoder() {
    Coder coder = new Coder();
    coder.setName("战五渣");
    coder.setPower(5);
    return coder;
}

@Provides @Level("high") Coder provideHighLevelCoder() {
    Coder coder = new Coder();
    coder.setName("大神");
    coder.setPower(1000);
    return coder;
}

(3). 在声明 @Inject 对象的时候，加上对应的 @Qualifier 注解：

@Inject @Level("low") Coder lowLevelCoder;
@Inject @Level("high") Coder highLevelCoder;

此外，还有一个默认实现的注解 @Named，使用方法同上，源码如下：

@Qualifier
@Documented
@Retention(RUNTIME)
public @interface Named {

    /** The name. */
    String value() default "";
}

@Scope

Dagger2 可以通过 @Scope 自定义注解限定注解作用域。
我们直接看 Dagger2 自带的，通过 @Scope 实现的 @Singleton 注解，源码如下：

@Scope
@Documented
@Retention(RUNTIME)
public @interface Singleton{}

用法如下：

@Singleton // @Inject 提供对象的单例模式
public class Tester {
    @Inject
    public Tester() {}
}

@Provides
@Singleton // @Provides 提供对象的单例模式
Tester provideTester() {
    return new Tester();
}

@Singleton // 标明该 Component 中有 Module 使用了 @Singleton
@Component(modules = TestModule.class)
public interface ActivityComponent {
    void inject();
}

如果要使用我们自己的注解，比如在 MVP 中非常常见的 @PreActivity，将上面的 @Singleton 替换成 @PreActivity 即可，使用上无区别：

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

如何理解 @Scope

参看：Android：dagger2让你爱不释手-重点概念讲解、融合篇

这里我们使用一个最简单的 @Singleton 注解提供一个 AppComponent。编译后，Dagger2 自动帮我们生成如下代码：

@Generated("dagger.internal.codegen.ComponentProcessor")
public final class DaggerAppComponent implements AppComponent {
  private Provider provideContextProvider;
  private MembersInjector appMembersInjector;

  private DaggerAppComponent(Builder builder) {  
    assert builder != null; // 判断了只有第一次实例化这个Component时才会去执行下面的代码
    initialize(builder);
  }

  public static Builder builder() {  
    return new Builder();
  }

  private void initialize(final Builder builder) {  
    this.provideContextProvider = ScopedProvider.create(AppModule_ProvideContextFactory.create(builder.appModule));
    this.appMembersInjector = App_MembersInjector.create((MembersInjector) MembersInjectors.noOp(), provideToastUtilProvider);
  }

  @Override
  public Context context() {  
    return provideContextProvider.get();
  }

  @Override
  public void inject(App app) {  
    appMembersInjector.injectMembers(app);
  }

  public static final class Builder {
    private AppModule appModule;
  
    private Builder() {  
    }
  
    public AppComponent build() {  
      if (appModule == null) {
        throw new IllegalStateException("appModule must be set");
      }
      return new DaggerAppComponent(this);
    }
  
    public Builder appModule(AppModule appModule) {  
      if (appModule == null) {
        throw new NullPointerException("appModule");
      }
      this.appModule = appModule;
      return this;
    }
  }
}

传递进来的 appModule 首先交由 AppModule_ProvideContextFactory：

@Generated("dagger.internal.codegen.ComponentProcessor")
public final class AppModule_ProvideContextFactory implements Factory {
  private final AppModule module;

  public AppModule_ProvideContextFactory(AppModule module) {  
    assert module != null;
    this.module = module;
  }

  @Override
  public Context get() {  
    Context provided = module.provideContext(); // 这就是我们在 AppModule 中定义的方法，去提供 Context 对象的实例。
    if (provided == null) {
      throw new NullPointerException("Cannot return null from a non-@Nullable @Provides method");
    }
    return provided;
  }

  public static Factory create(AppModule module) {  
    return new AppModule_ProvideContextFactory(module);
  }
}

这个类的功能其实就是维护了 Context 对象，其他类在想使用时就可以从这里拿。
继续看之前，AppModule_ProvideContextFactory 通过工厂模式创建了自己的实例后就把自己传递给了 ScopedProvider：

public final class ScopedProvider implements Provider {
  private static final Object UNINITIALIZED = new Object();

  private final Factory factory;
  private volatile Object instance = UNINITIALIZED;

  private ScopedProvider(Factory factory) {
    assert factory != null;
    this.factory = factory;
  }

  @SuppressWarnings("unchecked") // cast only happens when result comes from the factory
  @Override
  public T get() {
    // double-check idiom from EJ2: Item 71
    Object result = instance;
    if (result == UNINITIALIZED) {
      synchronized (this) {
        result = instance;
        if (result == UNINITIALIZED) {
          instance = result = factory.get();
        }
      }
    }
    return (T) result;
  }

  /** Returns a new scoped provider for the given factory. */
  public static  Provider create(Factory factory) {
    if (factory == null) {
      throw new NullPointerException();
    }
    return new ScopedProvider(factory);
  }
}

对之前的 Context 对象，做一次双重校验锁，目的是为了实现对象的线程安全。
在用到 Context 对象的地方，都是类似于 DaggerAppComponent 中的 provideContextProvider.get() 方法去获取实例。

总结来说，@Scope本身并不控制对象的生命周期，其生命周期其实还是看生成的 Component 对象的生命周期。

后话

其实知晓 Dagger2 注解的使用，大致了解 Dagger2 的原理其实并不是难点或者说重点。
在实际工程中如何灵活去使用它，如何根据业务的需要切分 Module 和 Component 才是我们在之后需要时间不断去打磨。