web-dev-qa-db-fra.com

Quelles alternatives de gestion automatique des ressources existent pour Scala?

J'ai vu de nombreux exemples de ARM (gestion automatique des ressources) sur le Web pour Scala. Cela semble être un rite de passage pour en écrire un, bien que la plupart se ressemblent à peu près. Je ai voir un exemple assez cool en utilisant des continuations, cependant.

En tout cas, une grande partie de ce code a des défauts d'un type ou d'un autre, alors j'ai pensé que ce serait une bonne idée d'avoir une référence ici sur Stack Overflow, où nous pouvons voter pour les versions les plus correctes et les plus appropriées.

scalaresource-management
100
Daniel C. Sobral

Pour l'instant Scala 2.1 a finalement supporté: try with resources en utilisant sing :), Exemple:

val lines: Try[Seq[String]] =
  Using(new BufferedReader(new FileReader("file.txt"))) { reader =>
    Iterator.unfold(())(_ => Option(reader.readLine()).map(_ -> ())).toList
  }

ou en utilisant Using.resource éviter Try

val lines: Seq[String] =
  Using.resource(new BufferedReader(new FileReader("file.txt"))) { reader =>
    Iterator.unfold(())(_ => Option(reader.readLine()).map(_ -> ())).toList
  }

Vous pouvez trouver plus d'exemples dans tilisation doc.

Un utilitaire pour effectuer la gestion automatique des ressources. Il peut être utilisé pour effectuer une opération à l'aide de ressources, après quoi il libère les ressources dans l'ordre inverse de leur création.

5
chengpohi

Chris Hansen entrée de blog "ARM Blocks in Scala: Revisited" du 26/03/09 parle de la diapositive 21 de Martin Odersky présentation du FOSDEM . Ce bloc suivant est tiré directement de la diapositive 21 (avec permission):

def using[T <: { def close() }]
    (resource: T)
    (block: T => Unit) 
{
  try {
    block(resource)
  } finally {
    if (resource != null) resource.close()
  }
}

--fin quote--

Ensuite, nous pouvons appeler comme ceci:

using(new BufferedReader(new FileReader("file"))) { r =>
  var count = 0
  while (r.readLine != null) count += 1
  println(count)
}

Quels sont les inconvénients de cette approche? Ce modèle semble répondre à 95% des cas où j'aurais besoin d'une gestion automatique des ressources ...

Modifier: extrait de code ajouté

Edit2: étendant le modèle de conception - en s'inspirant de l'instruction python with et en adressant:

  • instructions à exécuter avant le bloc
  • réexception d'une exception en fonction de la ressource gérée
  • gérer deux ressources avec une seule instruction using
  • gestion spécifique aux ressources en fournissant une conversion implicite et une classe Managed

C'est avec 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(_) 
    }
  }
}
74
huynhjl

Daniel,

Je viens de déployer la bibliothèque scala-arm pour la gestion automatique des ressources. Vous pouvez trouver la documentation ici: https://github.com/jsuereth/scala-arm/wiki

Cette bibliothèque prend en charge trois styles d'utilisation (actuellement):

1) Impératif/pour l'expression:

import resource._
for(input <- managed(new FileInputStream("test.txt")) {
// Code that uses the input as a FileInputStream
}

2) Style monadique

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) Style de continuations délimitées

Voici un serveur TCP "echo":

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()
    }
  }
}

Le code utilise un trait de type Ressource, il est donc capable de s'adapter à la plupart des types de ressources. Il a une solution de rechange pour utiliser le typage structurel contre des classes avec une méthode close ou dispose. Veuillez consulter la documentation et faites-moi savoir si vous pensez à des fonctionnalités pratiques à ajouter.

62
jsuereth

Voici James Iry solution utilisant des suites:

// 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}

Voici les solutions avec et sans suite de comparaison:

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
}

Et voici la suggestion d'amélioration de 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
}
18
Daniel C. Sobral

Je vois une évolution progressive en 4 étapes pour faire ARM dans Scala:

  1. Pas de bras: saleté
  2. Fermetures uniquement: mieux, mais plusieurs blocs imbriqués
  3. Continuation Monad: Utilisez For pour aplatir la séparation imbriquée mais non naturelle en 2 blocs
  4. Poursuite du style direct: Nirava, aha! C'est également l'alternative la plus sûre pour le type: une ressource en dehors du bloc withResource sera une erreur de type.
7
Mushtaq Ahmed

Il y a un poids léger (10 lignes de code) ARM inclus avec de meilleurs fichiers. Voir: 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

Voici comment il est implémenté si vous ne voulez pas la bibliothèque entière:

  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()
      }
    }
  }
6
pathikrit

Une autre alternative est la monade Lazy TryClose de Choppy. C'est assez bien avec les connexions à la base de données:

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
}

Et avec les flux:

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
}

Plus d'informations ici: https://github.com/choppythelumberjack/tryclose

1
ChoppyTheLumberjack

Comment utiliser les classes Type

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) } 
}
1
Santhosh Sath

Voici la réponse de @ chengpohi, modifiée pour qu'elle fonctionne avec Scala 2.8+, au lieu de seulement Scala 2.13 (oui, cela fonctionne avec Scala 2.13 également):

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
  }
0
Mike Slinn