我们看下源码，这里的create是创建了一个ScopeProvider的对象，并将工厂传入，当这个ScopeProvider去get的时候，内部有个单例来维持这个对象，这就是为什么我们自定义注解是个单例的秘密。

接下来看看神器的注解是怎么起作用的。

public final class BaseActivity_MembersInjector implements MembersInjector<BaseActivity> {
    private final MembersInjector<FragmentActivity> supertypeInjector;
    private final Provider<Context> contextProvider;

    public BaseActivity_MembersInjector(MembersInjector<FragmentActivity> supertypeInjector, Provider<Context> contextProvider) {
        assert supertypeInjector != null;

        this.supertypeInjector = supertypeInjector;

        assert contextProvider != null;

        this.contextProvider = contextProvider;
    }

    public void injectMembers(BaseActivity instance) {
        if(instance == null) {
            throw new NullPointerException("Cannot inject members into a null reference");
        } else {
            this.supertypeInjector.injectMembers(instance);
            instance.context = (Context)this.contextProvider.get();
        }
    }

    public static MembersInjector<BaseActivity> create(MembersInjector<FragmentActivity> supertypeInjector, Provider<Context> contextProvider) {
        return new BaseActivity_MembersInjector(supertypeInjector, contextProvider);
    }
}

在我们注入这个对象后，injectMembers方法中，写明了BaseActivity中的context对象是从ContextProvider的get方法中得到，根据代码也可以看到，这部分依赖是从ApplicationComponent中的provideContext方法取得。

再看看Lazy Load：

public final class DoubleCheckLazy<T> implements Lazy<T> {
  private static final Object UNINITIALIZED = new Object();

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

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

  @SuppressWarnings("unchecked") // cast only happens when result comes from the factory
  @Override
  public T get() {
    // to suppress it.
    Object result = instance;
    if (result == UNINITIALIZED) {
      synchronized (this) {
        result = instance;
        if (result == UNINITIALIZED) {
          instance = result = provider.get();
        }
      }
    }
    return (T) result;
  }

  public static <T> Lazy<T> create(Provider<T> provider) {
    if (provider == null) {
      throw new NullPointerException();
    }
    return new DoubleCheckLazy<T>(provider);
  }
}

toasterLazy加载的时候是使用DoubleCheckLazy.create(this.toasterLazyProvider)来进行初始化。而内部是个单例，只有在get时才会初始化。

至此，Dagger2的主要源码就差不多理解了。

二.使用分析

Dagger2很优雅，优雅到你可以特别轻松的调试它，以为他和你手写的代码几乎一模一样，又优雅到几乎所有的错误都从编译器暴露出。

与RoboGuice的反射不同，生成代码必然会导致方法数的增加。但是，我们可以看到生成的代码数量并不多，而且在实际应用过程中也可以看出，确实影响不大，这个可以大家在以后的使用中慢慢体会。