ACTUALIZACIÓN en 2019 / Sep / 01:
- Comenzando con Scala 2.13, prefiera usar scala.util.
- Se corrigió el error por el que
finallyse tragaría el original Exceptionarrojado trysi el finallycódigo arrojaba unException
Después de revisar todas estas respuestas sobre cómo escribir fácilmente un archivo en Scala, y algunas de ellas son bastante agradables, tuve tres problemas:
- En la respuesta de Jus12 , el uso de curry para usar el método auxiliar no es obvio para los principiantes de Scala / FP
- Necesita encapsular errores de nivel inferior con
scala.util.Try
- Necesita mostrar los desarrolladores de Java nuevas a Scala / FP cómo adecuadamente nido dependientes de los recursos por lo que el
closemétodo se lleva a cabo en cada recurso dependiente en orden inverso - Nota: el cierre de los recursos dependientes en el orden inverso en particular en caso de un fallo es un requisito rara vez se entiende de la java.lang.AutoCloseableespecificación que tiende a generar errores muy perniciosos y difíciles de encontrar y fallas en el tiempo de ejecución
Antes de comenzar, mi objetivo no es la concisión. Es para facilitar la comprensión de los principiantes Scala / FP, generalmente los que provienen de Java. Al final, juntaré todos los bits y luego aumentaré la concisión.
Primero, el usingmétodo debe actualizarse para su uso Try(nuevamente, la concisión no es el objetivo aquí). Será renombrado a tryUsingAutoCloseable:
def tryUsingAutoCloseable[A <: AutoCloseable, R]
(instantiateAutoCloseable: () => A) //parameter list 1
(transfer: A => scala.util.Try[R]) //parameter list 2
: scala.util.Try[R] =
Try(instantiateAutoCloseable())
.flatMap(
autoCloseable => {
var optionExceptionTry: Option[Exception] = None
try
transfer(autoCloseable)
catch {
case exceptionTry: Exception =>
optionExceptionTry = Some(exceptionTry)
throw exceptionTry
}
finally
try
autoCloseable.close()
catch {
case exceptionFinally: Exception =>
optionExceptionTry match {
case Some(exceptionTry) =>
exceptionTry.addSuppressed(exceptionFinally)
case None =>
throw exceptionFinally
}
}
}
)
El comienzo del tryUsingAutoCloseablemétodo anterior puede ser confuso porque parece tener dos listas de parámetros en lugar de la lista de parámetros únicos habitual. Esto se llama curry. Y no entraré en detalles sobre cómo funciona el curry o dónde es útil ocasionalmente . Resulta que para este espacio problemático en particular, es la herramienta adecuada para el trabajo.
Luego, necesitamos crear un método, tryPrintToFileque creará un (o sobrescribirá uno existente) Filey escribirá un List[String]. Utiliza un FileWriterque está encapsulado por un BufferedWriterque a su vez está encapsulado por un PrintWriter. Y para elevar el rendimiento, BufferedWriterse define un tamaño de búfer predeterminado mucho mayor que el predeterminado para defaultBufferSize, y se le asigna el valor 65536.
Aquí está el código (y nuevamente, la concisión no es el objetivo aquí):
val defaultBufferSize: Int = 65536
def tryPrintToFile(
lines: List[String],
location: java.io.File,
bufferSize: Int = defaultBufferSize
): scala.util.Try[Unit] = {
tryUsingAutoCloseable(() => new java.io.FileWriter(location)) { //this open brace is the start of the second curried parameter to the tryUsingAutoCloseable method
fileWriter =>
tryUsingAutoCloseable(() => new java.io.BufferedWriter(fileWriter, bufferSize)) { //this open brace is the start of the second curried parameter to the tryUsingAutoCloseable method
bufferedWriter =>
tryUsingAutoCloseable(() => new java.io.PrintWriter(bufferedWriter)) { //this open brace is the start of the second curried parameter to the tryUsingAutoCloseable method
printWriter =>
scala.util.Try(
lines.foreach(line => printWriter.println(line))
)
}
}
}
}
El tryPrintToFilemétodo anterior es útil porque toma un List[String]como entrada y lo envía a File. Ahora creemos un tryWriteToFilemétodo que tome a Stringy lo escriba en a File.
Aquí está el código (y te dejaré adivinar la prioridad de la concisión aquí):
def tryWriteToFile(
content: String,
location: java.io.File,
bufferSize: Int = defaultBufferSize
): scala.util.Try[Unit] = {
tryUsingAutoCloseable(() => new java.io.FileWriter(location)) { //this open brace is the start of the second curried parameter to the tryUsingAutoCloseable method
fileWriter =>
tryUsingAutoCloseable(() => new java.io.BufferedWriter(fileWriter, bufferSize)) { //this open brace is the start of the second curried parameter to the tryUsingAutoCloseable method
bufferedWriter =>
Try(bufferedWriter.write(content))
}
}
}
Finalmente, es útil poder obtener el contenido de a Filecomo a String. Si bien scala.io.Sourceproporciona un método conveniente para obtener fácilmente el contenido de a File, el closemétodo se debe utilizar Sourcepara liberar la JVM subyacente y los identificadores del sistema de archivos. Si esto no se hace, entonces el recurso no se libera hasta que el JVM GC (Garbage Collector) pueda liberar la Sourceinstancia en sí. Y aun así, solo hay una garantía débil de JVM de que el finalizemétodo será llamado por el GC al closerecurso. Esto significa que es responsabilidad del cliente llamar explícitamente al closemétodo, de la misma manera que es responsabilidad de un cliente hacer un alto closeen una instancia dejava.lang.AutoCloseable. Para esto, necesitamos una segunda definición del método de uso que maneja scala.io.Source.
Aquí está el código para esto (todavía no es conciso):
def tryUsingSource[S <: scala.io.Source, R]
(instantiateSource: () => S)
(transfer: S => scala.util.Try[R])
: scala.util.Try[R] =
Try(instantiateSource())
.flatMap(
source => {
var optionExceptionTry: Option[Exception] = None
try
transfer(source)
catch {
case exceptionTry: Exception =>
optionExceptionTry = Some(exceptionTry)
throw exceptionTry
}
finally
try
source.close()
catch {
case exceptionFinally: Exception =>
optionExceptionTry match {
case Some(exceptionTry) =>
exceptionTry.addSuppressed(exceptionFinally)
case None =>
throw exceptionFinally
}
}
}
)
Y aquí hay un ejemplo de uso en un lector de archivos de transmisión de línea súper simple (actualmente utilizado para leer archivos delimitados por tabulaciones de la salida de la base de datos):
def tryProcessSource(
file: java.io.File
, parseLine: (String, Int) => List[String] = (line, index) => List(line)
, filterLine: (List[String], Int) => Boolean = (values, index) => true
, retainValues: (List[String], Int) => List[String] = (values, index) => values
, isFirstLineNotHeader: Boolean = false
): scala.util.Try[List[List[String]]] =
tryUsingSource(scala.io.Source.fromFile(file)) {
source =>
scala.util.Try(
( for {
(line, index) <-
source.getLines().buffered.zipWithIndex
values =
parseLine(line, index)
if (index == 0 && !isFirstLineNotHeader) || filterLine(values, index)
retainedValues =
retainValues(values, index)
} yield retainedValues
).toList //must explicitly use toList due to the source.close which will
//occur immediately following execution of this anonymous function
)
)
Se ha proporcionado una versión actualizada de la función anterior como respuesta a una pregunta diferente pero relacionada de StackOverflow .
Ahora, uniendo todo eso con las importaciones extraídas (lo que hace que sea mucho más fácil pegar en Scala Worksheet presente tanto en Eclipse ScalaIDE como en el complemento IntelliJ Scala para que sea más fácil volcar la salida al escritorio para examinarla más fácilmente con un editor de texto), así es como se ve el código (con mayor concisión):
import scala.io.Source
import scala.util.Try
import java.io.{BufferedWriter, FileWriter, File, PrintWriter}
val defaultBufferSize: Int = 65536
def tryUsingAutoCloseable[A <: AutoCloseable, R]
(instantiateAutoCloseable: () => A) //parameter list 1
(transfer: A => scala.util.Try[R]) //parameter list 2
: scala.util.Try[R] =
Try(instantiateAutoCloseable())
.flatMap(
autoCloseable => {
var optionExceptionTry: Option[Exception] = None
try
transfer(autoCloseable)
catch {
case exceptionTry: Exception =>
optionExceptionTry = Some(exceptionTry)
throw exceptionTry
}
finally
try
autoCloseable.close()
catch {
case exceptionFinally: Exception =>
optionExceptionTry match {
case Some(exceptionTry) =>
exceptionTry.addSuppressed(exceptionFinally)
case None =>
throw exceptionFinally
}
}
}
)
def tryUsingSource[S <: scala.io.Source, R]
(instantiateSource: () => S)
(transfer: S => scala.util.Try[R])
: scala.util.Try[R] =
Try(instantiateSource())
.flatMap(
source => {
var optionExceptionTry: Option[Exception] = None
try
transfer(source)
catch {
case exceptionTry: Exception =>
optionExceptionTry = Some(exceptionTry)
throw exceptionTry
}
finally
try
source.close()
catch {
case exceptionFinally: Exception =>
optionExceptionTry match {
case Some(exceptionTry) =>
exceptionTry.addSuppressed(exceptionFinally)
case None =>
throw exceptionFinally
}
}
}
)
def tryPrintToFile(
lines: List[String],
location: File,
bufferSize: Int = defaultBufferSize
): Try[Unit] =
tryUsingAutoCloseable(() => new FileWriter(location)) { fileWriter =>
tryUsingAutoCloseable(() => new BufferedWriter(fileWriter, bufferSize)) { bufferedWriter =>
tryUsingAutoCloseable(() => new PrintWriter(bufferedWriter)) { printWriter =>
Try(lines.foreach(line => printWriter.println(line)))
}
}
}
def tryWriteToFile(
content: String,
location: File,
bufferSize: Int = defaultBufferSize
): Try[Unit] =
tryUsingAutoCloseable(() => new FileWriter(location)) { fileWriter =>
tryUsingAutoCloseable(() => new BufferedWriter(fileWriter, bufferSize)) { bufferedWriter =>
Try(bufferedWriter.write(content))
}
}
def tryProcessSource(
file: File,
parseLine: (String, Int) => List[String] = (line, index) => List(line),
filterLine: (List[String], Int) => Boolean = (values, index) => true,
retainValues: (List[String], Int) => List[String] = (values, index) => values,
isFirstLineNotHeader: Boolean = false
): Try[List[List[String]]] =
tryUsingSource(() => Source.fromFile(file)) { source =>
Try(
( for {
(line, index) <- source.getLines().buffered.zipWithIndex
values = parseLine(line, index)
if (index == 0 && !isFirstLineNotHeader) || filterLine(values, index)
retainedValues = retainValues(values, index)
} yield retainedValues
).toList
)
}
Como un novato Scala / FP, he quemado muchas horas (en su mayoría frustración en la cabeza) ganando el conocimiento y las soluciones anteriores. Espero que esto ayude a otros novatos de Scala / FP a superar esta joroba de aprendizaje en particular más rápido.