Guice benutzerdefinierten Bereich Eingabe und Beenden in der Java-Konsole Anwendung

Question

Ich versuche derzeit, Injektion in einer Java-Konsole-Anwendung mit Guice implementieren. Die Anwendung importiert XML-Dateien in eine Datenbank. Jeder Importvorgang wird in einem AbstractImporter getan, was entweder ein UserImporter sein kann, ein ScheduleImporter usw.

public class ScheduleMigrator extends AbstractMigrator { 
    private final UserImporter userImporter; 
    private final ScheduleImporterFactory scheduleImporterFactory; 

    @Inject 
    public ScheduleMigrator(UserImporter userImporter, 
          ScheduleImporterFactory scheduleImporterFactory) { 
     this.userImporter = userImporter; 
     this.scheduleImporterFactory = scheduleImporterFactory; 
    } 

    public void migrate() { 
     // Migrate users 
     userImporter.run(); 

     // Migrate schedules for each type 
     for (ScheduleType scheduleTypes : ScheduleType.values()) { 
      ScheduleImporter importer = 
       scheduleImporterFactory.create(scheduleTypes); 
      importer.run(); 
     } 
    } 

} 

public class UserImporter extends AbstractImporter { 

    private final UserTransformer userTransformer; 
    private final ConfigurationService configurationService; 

    @Inject 
    public UserImporter(UserTransformer userTransformer, 
         ConfigurationService configurationService) { 
     this.userTransformer = userTransformer; 
     this.configurationService = configurationService; 
    } 

    public void run() { 
     // do stuff here 
    } 
} 

@Singleton 
public class UserTransformer { 
    // ...code ommited... 

} 

@ImporterScoped 
public class ConfigurationService { 
    // ...code ommited... 

} 

Ich habe erfolgreich meine eigenen Rahmen geschaffen (@ImporterScoped) für Klassen, die nur verfügbar sein sollten und instanziiert nur in einem Importer. Der Bereich wurde erstellt, indem die Schritte in the wiki ausgeführt wurden. Mein Problem ist, wie sollte ich den Bereich in ScheduleMigrator eingeben und verlassen? Wie Sie in ScheduleMigrator sehen können, wird jede Importer injiziert und ihre run() Methode aufgerufen. Es gibt auch Fabriken (basierend auf Guices @AssistedInject Funktion). Dies ist, wo ich möchte, dass jeder Bereich zu starten und zu beenden, sollten UserImporter und ScheduleImporterFactory in ihrem eigenen Bereich ausgeführt werden.

Dies ist eine grobe Vorstellung davon, was ich zu erreichen bin versucht:

importerScope.enter(); 
(new UserImporter()).run(); 
importerScope.exit(); 

Guice in der Dokumentation erwähnt die Verwendung von Abfangjäger, aber ich bin ein wenig verloren, wie kann es umgesetzt werden.

Answer 1

Die Verwendung von AOP scheint ein sehr überentwickelter Ansatz zu sein und könnte zu Problemen führen. Wann gebe ich den Umfang ein? Wann verlasse ich? Was passiert, wenn ich zwei Importer Objekte instanziiere?

Stattdessen fügte ich eine runScoped Methode in , die eine Runnable dauert und führt es aus. Mit der Injektion bekomme ich den ImporterScope Umfang, gebe ihn ein und verlasse ihn entsprechend.

protected void runScoped(Runnable function) 
{ 
    scenarioScope.enter(); 

    try { 
     function.run(); 
    } 
    finally { 
     scenarioScope.exit(); 
    } 
} 

Verbrauch:

runScoped(() -> { 
    ScheduleImporter importer = 
      scheduleImporterFactory.create(scheduleTypes); 
    importer.run(); 
}); 

Dies führt zu einem Problem, wenn. In ScheduleMigrator kann ich nicht Importers injiziert werden, da ihre Instanziierung außerhalb eines Bereichs auftreten würde und Guice einen OutOfScopeException auslöst. Ich musste jede Importer in eine Provider wickeln.

private final Provider<UserImporter> userImporterProvider; 

runScoped(() -> { 
    UserImporter importer = userImporterProvider.get(); 
    importer.run(); 
});