UPDATE am 2019 / Sep / 01:
- Verwenden Sie ab Scala 2.13 lieber scala.util.Using
- Fehler
finallybehoben Exception, durch den das Original verschluckt wurde , trywenn der finallyCode einException
Nachdem ich all diese Antworten zum einfachen Schreiben einer Datei in Scala überprüft hatte und einige davon sehr nett sind, hatte ich drei Probleme:
- In der Antwort des Jus12 ist die Verwendung von Currying für die Verwendung der Hilfsmethode für Scala / FP-Anfänger nicht offensichtlich
- Muss Fehler niedrigerer Ebene mit kapseln
scala.util.Try
- Bedürfnisse zu zeigen , Java - Entwickler neue Scala / FP , wie man richtig Nest abhängige Ressourcen , so dass die
closeMethode auf jede abhängige Ressource in umgekehrten Reihenfolge - Hinweis: Schließen abhängige Ressourcen in umgekehrter Reihenfolge vor allem im Fall eines Fehlers ist ein selten verstanden Erfordernis Die java.lang.AutoCloseableSpezifikation, die dazu neigt, zu sehr schädlichen und schwer zu findenden Fehlern und Laufzeitfehlern zu führen
Bevor ich anfange, ist mein Ziel nicht prägnant. Dies soll Scala / FP-Anfängern, die normalerweise aus Java stammen, das Verständnis erleichtern. Ganz am Ende werde ich alle Teile zusammenziehen und dann die Prägnanz erhöhen.
Zunächst muss die usingMethode aktualisiert werden, um sie verwenden zu können Try(auch hier ist Prägnanz nicht das Ziel). Es wird umbenannt 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
}
}
}
)
Der Anfang der obigen tryUsingAutoCloseableMethode kann verwirrend sein, da sie anscheinend zwei Parameterlisten anstelle der üblichen Einzelparameterliste enthält. Dies nennt man Currying. Und ich werde nicht ins Detail gehen, wie Curry funktioniert oder wo es gelegentlich ist nützlich ist. Es stellt sich heraus, dass es für diesen speziellen Problembereich das richtige Werkzeug für den Job ist.
Als nächstes müssen wir eine Methode erstellen tryPrintToFile, die eine erstellt (oder eine vorhandene überschreibt) Fileund eine schreibt List[String]. Es verwendet ein, FileWriterdas von einem eingekapselt BufferedWriterist, das wiederum von einem eingekapselt ist PrintWriter. Um die Leistung zu steigern, wird eine Standardpuffergröße BufferedWriterdefiniert, die viel größer als die Standardpuffergröße ist.defaultBufferSize , und der Wert 65536 zugewiesen.
Hier ist der Code (und auch hier ist Prägnanz nicht das Ziel):
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))
)
}
}
}
}
Die obige tryPrintToFileMethode ist insofern nützlich, als sie a List[String]als Eingabe nimmt und an a sendet File. Lassen Sie uns nun eine tryWriteToFileMethode erstellen , die a nimmt Stringund in a schreibtFile .
Hier ist der Code (und ich lasse Sie hier die Priorität der Prägnanz erraten):
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))
}
}
}
Schließlich ist es nützlich, den Inhalt von a Fileals a abrufen zu können String. Während dies scala.io.Sourceeine bequeme Methode zum einfachen Abrufen des Inhalts von a darstellt File, closemuss die Methode verwendet werden Source, um die zugrunde liegenden JVM- und Dateisystem-Handles freizugeben. Wenn dies nicht erfolgt, wird die Ressource erst freigegeben, wenn der JVM GC (Garbage Collector) die SourceInstanz selbst freigegeben hat. Und selbst dann gibt es nur eine schwache JVM-Garantie, dass die finalizeMethode vom GC zur closeRessource aufgerufen wird . Dies bedeutet, dass es in der Verantwortung des Kunden liegt, das explizit aufzurufen . Dazu benötigen wir eine zweite Definition der using-Methode, die behandelt wird .close Methode , genauso wie es in der Verantwortung eines Kunden liegt, groß zu seinclose eine Instanz von zu ermittelnjava.lang.AutoCloseablescala.io.Source
Hier ist der Code dafür (immer noch nicht präzise):
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
}
}
}
)
Und hier ist ein Beispiel für die Verwendung in einem supereinfachen Zeilen-Streaming-Dateireader (der derzeit zum Lesen von durch Tabulatoren getrennten Dateien aus der Datenbankausgabe verwendet wird):
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
)
)
Eine aktualisierte Version der oben genannten Funktion wurde als Antwort auf eine andere, aber verwandte StackOverflow-Frage bereitgestellt .
Wenn Sie nun alles zusammen mit den extrahierten Importen zusammenführen (was das Einfügen in das Scala-Arbeitsblatt, das sowohl im Eclipse ScalaIDE- als auch im IntelliJ Scala-Plugin vorhanden ist, erheblich vereinfacht, um die Ausgabe auf den Desktop zu übertragen und die Prüfung mit einem Texteditor zu vereinfachen), So sieht der Code aus (mit erhöhter Prägnanz):
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
)
}
Als Scala / FP-Neuling habe ich viele Stunden (meistens mit Kopfkratzern) verbrannt, um mir das oben genannte Wissen und die oben genannten Lösungen zu verdienen. Ich hoffe, dies hilft anderen Scala / FP-Neulingen, diesen speziellen Lernbuckel schneller zu überwinden.