Dagger2 源码分析【3】

@Scope

When a binding uses a scope annotation, that means that the component object holds a reference to the bound object until the component object itself is garbage-collected.

当 Component 与 Module、目标类（需要被注入依赖）使用 Scope 注解绑定时，意味着 Component 对象持有绑定的依赖实例的一个引用直到 Component 对象本身被回收。
也就是作用域的原理，其实是让生成的依赖实例的生命周期与 Component 绑定，Scope 注解并不能保证生命周期，要想保证赖实例的生命周期，需要确保 Component 的生命周期。

Scope 是用来确定注入的实例的生命周期的，如果没有使用 Scope 注解，Component 每次调用 Module 中的 provide 方法或 Inject 构造函数生成的工厂时都会创建一个新的实例，而使用 Scope 后可以复用之前的依赖实例。

Scope 注解只能标注目标类、@provide 方法和 Component。
Scope 注解要生效的话，需要同时标注在 Component 和提供依赖实例的 Module 或目标类上。
Module 中 provide 方法中的 Scope 注解必须和 与之绑定的 Component 的 Scope 注解一样，否则作用域不同会导致编译时会报错。

@Singleton

@Singleton顾名思义保证单例，那么它又是如何实现的呢，实现了单例模式那样只返回一个实例吗？
我们先看看怎么使用：

@Singleton
public class Engine {
    @Inject
    public Engine() {}
}

public class Car {
    public Engine mEngine;
    public Car(Engine engine) {
        this.mEngine = engine;
    }

    public Engine getEngine() {
        return mEngine;
    }
}

@Module
public class CarModule {
    @Provides
    @Singleton
    Car carProvide(Engine engine) {
        return new Car(engine);
    }
}

@Component(modules = CarModule.class)
@Singleton
public interface ManComponent {
    void inject(ManActivity mainActivity);
}

public class ManActivity extends AppCompatActivity {

    @Inject
    Car mCar;

    @Inject
    Car mCar2;

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

        DaggerManComponent.create().inject(this);
        Log.d("Car", mCar.toString());
        Log.d("Car", mCar2.toString());
    }
}

最后我们观察日志：

07-11 11:20:47.788 31539-31539/com.whyalwaysmea.dagger2 D/Car: com.whyalwaysmea.dagger2.bean.Car@eda5747
07-11 11:20:47.789 31539-31539/com.whyalwaysmea.dagger2 D/Car: com.whyalwaysmea.dagger2.bean.Car@eda5747

可以发现这两个变量其实是同一个。
对比生成的代码，最大的不一样是DaggerManComponent，其他几个类都几乎没有什么变化。

public final class DaggerManComponent implements ManComponent {
  ...

  @SuppressWarnings("unchecked")
  private void initialize(final Builder builder) {
    //
    this.engineProvider = DoubleCheck.provider(Engine_Factory.create());

    this.carProvideProvider =
        DoubleCheck.provider(CarModule_CarProvideFactory.create(builder.carModule, engineProvider));

    this.manActivityMembersInjector = ManActivity_MembersInjector.create(carProvideProvider);
  }

  ...
}

可以看到这里最大的不同就是多了一个DoubleCheck.provider

public final class DoubleCheck implements Provider, Lazy {
  private static final Object UNINITIALIZED = new Object();
  private volatile Provider provider;
  private volatile Object instance = UNINITIALIZED; // instance 就是依赖实例的引用
  ...
  @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;
  }
  ...
}

可以看到DoubleCheck实现了Factory和Lazy，主要的逻辑还是在get()方法中。
内部方法中有点像Double CheckLock实现单例的方法，只是每次都会有一个新的局部变量，而真正的单例方法是使用的static。

由于DoubleCheck是在DaggerXXXComponent中调用的，然而DaggerXXXComponent又是我们通过它的Builder方法来获取的。
所以 Singleton 作用域可以保证一个 Component 中的单例，但是如果产生多个 Component 实例，那么实例的单例就无法保证了。