Dependency Injection in Scala Guice - Übergabe von Parametern

Question

Ich habe ein ziemlich einfaches Szenario zu lösen mit DI, aber ich bin nicht in der Lage, ein richtiges Beispiel/Dokumentation zu finden, um mich durch zu kommen. Ich bin neu in der Scala/Guice Welt.

Die aktuellen Komponenten wie folgt aussehen

trait Foo { 
} 

class FooImpl extends A { 

} 

trait Bar { 
    val description: String 
} 

class BarImpl(val description: String) extends Bar { 

} 

Jetzt habe ich eine Abhängigkeit zwischen Foo und Bar. Also, in der Regel würde der Code wie folgt aussehen

class FooImpl extends Foo { 
    Bar bar = createBar("Random Bar Value!") 
} 

wo createBar("Bar!") einfach new BarImpl("Random Bar Value") zurückgibt. Natürlich entferne ich die Fabrik/Helfer der Kürze halber.

Ich weiß, in dem Moment, in dem ich "neu" benutze, ist dies außerhalb des DI-Paradigmas. Ich möchte sicherstellen, dass Bar basierend auf einem Parameter in FooImpl injiziert werden kann. So ähnlich wie mit einer Factory. Wie verwenden wir DI in der Scala/Guice-Welt?

Ich habe mir AssistedInjection/Named Parameters angeschaut, aber ich konnte nicht verstehen, wie die Nutzung enden würde. Ich nehme an, dass das der beste Weg ist, aber ich konnte nicht verstehen, wie es geschrieben/getestet werden sollte.

Answer 1

Ok, also das ist, was für mich schließlich funktionierte. Schreiben Sie diese Schritte für jeden neu, der sich mit Scala Based Assisted Injection beschäftigen möchte.

Foo kann Bar erfordern, aber was wirklich injiziert werden muss, ist eine BarFactory, und nicht Bar.

Eine BarFactory muss erstellt werden, aber die Implementierung kann Guice überlassen werden. Hier wird es schwierig.

trait BarFactory { 
    def create(msg:String):Bar 
} 

Also lassen Sie uns wieder besuchen Foo und Bar:

@ImplementedBy(classOf[FooImpl]) 
trait Foo { 
    def getBar(msg: String): Bar 
} 

class FooImpl @Inject() (barFactory: BarFactory) extends Foo { 
    override def getBar(msg: String): Bar = { 
    barFactory.create(msg) 
    } 
} 

@ImplementedBy(classOf[BarImpl]) 
trait Bar { 
    def echo() : String 
} 

//Note that we use the @Assisted Annotation Here. 
class BarImpl @Inject() (@Assisted msg: String) extends Bar { 
    override def echo(): String = msg 
} 

die eigentliche Fabrik Erstellen als Teil eines Moduls

class TempModule extends AbstractModule { 
    override def configure(): Unit = { 
    install(new FactoryModuleBuilder() 
     .implement(classOf[Bar], classOf[BarImpl]) 
     .build(classOf[BarFactory])) 
    } 
} 

Und einmal gestartet getan wird, wird die Fabrik Umsetzung durch die zur Verfügung gestellt werden Guice, und Sie sollten in der Lage sein, Ihre tatsächliche Implementierung mithilfe der Factory zu erstellen.