3

考虑到模块都是通过 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);
    }
}

但是，您也可以仅指定一个包含组件图的依赖项（thePresenter或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);
    }
}

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

哪个是更好的方法？

编辑：我在一个不太好的重构项目中的一个更清晰和具体的例子如下：

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

然后

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;
    }
}

然后

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：我在这里有注射器，但它很糟糕。

我在另一个项目中拥有的那个更好。

4

2 回答 2

1

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

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

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

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

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

于 2015-06-28T20:28:00.147 回答
-1

如果您的依赖项是通过组件/模块提供的，那么在创建依赖项时组件将始终存在。所以你可以在它的构造函数中调用字段注入。再简单不过了。

于 2015-08-08T17:21:47.323 回答