log - tag android studio

Daga 2 inyectando los parámetros del constructor.

Question

Vi el siguiente ejemplo en el sitio web de Dagger 2 :

class Thermosiphon implements Pump {
  private final Heater heater;

  @Inject
  Thermosiphon(Heater heater) {
    this.heater = heater;
  }

  ...
}

y la documentación:

Cuando se solicita una nueva instancia, Dagger obtendrá los valores de los parámetros requeridos e invocará este constructor.

Cuando escribo un módulo para proporcionar un Thermosiphon como

@Module
public class ThermosiphonModule {

    @Provides
    @Singleton
    Thermosiphon provideThermosiphon() {
        return new Thermosiphon(???);
    }

}

el constructor Thermosiphon todavía requiere un Heater como argumento, lo que hace que toda la ''inyección automática de dependencias del constructor'' sea inútil.

Lo intenté

return new Thermosiphon(null); 

y

return new Thermosiphon(); 

(constructor vacío) y esperaba que Dagger2 detectara que quería que se inyectara el Heater faltante, sin embargo, el Calentador del Thermosiphon provisto siempre es nulo;

HeaterComponent aunque mi HeaterComponent / HeaterModule funciona bien y puede proporcionar un Heater .

¿Completamente malentiendo la característica completa de ''Dagger satisface las dependencias de los constructores para usted'' o me estoy perdiendo algo?

Answer 1

Por un lado, ya que ha anotado el constructor de Thermosiphon con @Inject , no necesita un método @Provides . Dagger utiliza este constructor para crear una instancia cuando sea necesario. Simplemente anote la clase de Thermosiphon con @Singleton para preservar el comportamiento de singleton.

Si desea usar un método @Provides , y para responder a su pregunta por completo, puede especificar el Heater como un parámetro para el método:

@Module
public class ThermosiphonModule {

    @Provides
    @Singleton
    Thermosiphon provideThermosiphon(Heater heater) {
        return new Thermosiphon(heater);
    }

}

Answer 2

Si está utilizando módulos, entonces si tiene dos módulos de proveedor vinculados al mismo componente, podrá permitirles ver el calentador como un parámetro de constructor.

@Module
public class HeaterModule {
    @Provides
    @Singleton
    Heater heater() {
        return new Heater(); // if not using @Inject constructor
    }
}

@Module
public class ThermosiphonModule {
    @Provides
    @Singleton
    Thermosiphon thermosiphon(Heater heater) {
        return new Thermosiphon(heater); // if not using @Inject constructor
    }
}

@Singleton
@Component(modules={ThermosiphonModule.class, HeaterModule.class})
public interface SingletonComponent {
    Thermosiphon thermosiphon();
    Heater heater();

    void inject(Something something);
}

public class CustomApplication extends Application {
    private SingletonComponent singletonComponent;

    @Override
    public void onCreate() {
        super.onCreate();
        this.singletonComponent = DaggerSingletonComponent.builder().build(); //.create();
    }

    public SingletonComponent getSingletonComponent() {
        return singletonComponent;
    }
}

Pero con la inyección del constructor, también podrá proporcionar objetos de ese ámbito dado u objetos sin ámbito, siempre que tengan un constructor @Inject .

Por ejemplo,

@Singleton
@Component // no modules
public interface SingletonComponent {
    Thermosiphon thermosiphon();
    Heater heater();

    void inject(Something something);
}

Y

@Singleton
public class Heater {
    @Inject
    public Heater() {
    }
}

Y

@Singleton
public class Thermosiphon {
    private Heater heater;

    @Inject
    public Thermosiphon(Heater heater) {
        this.heater = heater;
    }
}

O

@Singleton
public class Thermosiphon {
    @Inject
    Heater heater;

    @Inject
    public Thermosiphon() {
    }
}