Question

我正在尝试使用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.fetch和ImageExtractor.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的方式是否正确？如何轻松传递依赖项？

Answer 1

如果你想在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的别名），值得一读。

Answer 2

更新： 删除自定义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。

当我使用＆＃34; Reader monad＆＃34;时，如何注入多个依赖项？依赖注入？

2 个答案: