如何确保资源在 Scala 中以易于理解的方式关闭

Question

如何在 Scala 的 for-comprehensions 中最好地处理具有副作用的函数？

我有一个 for 理解，它首先通过调用函数 f1 创建一种资源 (x)。该资源有一个 close 方法，需要在最后调用，但如果理解以某种方式失败（除非。

所以我们有类似的东西：

import scala.util.{Try,Success,Failure}

trait Resource {
  def close() : Unit
}

// Opens some resource and returns it as Success or returns Failure
def f1 : Try[Resource] = ...
def f2 : Try[Resource] = ...

val res = for {
  x <- f1
  y <- f2
} yield {
  (x,y)
}

我应该在哪里调用 close 方法？我可以在 for-comprehension 的末尾将其称为最后一条语句 (z f2 失败），它们都不能确保调用 close。 或者，我可以分开

x <- f1 

不理解是这样的：

val res = f1
res match {
  case Success(x) => {
    for {
      y <- f2
    }
    x.close
  }

  case Failure(e) => ...       
:

这将确保调用 close 但不是很好的代码。 难道没有更聪明、更干净的方法来实现同样的目标吗？

Answer 1

当我遇到这样的问题时，我会在两种可能性之间做出选择：

1. 使用Scala ARM
2. 自行实现Loan Pattern（链接不稳定，可能会失效）

在大多数情况下，我更喜欢自己的实现以避免额外的依赖。 这是贷款模式的代码：

def using[A](r : Resource)(f : Resource => A) : A =
    try {
        f(r)
    } finally {
        r.close()
    }

用法：

using(getResource())(r =>
    useResource(r)
)

由于您需要 2 个资源，因此您需要使用此模式两次：

using(getResource1())(r1 =>
    using(getResource2())(r2 =>
        doYourWork(r1, r2)))

您还可以查看以下答案：

• Scala: Disposable Resource Pattern
• functional try & catch w/ Scala
• Using a variable in finally block

Answer 2

关闭资源的常见模式是贷款模式：

type Closable = { def close(): Unit }

def withClosable[B](closable: Closable)(op: Closable => B): B = {
  try {
    op(closable)
  } finally {
    closable.close()
  }
}

稍作重构，您就可以使用这种模式：

import scala.util.{Try,Success,Failure}

trait Resource {
  def close() : Unit
}

// Opens some resource and returns it as Success or returns Failure
def f1(res: Resource) : Try[Resource] = ???
def f2(res: Resource) : Try[Resource] = ???

val f1Resource: Resource = ???
val f2Resource: Resource = ???

val res = for {
  x <- withClosable(f1Resource)(f1)
  y <- withClosable(f2Resource)(f2)
} yield {
  (x,y)
}

或

import scala.util.{Try,Success,Failure}

trait Resource {
  def close() : Unit
}

// Opens some resource and returns it as Success or returns Failure
def f1: Try[Resource] = { 
  val res: Resource = ???
  withClosable(res){ ... }
}
def f2: Try[Resource] = { 
  val res: Resource = ???
  withClosable(res){ ... }
}

val res = for {
  x <- f1
  y <- f2
} yield {
  (x,y)
}

Answer 3

你可以使用

https://github.com/jsuereth/scala-arm

如果你的“资源”没有实现 java.io.Closeable（或其他一些可关闭的接口，比库支持），你只需要编写一个隐式转换：

implicit def yourEnititySupport[A <: your.closable.Enitity]: Resource[A] = 
  new Resource[A] {
    override def close(r: A) = r.commit()
    // if you need custom behavior here
    override def closeAfterException(r: A, t: Throwable) = r.rollback()
  }

并像这样使用它：

import resource._

for {
  a <- managed(your.closable.Enitity())
  b <- managed(your.closable.Enitity())
} { doSomething(a, b) }