ATUALIZAÇÃO em 2019 / Sep / 01:
- Começando com o Scala 2.13, prefira usar scala.util.
- Corrigido o erro em
finallyque engoliria o original Exceptionjogado tryse o finallycódigo lançasse umException
Depois de revisar todas essas respostas sobre como escrever facilmente um arquivo no Scala, e algumas delas são bastante legais, tive três problemas:
- Na resposta do Jus12 , o uso de currying no método helper usando não é óbvio para iniciantes no Scala / FP
- Precisa encapsular erros de nível inferior com
scala.util.Try
- Precisa mostrar aos desenvolvedores Java novos no Scala / FP como aninhar corretamente recursos dependentes para que o
closemétodo seja executado em cada recurso dependente na ordem inversa - Nota: fechar recursos dependentes na ordem inversa ESPECIALMENTE EM CASO DE FALHA é um requisito raramente compreendido a java.lang.AutoCloseableespecificação que tende a levar a erros muito perniciosos e difíceis de encontrar e falhas no tempo de execução
Antes de começar, meu objetivo não é concisão. É para facilitar um entendimento mais fácil para iniciantes do Scala / FP, geralmente aqueles provenientes de Java. No final, reunirei todos os bits e aumentarei a concisão.
Primeiro, o usingmétodo precisa ser atualizado para uso Try(novamente, concisão não é o objetivo aqui). Ele será renomeado para 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
}
}
}
)
O início do tryUsingAutoCloseablemétodo acima pode ser confuso porque parece ter duas listas de parâmetros em vez da lista de parâmetros únicos habitual. Isso é chamado de curry. E não entrarei em detalhes como o curry funciona ou onde é ocasionalmente útil. Acontece que, para esse espaço problemático específico, é a ferramenta certa para o trabalho.
Em seguida, precisamos criar o método,, tryPrintToFileque criará um (ou substituirá um existente) Filee gravará um List[String]. Ele usa um FileWriterque é encapsulado por um BufferedWriterque, por sua vez, é encapsulado por a PrintWriter. E para elevar o desempenho, BufferedWriteré definido um tamanho de buffer padrão muito maior que o padrão para defaultBufferSize, e atribuído o valor 65536.
Aqui está o código (e novamente, concisão não é o objetivo aqui):
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))
)
}
}
}
}
O tryPrintToFilemétodo acima é útil, pois recebe uma List[String]entrada como e envia para a File. Vamos agora criar um tryWriteToFilemétodo que pega a Stringe grava em a File.
Aqui está o código (e eu vou deixar você adivinhar a prioridade da concisão aqui):
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, é útil poder buscar o conteúdo de a Filecomo a String. Embora scala.io.Sourceforneça um método conveniente para obter facilmente o conteúdo de a File, o closemétodo deve ser usado Sourcepara liberar os identificadores subjacentes da JVM e do sistema de arquivos. Se isso não for feito, o recurso não será liberado até que o JVM GC (Garbage Collector) saia para liberar a Sourceinstância em si. E mesmo assim, há apenas uma garantia fraca da JVM de que o finalizemétodo será chamado pelo GC para closeo recurso. Isso significa que é responsabilidade do cliente chamar explicitamente o closemétodo, da mesma forma que é responsabilidade de um cliente contar closecom uma instância dejava.lang.AutoCloseable. Para isso, precisamos de uma segunda definição do método using que manipula scala.io.Source.
Aqui está o código para isso (ainda não sendo 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 aqui está um exemplo de uso dele em um leitor de arquivos de streaming de linha super simples (atualmente usando para ler arquivos delimitados por tabulações da saída do banco de dados):
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
)
)
Uma versão atualizada da função acima foi fornecida como resposta a uma pergunta StackOverflow diferente, mas relacionada .
Agora, reunindo tudo isso com as importações extraídas (facilitando a colagem na planilha Scala presente no plug-in Eclipse ScalaIDE e IntelliJ Scala para facilitar o despejo de saída na área de trabalho para ser examinado mais facilmente com um editor de texto), é assim que o código se parece (com maior concisão):
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 um novato no Scala / FP, eu queimei muitas horas (principalmente na frustração de arranhar a cabeça), ganhando o conhecimento e as soluções acima. Espero que isso ajude outros iniciantes do Scala / FP a superar esse problema de aprendizado mais rápido.