<h2>Dagger2？</h2>    <p>Dagger 是 Java 平台的依赖注入库。在 J2EE 开发上流行甚广的 Spring 就是一个依赖注入库。此外还有 Google 的 Guice 和 Square 的 Dagger1。但它们都是是通过在运行时读取注解来实现依赖注入的，依赖的生成和注入需要依靠 Java 的反射机制，这对于对性能非常敏感的 Android 来说是一个硬伤。</p>    <p>Dagger 同样使用注解来实现依赖注入，但它利用 APT(Annotation Process Tool) 在编译时生成辅助类，这些类继承特定父类或实现特定接口，程序在运行时 Dagger 加载这些辅助类，调用相应接口完成依赖生成和注入。Dagger 对于程序的性能影响非常小，因此更加适用于 Android 应用的开发。</p>    <h2>开始之前</h2>    <p>在了解 Dagger2 之前，请务必先通晓两个概念：</p>    <ol>     <li> <p>依赖注入（Dependency Injection : DI） ：面向对象编程的一种模式，最大的作用是解耦。</p> </li>     <li> <p>Java 注解（Annotation） ：了解到哪些是 Java 原生支持的注解。</p> </li>    </ol>    <h2>Dagger2 带给我们的注解</h2>    <p>下文尝试尽量抛开特定的场景（比如 MVP 模式），以更具有普适性的代码，从骨架开始，慢慢去丰满血肉，更全面的去理解这里这些注解的使用。</p>    <h3>@Inject</h3>    <p>假设 MainActivity 依赖一个 Tester 的类，代码应该如下：</p>    <pre>  <code class="language-java">public class Tester {      @Inject      public Tester() {      }  }</code></pre>    <pre>  <code class="language-java">public class MainActivity extends Activity {      @Inject       Tester tester;  }</code></pre>    <p>@Inject 有两个作用：</p>    <ol>     <li> <p>标记 Tester 的构造方法，通知 Dagger2 在需要该类实例时可以通过该构造函数 new 出相关实例从而提供依赖。提供依赖的方式还有 @Provide ，下面细说。</p> </li>     <li> <p>标记 MainActivity 的 Tester 变量，通知 Dagger2 该变量实例需要由它来提供，也就是上述的需要 Dagger2 去 new 出 Tester 的实例 tester 。</p> </li>    </ol>    <p>我们另外还需要一个中间件去连接 <strong>依赖提供方</strong> 和 <strong>依赖使用方</strong> ，这就是 @Component ，详细的内容在下面介绍，先看下这个例子中的 TestComponent：</p>    <pre>  <code class="language-java">@Component  public interface TestComponent {      void inject(CActivity cActivity);  }</code></pre>    <p>在 MainActivity 的 onCreate() 加入：</p>    <pre>  <code class="language-java">@Override  protected void onCreate(@Nullable Bundle savedInstanceState) {      super.onCreate(savedInstanceState);      ...      DaggerTestComponent.builder().build().inject(this);      ...  }</code></pre>    <p>DaggerTestComponent 是 Dagger2 帮我们生成的类，命名规则就是在我们定义的接口名称前加上Dagger，实现了我们之前定义的 TestComponent 接口。执行完这一行代码，tester 就已经不是 null 了。</p>    <h3>@Provides</h3>    <p>@Inject 标记构造方法来生成依赖对象的方式有它的局限性，如：</p>    <ol>     <li> <p>接口（Interface），没有构造方法，自然无处标记。</p> </li>     <li> <p>第三方库提供的类，不适合去直接修改源码，标记构造方法。</p> </li>    </ol>    <p>对于上述的问题，就需要 @Provide 来提供依赖：</p>    <pre>  <code class="language-java">@Module  public class TestModule {      @Provides      Tester provideTester() {          return new Tester();      }  }</code></pre>    <p>需要注意的是：</p>    <ol>     <li> <p>@Provides 只能用于标记非构造方法，并且该方法必须在 @Moudle 内部。</p> </li>     <li> <p>@Provides 修饰的方法的方法名建议以 provide 开头。</p> </li>    </ol>    <pre>  <code class="language-java">@Component(modules = TestModule.class)  public interface TestComponent {      void inject(CActivity cActivity);  }</code></pre>    <p>这里跟之前使用 @Inject 提供依赖时的 Component 不同，标识了提供依赖的 TestModule。</p>    <pre>  <code class="language-java">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);      }  }</code></pre>    <p>DaggerTestComponent 也同样多了 testModule() 方法，参数就是我们自己定义的 TestModule。</p>    <h3>@Module</h3>    <p>@Module 一般用来标记类，该注解告知 Dagger2 可以到该类中寻找需要的依赖。上述的 @Provides 则标记提供依赖实例的方法。两者都是一起使用的。</p>    <h3>@Component</h3>    <p>Component一般用来标注接口，如上文所说，作用在于作为 <strong>依赖提供方</strong> 和 <strong>依赖使用方</strong> 沟通的桥梁。</p>    <p>更重要的一点在于：Component 可以组合不同的 Module 和 Component。</p>    <pre>  <code class="language-java">@Component(dependencies = ApplicationComponent.class, modules = ActivityModule.class)  public interface ActivityComponent {}</code></pre>    <p>多个 Module 和 Component 的情况：</p>    <pre>  <code class="language-java">@Component(  dependencies = {Component1.class,Component2.class,...},   modules = {Module1.class,Module1.class,...})  public interface ActivityComponent {}</code></pre>    <p>敲黑板，划重点：</p>    <ul>     <li> <p>Component 和它依赖的其他 Component 的 @Scope 作用域（@Scope下文会详细介绍）不能相同。</p> </li>     <li> <p>如果在依赖使用方需要依赖的对象并不是由当前直接的 Component 的 Module 提供的，而是由其所依赖的其他 Component 的 Module 提供的。那么就在被依赖的 Component 中就需要提供一个返回值为这个被依赖的 Compnent 的 Module 提供的依赖对象的方法，方法名可以随意。（贼™绕，血崩！）</p> </li>    </ul>    <p>举个栗子：</p>    <p>这里有一个 AModule 和 AComponent：</p>    <pre>  <code class="language-java">@Module  public class AModule {      @Provides      Tester provideTester() {          return new Tester();      }  }</code></pre>    <pre>  <code class="language-java">@Component(modules = AModule.class)  public interface AComponent {}</code></pre>    <p>还有一个依赖于 AComponent 的 BComponent：</p>    <pre>  <code class="language-java">@Component(dependencies = AComponent.class)  public interface BComponent {      void inject(MainActivity mainActivity);  }</code></pre>    <p>在 MainActivity 中就依赖 Tester 对象：</p>    <pre>  <code class="language-java">public class MainActivity extends Activity {      @Inject       Tester tester;  }</code></pre>    <p>这么写的话，编译器就不干了...我们需要在被依赖的 ACompnent 中添加返回值为 Tester 的方法，如下：</p>    <pre>  <code class="language-java">@Component(modules = AModule.class)  public interface AComponent {      Tester getTester();  }</code></pre>    <p>栗子举完了，但是这里我仍有个疑惑，为何这里这么不智能？需要显示去提供依赖？明明 @Subcomponent （下文详述）就可以很智能的去父 Component 中查找缺失的依赖...</p>    <h3>@Subcomponent</h3>    <p>@Subcomponent 其功能效果类似 component 的 dependencies。但是使用 @Subcomponent 不需要在父 component 中显式添加子 component 需要用到的对象，只需要添加返回子 Component 的方法即可，子 Component 能自动在父 Component 中查找缺失的依赖。</p>    <pre>  <code class="language-java">// 父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      }      }</code></pre>    <p>@Subcomponent 和 Component 在使用最大的差异就在于：</p>    <p>当我们使用的 @Subcomponent，父 Component 可以完全不暴露自己，而只把子 Component 传递给其使用者。</p>    <h3>@Qualifier</h3>    <p>如果有两类程序员，他们的能力值 power 分别是 5 和 1000，应该怎样让 Dagger 对他们做出区分呢？使用 @Qualifier 注解即可。</p>    <p>(1). 创建一个 @Qualifier 注解，用于区分两类程序员：</p>    <pre>  <code class="language-java">@Qualifier  @Documented  @Retention(RUNTIME)  public @interface Level {    String value() default "";  }</code></pre>    <p>(2). 为这两类程序员分别设置 @Provides 函数，并使用 @Qualifier 注解对他们做出不同的标记：</p>    <pre>  <code class="language-java">@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;  }</code></pre>    <p>(3). 在声明 @Inject 对象的时候，加上对应的 @Qualifier 注解：</p>    <pre>  <code class="language-java">@Inject @Level("low") Coder lowLevelCoder;  @Inject @Level("high") Coder highLevelCoder;</code></pre>    <p>此外，还有一个默认实现的注解 @Named，使用方法同上，源码如下：</p>    <pre>  <code class="language-java">@Qualifier  @Documented  @Retention(RUNTIME)  public @interface Named {        /** The name. */      String value() default "";  }</code></pre>    <h3>@Scope</h3>    <p>Dagger2 可以通过 @Scope 自定义注解限定注解作用域。</p>    <p>我们直接看 Dagger2 自带的，通过 @Scope 实现的 @Singleton 注解，源码如下：</p>    <pre>  <code class="language-java">@Scope  @Documented  @Retention(RUNTIME)  public @interface Singleton{}</code></pre>    <p>用法如下：</p>    <pre>  <code class="language-java">@Singleton // @Inject 提供对象的单例模式  public class Tester {      @Inject      public Tester() {}  }</code></pre>    <pre>  <code class="language-java">@Provides  @Singleton // @Provides 提供对象的单例模式  Tester provideTester() {      return new Tester();  }</code></pre>    <pre>  <code class="language-java">@Singleton // 标明该 Component 中有 Module 使用了 @Singleton  @Component(modules = TestModule.class)  public interface ActivityComponent {      void inject();  }</code></pre>    <p>如果要使用我们自己的注解，比如在 MVP 中非常常见的 @PreActivity，将上面的 @Singleton 替换成 @PreActivity 即可，使用上无区别：</p>    <pre>  <code class="language-java">@Scope  @Documented  @Retention(RetentionPolicy.RUNTIME)  public @interface PreActivity {}</code></pre>    <p>这里我们使用一个最简单的 @Singleton 注解提供一个 AppComponent。编译后，Dagger2 自动帮我们生成如下代码：</p>    <pre>  <code class="language-java">@Generated("dagger.internal.codegen.ComponentProcessor")  public final class DaggerAppComponent implements AppComponent {    private Provider<Context> provideContextProvider;    private MembersInjector<App> 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;      }    }  }</code></pre>    <p>传递进来的 appModule 首先交由 AppModule_ProvideContextFactory：</p>    <pre>  <code class="language-java">@Generated("dagger.internal.codegen.ComponentProcessor")  public final class AppModule_ProvideContextFactory implements Factory<Context> {    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<Context> create(AppModule module) {        return new AppModule_ProvideContextFactory(module);    }  }</code></pre>    <p>这个类的功能其实就是维护了 Context 对象，其他类在想使用时就可以从这里拿。</p>    <p>继续看之前，AppModule_ProvideContextFactory 通过工厂模式创建了自己的实例后就把自己传递给了 ScopedProvider：</p>    <pre>  <code class="language-java">public final class ScopedProvider<T> implements Provider<T> {    private static final Object UNINITIALIZED = new Object();      private final Factory<T> factory;    private volatile Object instance = UNINITIALIZED;      private ScopedProvider(Factory<T> 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 <T> Provider<T> create(Factory<T> factory) {      if (factory == null) {        throw new NullPointerException();      }      return new ScopedProvider<T>(factory);    }  }</code></pre>    <p>对之前的 Context 对象，做一次双重校验锁，目的是为了实现对象的线程安全。</p>    <p>在用到 Context 对象的地方，都是类似于 DaggerAppComponent 中的 provideContextProvider.get() 方法去获取实例。</p>    <p>总结来说，@Scope本身并不控制对象的生命周期，其生命周期其实还是看生成的 Component 对象的生命周期。</p>    <h2>后话</h2>    <p>其实知晓 Dagger2 注解的使用，大致了解 Dagger2 的原理其实并不是难点或者说重点。</p>    <p>在实际工程中如何灵活去使用它，如何根据业务的需要切分 Module 和 Component 才是我们在之后需要时间不断去打磨。</p>    <p> </p>    <p>来自：https://segmentfault.com/a/1190000008677663</p>    <p> </p>