libreria - java swing netbeans

Método de inyección utilizando Daga 2.

Question

No he logrado encontrar una buena explicación / ejemplo sobre la inyección de métodos con Dagger 2. ¿Podría alguien ayudarme a entender?

Ejemplo:

@Inject
public Dinner makeDinner(Pasta pasta, Sauce sauce) {
    mPan.add(pasta);
    mPan.add(sauce);
    return mPan.cookDinner();
}

Entonces, si hago anotaciones en mi método con @Inject , ¿tengo razón al suponer que los argumentos en la firma del método se inyectarán con objetos definidos del gráfico de objetos? ¿Cómo puedo usar este método en mi código entonces? Todavía esperará que proporcione todos los argumentos, cuando haga la llamada al método, que tipo de derrota tiene el propósito.

ACTUALIZAR:

Por lo que entiendo, el objeto Dinner estará disponible si llamo DinnerComponent.dinner() , suponiendo que mi DinnerComponent esté configurado de esta forma:

@Component(modules = DinnerModule.class)
public interface DinnerComponent {
    Dinner dinner();
}

y mi DinnerModule está configurado así:

@Module
public class DinnerModule {
    public DinnerModule() {}

    @Provides
    Pasta providePasta() { return new Pasta(); }

    @Provides
    Sauce provideSauce() { return new Sauce(); }
}

¿Qué pasa si quiero frito mi cena? Así que vamos a introducir este método:

@Inject
public Dinner makeDinner(Pasta pasta, Sauce sauce) {
    mPan.add(pasta);
    mPan.add(sauce);
    return mPan.fryDinner();
}

¿Cómo puedo especificar dentro del componente qué cena es cuál?

Answer 1

La anotación de un método con @Inject da instrucciones a Dagger para ejecutar este método justo después de la creación del objeto, justo después de la llamada del constructor. Esto es útil cuando necesitas un objeto completamente construido para algo. Hay un ejemplo de inyección de método en este artículo .

Tiene razón al decir que los parámetros de este método serán suministrados por Dagger, por eso no debe llamar a este método usted mismo.

Answer 2

Una diferencia fundamental acerca de la inyección de método que difiere de la forma en que parece que la está utilizando es que la inyección de método es solo otra manera para que Dagger envíe dependencias cuando construye o inyecta un objeto listo para DI , lo que significa que los métodos anotados en inyectables @ son destinado a ser llamado por Dagger una vez en construcción y no desde su propio código . Esto hace que sea muy improbable que @Inject Inject @Inject anote makeDinner , fryDinner , o cualquier otro método que tenga efectos secundarios significativos o valores de retorno. En su lugar, trate la inyección de métodos como una oportunidad post-facto para la inyección de estilo constructor.

public class Chef {
  private Provider<Pasta> mPastaProvider;
  private Sauce mSauce;

  @Inject
  public void registerIngredients(     // can be named anything
      Provider<Pasta> pastaProvider,
      Sauce sauce) {                   // T and Provider<T> both work, of course
    mPastaProvider = pastaProvider;
    mSauce = sauce;
  }

  /* Non-@Inject */ public Dinner cookDinner() {
    mPan.add(mPastaProvider.get());
    mPan.add(mSauce);
    return mPan.cookDinner();
  }

  /* Non-@Inject */ public Dinner fryDinner() {
    mPan.add(mPastaProvider.get());
    mPan.add(mSauce);
    return mPan.fryDinner();
  }
}

En este caso, cuando solicite una inyección en un Chef, Dagger verá el método @ Inject-annotated y lo llamará. A menos que tenga un constructor anotado en Injectación @ o un método @Provides, no podrá obtener un Chef directamente desde su Componente, pero podría crear un método void en el Componente que recibe una instancia de Chef construida y que usa el campo y Método de inyección para proporcionar al Chef los ingredientes (o proveedores de ingredientes) que puedan necesitar. (Consulte la documentación de @Component y MembersInjector para más detalles).

Tenga en cuenta que en ningún caso aparece la Dinner disponible en el gráfico de objetos. Agregar @Inject a un constructor le dice a Dagger que puede usar ese constructor para hacer que el objeto esté disponible en el gráfico del objeto, pero agregar @Inject a un método o campo simplemente le dice a Dagger que, como parte del proceso de inyección, debe llenar ese campo o llamada Ese método con las dependencias dadas. Si desea que una Cena esté disponible en el gráfico de objetos, deberá @ Inyectar-anotar el constructor de Cena, o poner un método @Provides o @Binds en un Módulo que incorpore al Componente.

¿Por qué usarías esto? Considere un caso en el que los objetos se crean de manera reflexiva (por ejemplo, Actividades, Fragmentos y Vistas en Android, u Objetos serializables), donde preferiría no exponer los campos @Inject. En esos casos, podría evitar las restricciones del constructor haciendo que su inyección se realice en un campo. De manera similar, aunque no he intentado esto, puede aprovechar la jerarquía de clases para marcar un método de interfaz con @Inject, asegurándose de que esté en un contexto DI o no, puede pasar ciertas dependencias a un objeto como parte de su preparación.