Scala에는 어떤 자동 리소스 관리 대안이 있습니까?
-
18-09-2019 - |
문제
스칼라 웹에서 ARM (Automatic Resource Management)의 많은 예를 보았습니다. 대부분은 서로 비슷해 보이지만 하나를 작성하는 것은 의식 인 것 같습니다. 나 했다 그러나 연속성을 사용하여 꽤 멋진 예를보십시오.
어쨌든, 그 코드의 많은 부분에는 한 유형의 결함이 있으므로 Stack Overflow에서 가장 정확하고 적절한 버전을 투표 할 수있는 Stack Overflow에 대한 참조를 갖는 것이 좋은 생각이라고 생각했습니다.
해결책
지금은 스칼라 2.13 마침내 지원했습니다. try with resources
사용하여 사용 :), 예시:
val lines: Try[Seq[String]] =
Using(new BufferedReader(new FileReader("file.txt"))) { reader =>
Iterator.unfold(())(_ => Option(reader.readLine()).map(_ -> ())).toList
}
또는 사용 Using.resource
피하다 Try
val lines: Seq[String] =
Using.resource(new BufferedReader(new FileReader("file.txt"))) { reader =>
Iterator.unfold(())(_ => Option(reader.readLine()).map(_ -> ())).toList
}
더 많은 예제를 찾을 수 있습니다 사용 문서.
자동 리소스 관리를 수행하기위한 유틸리티. 리소스를 사용하여 작업을 수행하는 데 사용될 수 있으며, 그 후에는 리소스를 생성의 역 순서대로 공개합니다.
다른 팁
크리스 한센 블로그 항목 'Scala의 팔 블록 : 재 방문'3/26/09 Martin Odersky 's의 Slide 21에 대해 이야기합니다 Fosdem 프레젠테이션. 이 다음 블록은 슬라이드 21에서 바로 가져옵니다 (허가) :
def using[T <: { def close() }]
(resource: T)
(block: T => Unit)
{
try {
block(resource)
} finally {
if (resource != null) resource.close()
}
}
-엔드 견적-
그런 다음 다음과 같이 부를 수 있습니다.
using(new BufferedReader(new FileReader("file"))) { r =>
var count = 0
while (r.readLine != null) count += 1
println(count)
}
이 접근법의 단점은 무엇입니까? 이 패턴은 자동 리소스 관리가 필요한 곳의 95%를 다루는 것 같습니다 ...
편집하다: 코드 스 니펫이 추가되었습니다
edit2 : 디자인 패턴 확장 - 파이썬에서 영감을 얻습니다 with
성명서 및 주소 :
- 블록 앞에서 실행할 진술
- 관리 자원에 따라 예외를 다시 제외합니다
- 하나의 단일 사용 명령문으로 두 개의 리소스를 처리합니다
- 암시 적 변환 및 a
Managed
수업
이것은 Scala 2.8입니다.
trait Managed[T] {
def onEnter(): T
def onExit(t:Throwable = null): Unit
def attempt(block: => Unit): Unit = {
try { block } finally {}
}
}
def using[T <: Any](managed: Managed[T])(block: T => Unit) {
val resource = managed.onEnter()
var exception = false
try { block(resource) } catch {
case t:Throwable => exception = true; managed.onExit(t)
} finally {
if (!exception) managed.onExit()
}
}
def using[T <: Any, U <: Any]
(managed1: Managed[T], managed2: Managed[U])
(block: T => U => Unit) {
using[T](managed1) { r =>
using[U](managed2) { s => block(r)(s) }
}
}
class ManagedOS(out:OutputStream) extends Managed[OutputStream] {
def onEnter(): OutputStream = out
def onExit(t:Throwable = null): Unit = {
attempt(out.close())
if (t != null) throw t
}
}
class ManagedIS(in:InputStream) extends Managed[InputStream] {
def onEnter(): InputStream = in
def onExit(t:Throwable = null): Unit = {
attempt(in.close())
if (t != null) throw t
}
}
implicit def os2managed(out:OutputStream): Managed[OutputStream] = {
return new ManagedOS(out)
}
implicit def is2managed(in:InputStream): Managed[InputStream] = {
return new ManagedIS(in)
}
def main(args:Array[String]): Unit = {
using(new FileInputStream("foo.txt"), new FileOutputStream("bar.txt")) {
in => out =>
Iterator continually { in.read() } takeWhile( _ != -1) foreach {
out.write(_)
}
}
}
다니엘,
최근에 자동 리소스 관리를 위해 Scala-Arm 라이브러리를 배포했습니다. 여기에서 문서를 찾을 수 있습니다. https://github.com/jsuereth/scala-arm/wiki
이 라이브러리는 세 가지 스타일의 사용을 지원합니다 (현재).
1) 명령/표현 :
import resource._
for(input <- managed(new FileInputStream("test.txt")) {
// Code that uses the input as a FileInputStream
}
2) 모나 딕 스타일
import resource._
import java.io._
val lines = for { input <- managed(new FileInputStream("test.txt"))
val bufferedReader = new BufferedReader(new InputStreamReader(input))
line <- makeBufferedReaderLineIterator(bufferedReader)
} yield line.trim()
lines foreach println
3) 구분 연속 스타일
다음은 "Echo"TCP 서버입니다.
import java.io._
import util.continuations._
import resource._
def each_line_from(r : BufferedReader) : String @suspendable =
shift { k =>
var line = r.readLine
while(line != null) {
k(line)
line = r.readLine
}
}
reset {
val server = managed(new ServerSocket(8007)) !
while(true) {
// This reset is not needed, however the below denotes a "flow" of execution that can be deferred.
// One can envision an asynchronous execuction model that would support the exact same semantics as below.
reset {
val connection = managed(server.accept) !
val output = managed(connection.getOutputStream) !
val input = managed(connection.getInputStream) !
val writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(output)))
val reader = new BufferedReader(new InputStreamReader(input))
writer.println(each_line_from(reader))
writer.flush()
}
}
}
이 코드는 리소스 유형 특성을 사용하므로 대부분의 리소스 유형에 적응할 수 있습니다. 폐쇄 또는 폐기 방법으로 클래스에 대한 구조 타이핑을 사용하는 폴백이 있습니다. 문서를 확인하고 추가 할 편리한 기능을 생각하면 알려주십시오.
여기에 있습니다 제임스 아이리 연속을 사용하는 솔루션 :
// standard using block definition
def using[X <: {def close()}, A](resource : X)(f : X => A) = {
try {
f(resource)
} finally {
resource.close()
}
}
// A DC version of 'using'
def resource[X <: {def close()}, B](res : X) = shift(using[X, B](res))
// some sugar for reset
def withResources[A, C](x : => A @cps[A, C]) = reset{x}
다음은 비교를위한 연속이 있거나없는 솔루션입니다.
def copyFileCPS = using(new BufferedReader(new FileReader("test.txt"))) {
reader => {
using(new BufferedWriter(new FileWriter("test_copy.txt"))) {
writer => {
var line = reader.readLine
var count = 0
while (line != null) {
count += 1
writer.write(line)
writer.newLine
line = reader.readLine
}
count
}
}
}
}
def copyFileDC = withResources {
val reader = resource[BufferedReader,Int](new BufferedReader(new FileReader("test.txt")))
val writer = resource[BufferedWriter,Int](new BufferedWriter(new FileWriter("test_copy.txt")))
var line = reader.readLine
var count = 0
while(line != null) {
count += 1
writer write line
writer.newLine
line = reader.readLine
}
count
}
그리고 여기 Tiark Rompf의 개선 제안이 있습니다.
trait ContextType[B]
def forceContextType[B]: ContextType[B] = null
// A DC version of 'using'
def resource[X <: {def close()}, B: ContextType](res : X): X @cps[B,B] = shift(using[X, B](res))
// some sugar for reset
def withResources[A](x : => A @cps[A, A]) = reset{x}
// and now use our new lib
def copyFileDC = withResources {
implicit val _ = forceContextType[Int]
val reader = resource(new BufferedReader(new FileReader("test.txt")))
val writer = resource(new BufferedWriter(new FileWriter("test_copy.txt")))
var line = reader.readLine
var count = 0
while(line != null) {
count += 1
writer write line
writer.newLine
line = reader.readLine
}
count
}
스칼라에서 팔을하는 데 점진적인 4 단계 진화가 있습니다.
- 팔이 없음 : 먼지
- 만 클로저 만 : 더 좋지만 다중 중첩 블록
- Monduation Monad : 둥지를 평평하게하는 데 사용하지만 2 블록으로 부 자연스러운 분리
- 직접 스타일 연속 : Nirava, Aha! 이것은 또한 가장 유형-안전한 대안이기도합니다. 원시 블록 외부의 리소스는 유형 오류입니다.
더 나은 파일에 포함 된 경량 (10 줄의 코드) 암이 있습니다. 보다: https://github.com/pathikrit/better-files#lightweight-arm
import better.files._
for {
in <- inputStream.autoClosed
out <- outputStream.autoClosed
} in.pipeTo(out)
// The input and output streams are auto-closed once out of scope
전체 라이브러리를 원하지 않는 경우 구현되는 방법은 다음과 같습니다.
type Closeable = {
def close(): Unit
}
type ManagedResource[A <: Closeable] = Traversable[A]
implicit class CloseableOps[A <: Closeable](resource: A) {
def autoClosed: ManagedResource[A] = new Traversable[A] {
override def foreach[U](f: A => U) = try {
f(resource)
} finally {
resource.close()
}
}
}
유형 클래스를 사용하는 것은 어떻습니까
trait GenericDisposable[-T] {
def dispose(v:T):Unit
}
...
def using[T,U](r:T)(block:T => U)(implicit disp:GenericDisposable[T]):U = try {
block(r)
} finally {
Option(r).foreach { r => disp.dispose(r) }
}
또 다른 대안은 고르피의 게으른 tryclose 모나드입니다. 데이터베이스 연결에 꽤 좋습니다.
val ds = new JdbcDataSource()
val output = for {
conn <- TryClose(ds.getConnection())
ps <- TryClose(conn.prepareStatement("select * from MyTable"))
rs <- TryClose.wrap(ps.executeQuery())
} yield wrap(extractResult(rs))
// Note that Nothing will actually be done until 'resolve' is called
output.resolve match {
case Success(result) => // Do something
case Failure(e) => // Handle Stuff
}
그리고 스트림으로 :
val output = for {
outputStream <- TryClose(new ByteArrayOutputStream())
gzipOutputStream <- TryClose(new GZIPOutputStream(outputStream))
_ <- TryClose.wrap(gzipOutputStream.write(content))
} yield wrap({gzipOutputStream.flush(); outputStream.toByteArray})
output.resolve.unwrap match {
case Success(bytes) => // process result
case Failure(e) => // handle exception
}
추가 정보는 여기에 있습니다 : https://github.com/choppythelumberjack/tryclose
다음은 @chengpohi의 답변입니다. 수정되어 Scala 2.13 대신 Scala 2.8+에서 작동합니다 (예, Scala 2.13에서도 작동합니다).
def unfold[A, S](start: S)(op: S => Option[(A, S)]): List[A] =
Iterator
.iterate(op(start))(_.flatMap{ case (_, s) => op(s) })
.map(_.map(_._1))
.takeWhile(_.isDefined)
.flatten
.toList
def using[A <: AutoCloseable, B](resource: A)
(block: A => B): B =
try block(resource) finally resource.close()
val lines: Seq[String] =
using(new BufferedReader(new FileReader("file.txt"))) { reader =>
unfold(())(_ => Option(reader.readLine()).map(_ -> ())).toList
}