AGGIORNAMENTO il 2019 / Sep / 01:
- A partire da Scala 2.13, preferisci usare scala.util.Using
- Risolto il bug
finallyche causava la deglutizione dell'originale Exceptiongenerato tryse il finallycodice avesse lanciato unException
Dopo aver esaminato tutte queste risposte su come scrivere facilmente un file in Scala, e alcune sono piuttosto carine, ho avuto tre problemi:
- Nella risposta di Jus12 , l'uso del curry per l'utilizzo del metodo helper non è ovvio per i principianti di Scala / FP
- Deve incapsulare errori di livello inferiore con
scala.util.Try
- Deve mostrare agli sviluppatori Java nuovi su Scala / FP come nidificare correttamente le risorse dipendenti in modo che il
closemetodo venga eseguito su ciascuna risorsa dipendente in ordine inverso - Nota: la chiusura di risorse dipendenti in ordine inverso, IN PARTICOLARE NELL'EVENTO DI UN GUASTO è un requisito raramente compreso di la java.lang.AutoCloseablespecifica che tende a portare a bug molto perniciosi e difficili da trovare e errori di runtime
Prima di iniziare, il mio obiettivo non è conciso. Serve a facilitare la comprensione per i principianti di Scala / FP, in genere quelli che provengono da Java. Alla fine, unirò tutti i bit e poi aumenterò la concisione.
Innanzitutto, il usingmetodo deve essere aggiornato per essere utilizzato Try(di nuovo, la concisione non è l'obiettivo qui). Sarà rinominato in 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
}
}
}
)
L'inizio del tryUsingAutoCloseablemetodo sopra potrebbe essere fonte di confusione perché sembra avere due elenchi di parametri anziché l'elenco di parametri singolo consueto. Questo si chiama curry. E non approfondirò come funziona il curry o dove si trova di tanto in tanto utile. Si scopre che per questo particolare spazio problematico, è lo strumento giusto per il lavoro.
Successivamente, dobbiamo creare un metodo, tryPrintToFileche creerà un (o sovrascriverà un esistente) Filee scriverà un List[String]. Usa un FileWriterche è incapsulato da un BufferedWriterche è a sua volta incapsulato da un PrintWriter. E per migliorare le prestazioni, BufferedWriterviene definita una dimensione del buffer predefinita molto più grande di quella predefinita ,defaultBufferSize e viene assegnato il valore 65536.
Ecco il codice (e ancora, la concisione non è l'obiettivo qui):
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))
)
}
}
}
}
Il tryPrintToFilemetodo sopra è utile in quanto accetta un List[String]input e lo invia a File. Ora creiamo un tryWriteToFilemetodo che prende a Stringe lo scrive in aFile .
Ecco il codice (e ti farò indovinare la priorità della concisione qui):
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))
}
}
}
Infine, è utile essere in grado di recuperare il contenuto di a Filecome a String. Sebbene scala.io.Sourcefornisca un metodo conveniente per ottenere facilmente il contenuto di a File, il closemetodo deve essere utilizzato su Sourceper rilasciare gli handle di file system e JVM sottostanti. Se ciò non viene fatto, la risorsa non viene rilasciata fino a quando JVM GC (Garbage Collector) non riesce a rilasciare l' Sourceistanza stessa. E anche allora, c'è solo una debole JVM che garantisce che il finalizemetodo verrà chiamato dal GC alla closerisorsa. Ciò significa che è responsabilità del cliente chiamare esplicitamente il . Per questo, abbiamo bisogno di una seconda definizione del metodo using che gestisce .close metodo, esattamente come è responsabilità di un cliente occuparsi di closeun'istanza dijava.lang.AutoCloseablescala.io.Source
Ecco il codice per questo (non essere ancora 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
}
}
}
)
E qui ne è un esempio l'utilizzo in un lettore di file di streaming di linea super semplice (attualmente in uso per leggere file delimitati da tabulazioni dall'output del database):
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
)
)
Una versione aggiornata della funzione sopra è stata fornita come risposta a una domanda StackOverflow diversa ma correlata .
Ora, portando tutto questo insieme alle importazioni estratte (rendendo molto più facile incollare nel foglio di lavoro Scala presente sia nel plug-in Eclipse ScalaIDE sia nel plug-in IntelliJ Scala per semplificare il dump dell'output sul desktop per essere esaminato più facilmente con un editor di testo), ecco come appare il codice (con maggiore concisione):
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
)
}
Come novizio di Scala / FP, ho bruciato molte ore (soprattutto per la frustrazione della testa) guadagnando le conoscenze e le soluzioni di cui sopra. Spero che questo aiuti gli altri neofiti della Scala / FP a superare più velocemente questa particolare gobba di apprendimento.