java-try-mit-Ressourcen-nicht die Arbeit mit scala

Wenn Ihr auf der Scala 2.13 dann sollten Sie das Mit dem Objekt.

In älteren Versionen von scala, es gibt keinen direkt-support für javas try-with-resources-Konstrukt, aber er kann ziemlich leicht bauen Sie Ihren eigenen support, indem die Darlehen Muster. Das folgende ist eine einfache, aber nicht optimale Beispiel, das ist leicht zu verstehen. Eine weitere richtige Lösung gegeben wird später in dieser Antwort:

import java.lang.AutoCloseable

def autoClose[A <: AutoCloseable,B](
        closeable: A)(fun: (A) ⇒ B): B = {
    try {
        fun(closeable)
    } finally {
        closeable.close()
    }
}

Diese definiert eine wiederverwendbare Methode, das funktioniert so ähnlich wie ein try-with-resource-Konstrukt in java. Es funktioniert, indem es zwei parameter. Zunächst ist nimmt die eine Unterklasse von Autoclosable Instanz, und zweiten dauert es eine Funktion, die den gleichen Autoclosable Typ als paremeter. Der Rückgabetyp der Funktion parameter wird als Rückgabetyp der Methode. Die Methode führt dann die Funktion innerhalb eines try -, und schließen Sie die autocloseble in seiner finally-block.

Können Sie es wie folgt (wird hier verwendet, um das Ergebnis findAny() auf den stream.

val result: Optional[String] = autoClose(Files.lines(Paths.get("somefile.txt"))) { stream ⇒
    stream.findAny()
}

Bei Ihrem tun zu wollen, exceptions fangen, haben Sie 2 Möglichkeiten.

1. Fügen Sie einen try/catch-block rund um den Strom.findAny () - Aufruf.

2. Oder fügen Sie einen catch-block der try-block in der autoClose-Methode. Beachten Sie, dass dies sollte nur durchgeführt werden, wenn die Logik innerhalb der catch-block ist nutzbar von allen Orten, wo autoClose genannt wird.

Beachten Sie, dass als Vitalii witrenko darauf hin, diese Methode wird schlucken Sie die exception aus der close-Methode auf, wenn die Funktion durch den Kunden geliefert, und die close-Methode auf das AutoCloseable eine exception wirft. Javas try-mit-Ressourcen behandelt, und wir können machen autoClose tun dies, indem Sie ein bisschen komplexer:

  def autoClose[A <: AutoCloseable,B](
      closeable: A)(fun: (A) ⇒ B): B = {

    var t: Throwable = null
    try {
      fun(closeable)
    } catch {
      case funT: Throwable ⇒
        t = funT
        throw t
    } finally {
      if (t != null) {
        try {
          closeable.close()
        } catch {
          case closeT: Throwable ⇒
            t.addSuppressed(closeT)
            throw t
        }
      } else {
        closeable.close()
      }
    }
  }

Dies funktioniert, indem Sie die Speicherung der potenziell Ausnahme der client-Funktion wirft, und die addition der möglichen Ausnahme der close-Methode als unterdrückte exception. Das ist ziemlich nah an, wie oracle erklärt, dass try-mit-Ressourcen ist es tatsächlich zu tun: http://www.oracle.com/technetwork/articles/java/trywithresources-401775.html

Dies ist jedoch Scala, und viele Menschen werden es vorziehen, das Programm in ein mehr funktionale Weise. In ein mehr funktionale Art und Weise, die Methode zurückgeben soll, einen Versuch, statt eine Ausnahme zu werfen. Dies vermeidet eine Nebenwirkung, eine Ausnahme zu werfen, und macht klar, dass der client, dass die Antwort kann ein Fehler sein, die behandelt werden muss (wie bereits in der Antwort von Stas). In einer praktischen Umsetzung, wir möchten auch, um zu vermeiden, dass ein var, also ein naiver Ansatz wäre:

  //Warning this implementation is not 100% safe, see below
  def autoCloseTry[A <: AutoCloseable,B](
      closeable: A)(fun: (A) ⇒ B): Try[B] = {

    Try(fun(closeable)).transform(
      result ⇒ {
        closeable.close()
        Success(result)
      },
      funT ⇒ {
        Try(closeable.close()).transform(
          _ ⇒ Failure(funT),
          closeT ⇒ {
            funT.addSuppressed(closeT)
            Failure(funT)
          }
        )
      }
    )
  }

Dies könnte Ihnen benannt werden:

    val myTry = autoCloseTry(closeable) { resource ⇒
      //doSomethingWithTheResource
      33
    }
    myTry match {
      case Success(result) ⇒ doSomethingWithTheResult(result)
      case Failure(t) ⇒ handleMyExceptions(t)
    }

Oder Sie könnten einfach anrufen .Holen Sie sich auf myTry zu machen, das Ergebnis zurückgibt, oder werfen eine Ausnahme.

Jedoch als Kolmar, betont in einem Kommentar, dieser Implementierung ist fehlerhaft, durch, wie die return-Anweisung kann in scala. Betrachten Sie das folgende:

  class MyClass extends AutoCloseable {
    override def close(): Unit = println("Closing!")
  }

  def foo: Try[Int] = {
     autoCloseTry(new MyClass) { _ => return Success(0) }
  }

  println(foo)

Würden wir erwarten, dass diese zu drucken, Schließen!, aber wird es nicht. Das problem ist hier das explizite return-Anweisung innerhalb der Funktion Körper. Es macht die Methode überspringen Sie die Logik in der autoCloseTry Methode, und damit nur die Renditen Erfolg(0), ohne schließen der Ressource.

Um dieses problem zu beheben, erstellen wir ein mix aus den 2 Lösungen, eine, die die funktionale API der Rücksendung einen Versuch Wert, aber nutzt die klassische Implementierung, basierend auf try/finally-blocks:

    def autoCloseTry[A <: AutoCloseable,B](
        closeable: A)(fun: (A) ⇒ B): Try[B] = {

      var t: Throwable = null
      try {
        Success(fun(closeable))
      } catch {
        case funT: Throwable ⇒
          t = funT
          Failure(t)
      } finally {
        if (t != null) {
          try {
            closeable.close()
          } catch {
            case closeT: Throwable ⇒
              t.addSuppressed(closeT)
              Failure(t)
          }
        } else {
          closeable.close()
        }
      }
    }

Sollte dies das problem beheben, und kann genauso verwendet werden wie der erste Versuch. Aber es zeigt, dass diese ein bisschen fehleranfällig, und die fehlerhafte Umsetzung wurde in dieser Antwort als die empfohlene version für einige Zeit. So, es sei denn, Sie versuchen zu vermeiden, dass zu viele Bibliotheken, sollten Sie richtig betrachten mit dieser Funktion aus einer Bibliothek. Ich denke, dass es schon eine andere Antwort verweist auf ein, aber meine Vermutung ist, dass es mehrfach Bibliotheken, löst dieses problem auf unterschiedliche Weise.

Haben Sie bereits in einer der Antworten Ansatz:

  def autoClose[A <: AutoCloseable, B](resource: A)(code: A ⇒ B): B = {
    try
      code(resource)
    finally
      resource.close()
  }

Aber ich denke, das folgende ist viel eleganter:

  def autoClose[A <: AutoCloseable, B](resource: A)(code: A ⇒ B): Try[B] = {
    val tryResult = Try {code(resource)}
    resource.close()
    tryResult
  }

Durch die Letzte IMHO ist es einfacher zu handhaben ist die Ablaufsteuerung.