es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

¿Cómo pasar un parámetro a un módulo compartido de Dagger?

02 Aug, 2023 Programación

Estoy tratando de hacer que varios módulos de dagas compartan un único módulo común, donde el módulo común necesita acceder a una cadena diferente según el módulo que lo incluya.

Tenga en cuenta que, aunque en el ejemplo de código a continuación estoy pasando una sola cadena (por simplicidad), en realidad quiero pasar varias cadenas.

// El módulo compartido
@Module()
public final class SharedModule {
  @Provides @Singleton
  public static SomeClass(String moduleSpecificString) {
    return new SomeClass(moduleSpecificString);
  }
}

// Dos módulos intentando usar el módulo compartido, pero donde cada
// módulo necesita que el módulo compartido utilice un parámetro ligeramente diferente
@Module(includes = {SharedModule.class))
public final class ModuleA {
  @Provides @Singleton
  public static String moduleTextA() {
    return "ModuleA";
  }
}

@Module(includes = {SharedModule.class))
public final class ModuleB {
  @Provides @Singleton
  public static String moduleTextA() {
    return "ModuleB";
  }
}

Las dos posibles soluciones que he encontrado hasta ahora son:

  1. Usar @BindsInstance para especificar las cadenas en el constructor de componentes en su lugar.

Pero eso tiene la desventaja de sacar estas cadenas codificadas del módulo (lo que significa que cada prueba que intente construir solo el módulo ahora también debe declarar esas cadenas).

  1. Usar @IntoMap en ModuleA y ModuleB para insertar la cadena en un mapa.

Esto me permite usar el mismo mapa para pasar varias cadenas, pero parece que pierdo las verificaciones en tiempo de compilación de Dagger para asegurarme de que cada clave en el mapa de la que me preocupo tenga un valor definido.

¿Existen mejores opciones disponibles?

Tags:  ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Una posible solución es crear componentes separados para ModuleA y ModuleB, y utilizar la función de dependencia @Component para incluir el Componente Compartido. De esta manera, cada componente puede tener su propio módulo que proporcione la cadena específica, y el Componente Compartido puede depender de esos módulos.

    Por ejemplo:

    @Component(modules = SharedModule.class)
@Singleton
public interface SharedComponent {
  SomeClass getSomeClass();
}

@Component(dependencies = SharedComponent.class, modules = ModuleA.class)
@Singleton
public interface ComponentA {
  // Define el(los) método(s) para exponer las dependencias proporcionadas por este componente
}

@Component(dependencies = SharedComponent.class, modules = ModuleB.class)
@Singleton
public interface ComponentB {
  // Define el(los) método(s) para exponer las dependencias proporcionadas por este componente
}

    En ModuleA y ModuleB, proporciona la cadena específica como un método proveedor separado:

    @Module
public final class ModuleA {
  @Provides @Singleton
  public static String provideModuleTextA() {
    return "ModuleA";
  }
}

@Module
public final class ModuleB {
  @Provides @Singleton
  public static String provideModuleTextB() {
    return "ModuleB";
  }
}

    Luego, en la clase que utiliza estos componentes, crea instancias de ambos componentes y obtén la dependencia compartida de cada uno:

    // Crea instancias de ambos componentes
SharedComponent sharedComponent = DaggerSharedComponent.create();
ComponentA componentA = DaggerComponentA.builder()
    .sharedComponent(sharedComponent)
    .build();
ComponentB componentB = DaggerComponentB.builder()
    .sharedComponent(sharedComponent)
    .build();

// Obtiene la dependencia compartida de cada componente
SomeClass someClassA = componentA.getSomeClass();
SomeClass someClassB = componentB.getSomeClass();

    Este enfoque permite que cada módulo proporcione su propia cadena específica, al mismo tiempo que comparte el módulo común. También permite realizar comprobaciones en tiempo de compilación para asegurar que todas las dependencias necesarias estén definidas en el módulo de cada componente.

Comments are closed.