Question

我读了Dependency Injection Without the Gymnastics PDF，表明不需要任何花哨的DI框架，但它超出了我的掌握（至少没有具体的例子）。当我有机会时，我会尝试观看Dependency Injection Without the Gymnastics和Dead Simple Dependency Injection。

在Java中使用Guice，如果A同时依赖于B和C，并且B和C都依赖于D，那么就会有类似的东西：

public class A {
    @Inject
    public A(B b, C c) {
        this.b = b;
        this.c = c;
    }
}

public class B {
    @Inject
    public B(D d) {
        this.d = d;
    }
}

public class C {
    @Inject
    public C(D d) {
        this.d = d;
    }
}

public class D { /* ... */ }

和一个模块，说明要使用哪个D实现，然后只需要从进样器中请求A的实例：

A a = injector.createInstance(A.class);

鉴于上面的URL中提供了什么，上述代码的Scala等价物如何？

FWIW，我也正在调查https://github.com/dickwall/subcut/blob/master/GettingStarted.md，我只是想了解反DI解决方案。

Answer 1

隐式参数对于您正在描述的用例来说已经足够了。

case class A(implicit b: B, c: C)
case class B(implicit d: D)
case class C(implicit d: D)
class D { /* ... */ }

implicit val theD = new D
implicit val theB = B()
implicit val theC = C()

现在您可以通过以下方式询问A：

val a = A()

Answer 2

您可以使用自我类型解决此问题。

A取决于B和C，B和C都取决于D

所以可以这样写：

class A {
  self: B with C => 
}

trait B { 
  self: D => 
}

trait C {
  self: D => 
}

trait D {}

然后在通话方面：

val x = new A with BImpl with CImpl with DImpl

但下面的代码不会编译，因为B，C，D类的依赖关系未得到解决：

val x = new A

Answer 3

提供这种类型的依赖注入很棘手。上面的大多数示例都要求您在实例化类的位置附近创建implicits。

我能想到的最近的是：

class A(implicit b:B, c:C)
class B(implicit d:D)
class C(implicit d:D)
trait D { //the interface 
  def x:Unit
}

object Implicits {
  implicit def aFactory:A = new A
  implicit lazy val bInstance:B = new B
  implicit def cFactory:C = new C
  implicit def dFactory:D = new D {
     def x:Unit = {/* some code */}
  }
}

然后在你的代码中使用它：

import Implicits._

object MyApplication {
   def main(args: Array[String]):Unit = {
      val a = new A
   }
}

如果您需要在（例如）测试时指定不同的版本，则可以执行以下操作：

import Implicits._

object MyApplication {

  // Define the actual implicits
  Implicits.module = new Module {
    import Implicits._

    def a = new A
    lazy val b = new B
    def c = new C
    def d = new D {
      def x = println("x")
    }
  }

  def main(args: Array[String]):Unit = {
    val a = new A // or val a = implicitly[A] 
  }

}

// The contract (all elements that you need)
trait Module {
  def a: A
  def b: B
  def c: C
  def d: D
}

// Making the contract available as implicits
object Implicits {
  var module: Module = _

  implicit def aFactory:A = module.a
  implicit def bFactory:B = module.b
  implicit def cFactory:C = module.c
  implicit def dFactory:D = module.d
}

这样您就可以在任何文件中导入Implicits._，并提供与原始问题类似的工作流程。

在大多数情况下，我不会使用这种策略。我只是在创建实例的类中使隐式可用：

object MyApplication {

  implicit def a: A = new A
  implicit lazy val b: B = new B
  implicit def c: C = new C
  implicit def d: D = new D {
    def x: Unit = println("x")
  }

  def main(args: Array[String]): Unit = {
    val a = implicitly[A]
    val e = new E
  }

}

class E(implicit d:D) {
    new C
}

此处E在另一个文件中定义，并创建C的实例。我们要求D传递给E，并且E取决于D（通过C）该文档。

Answer 4

我认为@ om-nom-nom的答案非常接近你想要的。这就是我所拥有的：

class A {
  self: B with C => 

  def sum = tripleD + doubleD
}

trait B { 
  self: D => 

  def tripleD = x * 3
}

trait C {
  self: D => 

  def doubleD = x * 2
}

trait D extends B with C {
  val x: Int
}

trait E extends D {
  val x = 3
}

trait F extends D {
  val x = 4
}

val a = new A with E
val b = new A with F

println("a.sum = " + a.sum)
println("b.sum = " + b.sum)

如何避免Scala中的依赖注入？

4 个答案: