Dagger2：用组件本身注入模块提供的实现类

考虑到模块都是通过 Dagger1 规范相互共享的complete=false, library=true，您可以收到由@Provides通过构造函数参数的方法，就像这样。

public class GetUserForUsernameTaskImpl
        implements GetUserForUsernameTask {
    public static final String TAG = GetUserForUsernameTaskImpl.class.getSimpleName();

    private Realm realm;
    private UserRepository userRepository;

    public GetUserForUsernameTaskImpl(Realm realm, UserRepository userRepository) {
        this.realm = realm;
        this.userRepository = userRepository;
    }

    @Override
    public RealmResults<UserRLM> getUsers() {
        try {
            RealmResults<UserRLM> users = userRepository.findAll(realm);
    ...
}

@Module(includes = {RepositoryModule.class, RealmModule.class})
public class DatabaseTaskModule {
    @Provides
    public GetUsersDatabaseTask getUsersDatabaseTask(Realm realm, UserRepository userRepository) {
        return new GetUsersDatabaseTaskImpl(realm, userRepository);
    }
}

但是，您也可以仅指定一个依赖项（Presenter or the CustomApplication实例）保存组件图，并使用该组件图来注入您的实现类。

public class GetUserForUsernameTaskImpl
        implements GetUserForUsernameTask {
    public static final String TAG = GetUserForUsernameTaskImpl.class.getSimpleName();

    @Inject
    public Realm realm;
    @Inject
    public UserRepository userRepository;

    protected Presenter presenter;
    private boolean isInjected = false;

    public GetUserForUsernameTaskImpl(Presenter presenter) {
        this.presenter = presenter;
    }

    @Override
    public RealmResults<UserRLM> getUsers() {
        if(!isInjected) {
            presenter.getPresenterComponent().inject(this);
            isInjected = true;
        }
        try {
            RealmResults<UserRLM> users = userRepository.findAll(realm);
            ...
    }
}

@Module(includes = {PresenterModule.class})
public class DatabaseTaskModule {
    @Provides
    public GetUsersDatabaseTask getUsersDatabaseTask(Presenter presenter) {
        return new GetUsersDatabaseTaskImpl(presenter);
    }
}

这样，您只需依赖演示者的对象图，而不必弄乱构造函数参数。

哪一种是更好的方法？

EDIT:我在一个不太好的重构项目中得到的一个更清晰具体的例子如下：

@Module(includes = {ContextModule.class})
public class ClientAuthModule {
    @Provides
    public ClientAuthAuthenticator clientAuthAuthenticator(CustomApplication customApplication) {
        return new ClientAuthAuthenticator(customApplication);
    }
}

Then

public class CustomApplication
        extends Application {
    public static class InjectorInitializedEvent {
    }

    public static class InjectorInitializedEventProducer {
        @Produce
        public InjectorInitializedEvent produceEvent() {
            return new InjectorInitializedEvent();
        }
    }

    private ApplicationComponent applicationComponent;

    @Override
    public void onCreate() {
        super.onCreate();
        applicationComponent = Injector.INSTANCE.initializeApplicationComponent();
        SingletonBus.INSTANCE.getBus().post(new InjectorInitializedEvent());
        SingletonBus.INSTANCE.getBus().register(new InjectorInitializedEventProducer()); //OTTO bus, event producer
    }

    public ApplicationComponent getApplicationComponent() {
        return this.applicationComponent;
    }
}

Then

public class ClientAuthAuthenticator {
    private CustomApplication customApplication;

    @Inject
    public PEMConverter pemConverter;
    @Inject
    public KeyPairCreator keyPairCreator;
    @Inject
    public PKCS10CsrCreator pkcs10CsrCreator;
    @Inject
    public KeyPairReader keyPairReader;
    //...

    public ClientAuthAuthenticator(CustomApplication customApplication) {
        this.customApplication = customApplication;
        SingletonBus.INSTANCE.getBus().register(this);
    }

    @Subscribe
    public void onInjectorInitializedEvent(CustomApplication.InjectorInitializedEvent e) {
        customApplication.getApplicationComponent().inject(this);
        SingletonBus.INSTANCE.getBus().unregister(this);
    }

    ...

问题：这样，当注入器准备好时，所有依赖项都由应用程序的组件提供，而不是通过构造函数。但这是一个好方法吗？从长远来看有什么注意事项吗？

EDIT2:我这里有注射器，但效果很糟糕。

我拥有的那个在我的另一个项目中构造得更好 https://stackoverflow.com/questions/31834056/how-do-you-organise-your-dagger-2-modules-and-components/31835913#31835913.

使用构造函数注入方法，您只需使用标准 JSR-330 注释来注释您的类，因此：

• 该代码与您正在使用的具体依赖注入库分离。如果您需要回到旧版本的 dagger，则只需更改模块和组件定义，而不需要更改核心类。

• 您的类不需要了解它们如何生成的详细信息。明天您可能会根据范围拥有不同的组件，或者您可能希望将组件从演示者类中取出。你的核心类不应该因此而改变。

• 它使测试您的模块变得更加容易。无需通过应用程序运行代码生成或替换组件实例。只需将您的模拟或测试模块直接注入构造函数中即可完成。

仅当模块的生命周期超出您的控制时才应使用字段和方法注入。 Android 环境中的活动或片段就是这种情况。在该用例之外，这些方法只是问题的根源。