上一期稍微探究了一下交叉依赖，这一期来探究一下Dagger里的@Scope标注。
Scope是范围的意思，Dagger里面自带了一个已经可以用的范围标注：@Singleton。
我们知道，Singleton是单例的意思，那么这里的单例标注是何含义？
先看看@Singleton的代码：

/**
 * Identifies a type that the injector only instantiates once. Not inherited.
 *
 * @see javax.inject.Scope @Scope
 */
@Scope
@Documented
@Retention(RUNTIME)
public @interface Singleton {}

注释说，标识一个类型，让注入器只初始化它一次。关于类型，我们不可避免联想到@Provides标注，也是只关注返回类型的。
再看看@Scope标注：

/**
 * Identifies scope annotations. A scope annotation applies to a class
 * containing an injectable constructor and governs how the injector reuses
 * instances of the type. By default, if no scope annotation is present, the
 * injector creates an instance (by injecting the type's constructor), uses
 * the instance for one injection, and then forgets it. If a scope annotation
 * is present, the injector may retain the instance for possible reuse in a
 * later injection. If multiple threads can access a scoped instance, its
 * implementation should be thread safe. The implementation of the scope
 * itself is left up to the injector.
 * 省略中间注释……
 *
 * <p>Annotating scope annotations with {@code @Scope} helps the injector
 * detect the case where a programmer used the scope annotation on a class but
 * forgot to configure the scope in the injector. A conservative injector
 * would generate an error rather than not apply a scope.
 *
 * @see javax.inject.Singleton @Singleton
 */
@Target(ANNOTATION_TYPE)
@Retention(RUNTIME)
@Documented
public @interface Scope {}

这次注释还比较有用，或者说是能看懂的。大意就是，如果没有@Scope标注，注入器每次都会产生新的实例来注入，反之就会保存然后复用。另外还提到了线程安全，不过这些都是Dagger包揽的。
到目前为止，可能你还有不少疑问，不过先来实验一下，或许疑问就迎刃而解了。

主体代码

现在新建一个MyApp继承Application，并在Manifest文件里面声明：

public class MyApp extends Application {

  @Override
  public void onCreate() {
    super.onCreate();
  }
}

  <application
    android:name=".MyApp"
...

好了，现在我们想要做的事情就是，在MyApp与MainActivity里面注入两个ClassB，来观察是否真的是单例模式。当然，这仅仅是实验，讲道理单例一般是不带构造参数的。
另外还有一个比较常见的Dagger的应用方法，就是只创建一次Component然后到处传，好处就是复用，然后实际上@Singleton标注也局限于同一个注入器。一般而言创建的场合就是在Application里面了。
首先将ComponentB添加对MyApp的@Inject标注方法，并添加@Singleton标注：

@Singleton
@Component(modules = ModuleB.class)
public interface ClassBComponent {

  void inject(MainActivity mainActivity);
  void inject(MyApp myApp);
}

为什么Component也要加@Singleton标注呢？这是Dagger的规定，假如@Provides里面有想要加单例标注的，那么其Component也得加，或许与生成代码的机制有关，我们遵循即可，到后面会有更多说明。
然后对ModuleB里面的对应的ClassB的提供函数加上单例标注：

@Module
public class ModuleB {

  private int a;
  private int b;

  public ModuleB(int a, int b) {
    this.a = a;
    this.b = b;
  }

  @Provides
  @Named("a")
  int provideIntA() {
    return a;
  }

  @Provides
  @Named("b")
  int provideIntB() {
    return b;
  }

  @Provides
  ClassA provideClassA(@Named("a") int a, @Named("b") int b) {
    return new ClassA(a, b);
  }

  @Singleton
  @Provides
  ClassB provideClassB(ClassA classA, @Named("a") int a) {
    return new ClassB(classA, a);
  }
}

为方便看出ClassB的构造，在ClassB的构造函数里加一个Log：

public class ClassB {
  private static final String TAG = "ClassB";
  private ClassA classA;
  private int a;

  public ClassB(ClassA classA, int a) {
    this.classA = classA;
    this.a = a;
    Log.d(TAG, "classB constructor called");
  }

  public ClassA getClassA() {
    return classA;
  }

  public int getA() {
    return a;
  }
}

现在对MyApp做一些变更：

public class MyApp extends Application {

  private static MyApp appInstance = null;
  private static ClassBComponent classBComponent = null;

  @Inject ClassB classB;

  @Override
  public void onCreate() {
    super.onCreate();

    appInstance = this;
    classBComponent = DaggerClassBComponent.builder().moduleB(new ModuleB(2, 3)).build();
    classBComponent.inject(this);
  }

  public static MyApp getAppInstance() {
    return appInstance;
  }

  public static ClassBComponent getClassBComponent() {
    return classBComponent;
  }
}

然后再是MainActivity：

public class MainActivity extends AppCompatActivity {
  @Inject ClassB classB;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    MyApp.getClassBComponent().inject(this);
  }
}

运行发现构造函数确实只被调用了一次。假如把两个@Singleton去掉可以发现调用了两次，有兴趣的可以自己试一试。
仔细想想，也许没那么神奇？毕竟是对同一个Component而言，既然刚开始就获得了所有需要的参数，生成一些单例代码也不那么奇怪。

生成代码

生成代码变化不如想象中那么大。首先四个工厂还是雷打不动，说明单例的实现并没有落在ClassB的工厂类上面；然后多了一个MyApp_MembersInjector原理和MainActivity_MembersInjector类似。
真正实现单例的是DaggerClassBComponent，这也解释了为什么要在其上添加@Singleton标注：

public final class DaggerClassBComponent implements ClassBComponent {
  private Provider<Integer> provideIntAProvider;

  private Provider<Integer> provideIntBProvider;

  private Provider<ClassA> provideClassAProvider;

  private Provider<ClassB> provideClassBProvider;

  private MembersInjector<MainActivity> mainActivityMembersInjector;

  private MembersInjector<MyApp> myAppMembersInjector;

  private DaggerClassBComponent(Builder builder) {
    assert builder != null;
    initialize(builder);
  }

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

  @SuppressWarnings("unchecked")
  private void initialize(final Builder builder) {

    this.provideIntAProvider = ModuleB_ProvideIntAFactory.create(builder.moduleB);

    this.provideIntBProvider = ModuleB_ProvideIntBFactory.create(builder.moduleB);

    this.provideClassAProvider =
        ModuleB_ProvideClassAFactory.create(
            builder.moduleB, provideIntAProvider, provideIntBProvider);

    this.provideClassBProvider =
        DoubleCheck.provider(
            ModuleB_ProvideClassBFactory.create(
                builder.moduleB, provideClassAProvider, provideIntAProvider));

    this.mainActivityMembersInjector = MainActivity_MembersInjector.create(provideClassBProvider);

    this.myAppMembersInjector = MyApp_MembersInjector.create(provideClassBProvider);
  }

  @Override
  public void inject(MainActivity mainActivity) {
    mainActivityMembersInjector.injectMembers(mainActivity);
  }

  @Override
  public void inject(MyApp myApp) {
    myAppMembersInjector.injectMembers(myApp);
  }

  public static final class Builder {
    private ModuleB moduleB;

    private Builder() {}

    public ClassBComponent build() {
      if (moduleB == null) {
        throw new IllegalStateException(ModuleB.class.getCanonicalName() + " must be set");
      }
      return new DaggerClassBComponent(this);
    }

    public Builder moduleB(ModuleB moduleB) {
      this.moduleB = Preconditions.checkNotNull(moduleB);
      return this;
    }
  }
}

核心代码是这里：

 this.provideClassBProvider =
        DoubleCheck.provider(
            ModuleB_ProvideClassBFactory.create(
                builder.moduleB, provideClassAProvider, provideIntAProvider));

那么DoubleCheck又是什么呢？

/**
 * A {@link Lazy} and {@link Provider} implementation that memoizes the value returned from a
 * delegate using the double-check idiom described in Item 71 of <i>Effective Java 2</i>.
 */
public final class DoubleCheck<T> implements Provider<T>, Lazy<T> {
  private static final Object UNINITIALIZED = new Object();

  private volatile Provider<T> provider;
  private volatile Object instance = UNINITIALIZED;

  private DoubleCheck(Provider<T> provider) {
    assert provider != null;
    this.provider = provider;
  }

  @SuppressWarnings("unchecked") // cast only happens when result comes from the provider
  @Override
  public T get() {
    Object result = instance;
    if (result == UNINITIALIZED) {
      synchronized (this) {
        result = instance;
        if (result == UNINITIALIZED) {
          result = provider.get();
          /* Get the current instance and test to see if the call to provider.get() has resulted
           * in a recursive call.  If it returns the same instance, we'll allow it, but if the
           * instances differ, throw. */
          Object currentInstance = instance;
          if (currentInstance != UNINITIALIZED && currentInstance != result) {
            throw new IllegalStateException("Scoped provider was invoked recursively returning "
                + "different results: " + currentInstance + " & " + result + ". This is likely "
                + "due to a circular dependency.");
          }
          instance = result;
          /* Null out the reference to the provider. We are never going to need it again, so we
           * can make it eligible for GC. */
          provider = null;
        }
      }
    }
    return (T) result;
  }

  /** Returns a {@link Provider} that caches the value from the given delegate provider. */
  public static <T> Provider<T> provider(Provider<T> delegate) {
    checkNotNull(delegate);
    if (delegate instanceof DoubleCheck) {
      /* This should be a rare case, but if we have a scoped @Binds that delegates to a scoped
       * binding, we shouldn't cache the value again. */
      return delegate;
    }
    return new DoubleCheck<T>(delegate);
  }

  /** Returns a {@link Lazy} that caches the value from the given provider. */
  public static <T> Lazy<T> lazy(Provider<T> provider) {
    if (provider instanceof Lazy) {
      @SuppressWarnings("unchecked")
      final Lazy<T> lazy = (Lazy<T>) provider;
      // Avoids memoizing a value that is already memoized.
      // NOTE: There is a pathological case where Provider<P> may implement Lazy<L>, but P and L
      // are different types using covariant return on get(). Right now this is used with
      // DoubleCheck<T> exclusively, which is implemented such that P and L are always
      // the same, so it will be fine for that case.
      return lazy;
    }
    return new DoubleCheck<T>(checkNotNull(provider));
  }
}

其原理来自于Double Check的单例模式，这里就是把传入的工厂再包一层单例，至于细节有兴趣的可以自行研究。

看Dagger的实现好像也不是那么难不是吗？其实Dagger还支持自定义@Scope，只需要仿照@Singleton的样子改个名字就行了，但其实Dagger会把它当做@Singleton来对待，或者说Dagger其实压根只认识@Scope。
你可能会觉得很疑惑。不过想一想，随便加一个@PerActivity之类的就让Dagger掌控Activity的生命周期，然后做出相应调整，那是童话故事。事实就是，Dagger只认@Scope，只当做单例处理，这也是为什么Dagger只带了这么一个标注，而且改名叫这个。
那么是不是自定义@Scope就没有意义了呢？也不尽然。好的名字能直接起到注释的作用，比如@PerActivity就时刻提醒作者和读者这个Component生命周期应该局限在Activity之内。也就是说，其实最后真正要实现PerActivity的还是使用的人。
学习了@Scope，下一期我们将探究Component dependency与Subcomponent。