不使用匕首获得单身者

Question

在我目前的Android应用程序中，我刚刚开始使用Dagger，我不知道如何实现我想要的功能(我相信我想要的功能是可能的)。

基本上，我的处境是这样。我有以下类，我希望它们的实例/注射由Dagger管理。我还希望其中一些是单身汉，这一点在(1)中得到了注意：

• CipherFactory -简单，包装-私人工厂
• CryptoService (1) -依赖于CipherFactory
• SerializationService (1) -依赖于杰克逊的ObjectMapper
• PlayerApplicationService (1) -依赖于SerializationService
• PlayerRepository (1) -依赖于SerializationService，CryptoService

现在，我可以让Dagger创建这些服务，并适当地注入它们的依赖关系；问题是，有些类依赖于多个类，而且每次注入日志语句时，它都会出现在日志语句中。

下面是我目前对上述内容的了解，包括Dagger模块类：

CryptoService.java

@Singleton
public class CryptoService {
    private final CipherFactory cipherFactory;

    @Inject
    CryptoService(CipherFactory cipherFactory) {
        this.cipherFactory = cipherFactory;
    }
    ...
}   

CryptoServiceModule.java

@Module(
        injects = CryptoService.class,
        complete = true,
        library = true
)
public class CryptoServiceModule {

    @Provides
    @Singleton
    CipherFactory provideCipher() {
        return new CipherFactory();
    }

}

SerializationService.java

@Singleton
public class SerializationService {

    private final ObjectMapper objectMapper;

    @Inject
    SerializationService(ObjectMapper objectMapper) {
        this.objectMapper = objectMapper;
    }
    ...
}

SerializationServiceModule.java

@Module(
        injects = SerializationService.class,
        library = true,
        complete = true
)
public class SerializationServiceModule {

    @Provides
    @Singleton
    ObjectMapper provideMapper() {
        return new ObjectMapper();
    }

}

PlayerApplicationService.java

public class PlayerApplicationService {

    private SerializationService serializationService;

    @Inject
    public PlayerApplicationService(SerializationService serializationService) {
        this.serializationService = serializationService;
    }
    ....
}

PlayerApplicationServiceModule.java

@Module(
        injects = PlayerApplicationService.class,
        includes = {
                SerializationServiceModule.class
        },
        complete = true,
        library = true
)
public class PlayerApplicationServiceModule {
}

PlayerRepository.java

@Singleton
public class PlayerRepository implements Repository<Player> {

    private final SerializationService serializationService;
    private final CryptoService cryptoService;

    @Inject
    public PlayerRepository(SerializationService serializationService, CryptoService cryptoService) {
        this.serializationService = serializationService;
        this.cryptoService = cryptoService;
    }
    ...
}

PlayerRepositoryModule.java

@Module(
        injects = PlayerRepository.class,
        includes = {
                SerializationServiceModule.class,
                CryptoServiceModule.class
        },
        complete = true,
        library = true
)
public class PlayerRepositoryModule {
}

我遗漏了什么？正如我前面提到的，所有这些东西都是这样工作的，看起来我只是得到了一些依赖项的多个实例(例如，SerializationService，由两个类使用)，我只需要/只需要一个。

Answer 1

基于@Andyccs的注释，我将所有内容合并到应用程序级别的Module类中，并删除应用程序中的所有其他模块类：

PlayerApplicationModule.java

@Module(
        injects = {
                PlayerApplication.class,
                CryptoService.class,
                SerializationService.class,
                PlayerApplicationService.class
        },
        complete = true,
        library = true
)
public class PlayerApplicationModule {
    private PlayerApplication application;

    public PlayerApplicationModule(PlayerApplication application) {
        this.application = application;
    }

    @Provides
    @Singleton
    public Context provideApplicationContext() {
        return application;
    }

    @Provides
    @Singleton
    public CipherFactory provideCipherFactory() {
        return new CipherFactory();
    }

    @Provides
    @Singleton
    public ObjectMapper provideObjectMapper() {
        return new ObjectMapper();
    }

}

现在一切都如期而至。