当我使用" Reader monad"时,如何注入多个依赖项?依赖注入?

时间:2014-09-20 10:28:05

标签: scala dependency-injection monads

我正在尝试使用Reader monad进行依赖注入,但是当方法需要不同的依赖项时会遇到问题:

class PageFetcher {
  def fetch(url: String) = Reader((dep1: Dep1) => Try {
    ...
  })
}

class ImageExtractor {
  def extractImages(html: String) = Reader((deps: (Dep2, Dep3)) => {
    ...
  })
}


object MyImageFinder {
  def find(url: String) = Reader((deps: (PageFetcher, ImageExtractor)) => {
    val (pageFetcher, imageExtractor) = deps
    for {
      htmlTry <- pageFetcher.fetch(url)
      html <- htmlTry
      images <- imageExtractor.extractImages(html)
    } yield images
  })
}

// I add these 3 useless dependencies here just for demo
class Dep1

class Dep2

class Dep3

您可以看到PageFetcher.fetchImageExtractor.extractImages以及MyImageFinder.find都有不同的依赖关系。

我不确定我是否正确使用Reader的方式,很快当我将它们组合在一起并希望传递依赖关系时,我不知道该怎么做:

val pageFetcher = new PageFetcher
val imageExtractor = new ImageExtractor
val dep1 = new Dep1
val dep2 = new Dep2
val dep3 = new Dep3

def main(args: Array[String]) {
  args.headOption match {
    case Some(url) =>
      MyImageFinder.find(url)(???) match {
        case Success(images) => images.foreach(println)
        case Failure(err) => println(err.toString)
      }
    case _ => println("Please input an url")
  }
}

注意代码MyImageFinder.find(url)(???),我想传递像pageFetcher/imageExtractor/dep1/dep2/dep3这样的依赖关系,无论我怎么做,都无法编译。

我使用Reader的方式是否正确?如何轻松传递依赖项?

2 个答案:

答案 0 :(得分:13)

如果你想在for - 理解中使用多个读者,那么参数类型必须是相同的,不管是这样还是另一种。一种简单的方法就是将所有内容捆绑在一个环境类型中(它可能只是一个元组),然后将其用作所有读者的依赖项。

这会丢弃关于类型中细粒度依赖关系的大量信息,并且您还可以使用local作为for中的输入的一种映射 - 理解:< / p>

case class Foo(i: Int)
case class Bar(s: String)
case class Config(foo: Foo, bar: Bar)

val doSomethingWithFoo: Reader[Foo, String] = Reader(foo => "hello " * foo.i)
val doSomethingWithBar: Reader[Bar, String] = Reader(bar => s"bar is $bar")

val doSomethingWithConfig: Reader[Config, String] = for {
  resFoo <- doSomethingWithFoo.local(_.foo)
  resBar <- doSomethingWithBar.local(_.bar)
} yield (resFoo, resBar)

正如map功能A => B可以将Reader[E, A]更改为Reader[E, B]local E => F更改{{1} } Reader[F, A],在这种情况下,获取读者需要的特定环境块并自行提供。

请注意,Reader[E, A]上有许多其他组合器(更通用的类型 - Kleisli只是Reader的别名),值得一读。

答案 1 :(得分:6)

更新: 删除自定义flatMap以支持scalaz的Reader

正如Travis已经指出的那样,要使用Reader模式,您需要单个参数函数。因此,为了将它用于多个依赖项,您需要以某种方式将所有依赖项都放入单个参数中。在这里它变得有趣。 Travis展示的方式是最简单的方法,但您还必须使用.local调用手动切换环境,如果您需要多个计算子树的依赖项,则需要手动构建本地环境。

另一种方法是让Scala的子类型自动神奇地解决它。只要您的依赖项可以混合使用,组合具有不同或多个依赖项的东西就可以正常工作(如果您实际使用的是scalaz的Reader,那么如果您在Function1上使用flatMap就像某些Reader示例那样)。

选项1:杯子蛋糕模式

允许依赖项混合的一种方法是剥离蛋糕模式。我称之为杯形蛋糕模式,如果我不得不给它命名,Dick Wall称之为Parfait(见https://parleys.com/play/53a7d2cde4b0543940d9e55f/chapter28/about)。这个想法不是将所有内容都放在蛋糕中,而是将依赖项放入蛋糕中并将其作为上下文对象传递,您可以使用阅读器进行抽象。让我们将它应用到您的示例中:

// business logic
class PageFetcher {
  def fetch(url: String) = Reader((deps: Dep1Component) => Try {
    ...
  })
}

class ImageExtractor {
  def extractImages(html: String) = Reader((deps: (Dep2Component with Dep3Component)) => {
    ...
  })
}


object MyImageFinder {
  def find(url: String) = 
    for {
      pageFetcher <- Reader((deps: PageFetcherComponent) => dep.pageFetcher)
      imageExtractor <- Reader((deps: ImageExtractorComponent) => dep.imageExtractor)
      htmlTry <- pageFetcher.fetch(url)
      html <- htmlTry
      images <- imageExtractor.extractImages(html)
    } yield images
}

// I add these 3 useless dependencies here just for demo
class Dep1

class Dep2

class Dep3

// cupcake modules
trait PageFetcherComponent{
  def pageFetcher: PageFetcher
}
trait ImageExtractorComponent{
  def imageExtractor: ImageExtractor
}
trait Dep1Component{
  def dep1: Dep1
}
trait Dep2Component {
  def dep2: Dep2
}
trait Dep3Component{
  def dep3: Dep3
}

object Dependencies extends PageFetcherComponent with ImageExtractorComponent with Dep1Component with Dep2Component with Dep3Component{
  val pageFetcher = new PageFetcher
  val imageExtractor = new ImageExtractor
  val dep1 = new Dep1
  val dep2 = new Dep2
  val dep3 = new Dep3
}

def main(args: Array[String]) {
  args.headOption match {
    case Some(url) =>
      MyImageFinder.find(url)(Dependencies) match {
        case Success(images) => images.foreach(println)
        case Failure(err) => println(err.toString)
      }
    case _ => println("Please input an url")
  }
}

如果您有多个相同依赖项的实例(多个记录器,多个dbs等)并且您希望能够在其中一个上有选择地使用某些代码,则cup-cake模式会变得棘手。< / p>

选项2:类型索引地图

我最近提出了另一种使用特殊数据结构的方法,我称之为类型索引映射。它保存了所有的cup-cake锅炉板,使得使用相同类型依赖的多个实例变得更加容易(即只需将它们包装在单个成员类中以区分它们)。

/** gets stuff out of a TMap */
def Implicit[V:TTKey] = Reader((c: TMap[V]) => c[V])

// business logic
class PageFetcher {
  def fetch(url: String) = Implicit[Dep1].map{ dep1 => Try {
    ...
  }}
}

class ImageExtractor {
  def extractImages(html: String) = for{
    dep2 <- Implicit[Dep1]
    dep3 <- Implicit[Dep3]
  } yield {
    ...
  }
}


object MyImageFinder {
  def find(url: String) = 
    for {
      pageFetcher <- Implicit[PageFetcherComponent]
      imageExtractor <- Implicit[ImageExtractorComponent]
      htmlTry <- pageFetcher.fetch(url)
      html <- htmlTry
      images <- imageExtractor.extractImages(html)
    } yield images
}

// I add these 3 useless dependencies here just for demo
class Dep1

class Dep2

class Dep3

val Dependencies =
  TMap(new PageFetcher) ++
  TMap(new ImageExtractor) ++
  TMap(new Dep1) ++
  TMap(new Dep2) ++
  TMap(new Dep3)

def main(args: Array[String]) {
  args.headOption match {
    case Some(url) =>
      MyImageFinder.find(url)(Dependencies) match {
        case Success(images) => images.foreach(println)
        case Failure(err) => println(err.toString)
      }
    case _ => println("Please input an url")
  }
}

我在这里发表了https://github.com/cvogt/slick-action/。相应的测试用例在这里:https://github.com/cvogt/slick-action/blob/master/src/test/scala/org/cvogt/di/TMapTest.scala#L213它在maven上,但在使用它时要小心,因为代码是不稳定的,当前的实现在2.10中不是线程安全的,仅在2.11中,因为它依赖于TypeTags 。我可能会发布一个适用于2.10和2.11的版本。

<强>附录 虽然这解决了使用reader monad的多依赖注入,但仍然会出现htmlTry的类型错误,因为您将Reader / Function1-composition与Try-composition混合在一起。解决方案是创建一个包装Monad,它在内部包装Function1 [TMap [...],尝试[...]]并允许组合它们。这确实需要你将所有内容都填充到这种类型的monad中,即使某些东西不需要Try。