Guice: czy możliwe jest wstrzykiwanie modułów?

Używanie metod provider lub @ Provides jest świetne, jeśli potrzebujesz zależności do ręcznego konstruowania obiektu. Co jednak zrobić, jeśli potrzebujesz czegoś, co pomoże Ci zdecydować, jak skonfigurować same wiązania? Okazuje się, że możesz użyć Guice do stworzenia (i skonfigurowania) swojego modułu.

Oto (wymyślony) przykład. Po pierwsze, moduł, który chcemy skonfigurować:

/**
 * Creates a binding for a Set<String> which represents the food in a pantry.
 */
public class PantryModule extends AbstractModule {
  private final boolean addCheese;

  @Inject
  public ConditionalModule(@Named("addCheese") boolean addCheese) {
    this.addCheese = addCheese;
  }

  @Override
  protected void configure() {
    Multibinder<String> pantryBinder = Multibinder
      .newSetBinder(binder(), String.class);

    pantryBinder.addBinding().toInstance("milk");

    if (addCheese) {
      pantryBinder.addBinding().toInstance("cheese");
    }

    pantryBinder.addBinding().toInstance("bread");
  }
}

PantryModule oczekuje, że zostanie wprowadzona wartość logiczna, aby zdecydować, czy powinien zawierać ser w spiżarnia.

Następnie użyjemy Guice do konfiguracji modułu:

// Here we use an anonymous class as the "configuring" module. In real life, you would 
// probably use a standalone module.
Injector injector = Guice.createInjector(new AbstractModule() {
  @Override
  protected void configure() {
    // No cheese please!
    bindConstant().annotatedWith(Names.named("addCheese")).to(false);
    bind(PantryModule.class);
  }
});

Module configuredConditionalModule = injector.getInstance(PantryModule.class);

//...continued from last snippet...
injector = injector.createChildInjector(configuredConditionalModule);

I na koniec otrzymamy zestaw sznurków, które reprezentują naszą spiżarnię:

//...continued from last snippet...
Set<String> pantry = injector.getInstance(new Key<Set<String>>() {});

for (String food : pantry) {
  System.out.println(food);
}

Jeśli połączysz wszystkie elementy w główną metodę i uruchomisz ją, otrzymasz następujące wyjście:

milk
bread

Jeśli zmienisz Wiązanie na wartość logiczną "addCheese" na true, otrzymasz:

milk
cheese
bread

Ta technika jest fajna, ale prawdopodobnie przydatne tylko wtedy, gdy masz kontrolę nad instancją wtryskiwacza i tylko wtedy, gdy moduł wymaga złożonych zależności. Nie wiem, znalazłem prawdziwą potrzebę tego na prawdziwym projekcie w pracy. Jeśli tak, to ktoś inny też.

Pytanie jest już dobrze odpowiedział, Ale chciałem tylko dodać odmianę do przykładu Colina:

class MyModule extends AbstractModule { 
  public void configure() {
    bind(Something.class).toProvider(new Provider<Something>() {
       @Inject Dependency d;
       Something get() { return d.buildSomething(); }
    }
  }
}

Podejście metody @ Zapewnia jest jaśniejsze niż to, co mam powyżej w tym prostym przypadku, ale odkryłem, że tworzenie instancji rzeczywistego dostawcy może być przydatne również w niektórych sytuacjach. Coś, co ukradłem z listy mailingowej; nie przyszło by mi do głowy samo ;)

Jaki jest problem z inicjalizacją modułu przez wywołanie new MyModule(d) lub przez utworzenie Provider<Something> to ma zastrzyk Injector? Wydaje się, że są to standardowe sposoby radzenia sobie z tego rodzaju problemem. Jak już wspomniano, można również używać metod @Provides z argumentami.

Jeśli zależność jest opcjonalna, możesz utworzyć moduł, a następnie wywołać setter, aby zainicjalizować wartość w razie potrzeby (np. com.google.inject.persist.jpa.JpaPersistModule robi to z właściwościami, używając new JpaPersistModule(String), aby załadować poprawną wartość konfiguracja).

W Przeciwnym Razie przypuszczam, że może być to możliwe (a następnie zadzwonić createChildInjector(Modules... modules)), ale prawie zawsze wolałbym jedno z innych podejść do tego.