try-with-resources - endlich kein Ressourcen-Chaos mehr

Java • 3. Dezember 2025 • Lesezeit: 6 Minuten

Wenn man in Java mit Dateien, Streams oder Datenbanken arbeitet, stößt man schnell auf das Thema Ressourcenmanagement. Vielleicht kennst du das Problem: Du öffnest eine Datei, liest etwas heraus und am Ende musst du sie wieder schließen. Klingt einfach, aber was passiert, wenn mitten im Code eine Exception geworfen wird? Wird die Ressource dann trotzdem geschlossen? Genau dafür gibt es seit Java 7 eine elegante Lösung: try-with-resources.

Früher sah der Code nämlich schnell unübersichtlich aus, wenn man alles korrekt schließen wollte. Und genau hier kommt try-with-resources ins Spiel - eine einfache, aber sehr mächtige Sprachkonstruktion, die das Leben von Java-Entwicklern deutlich angenehmer macht.

Das klassische Beispiel – Ressourcen manuell schließen

Bevor wir sehen, wie try-with-resources funktioniert, werfen wir kurz einen Blick auf den „alten“ Weg. Angenommen, du möchtest eine Textdatei einlesen:

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class OldStyleExample {
    public static void main(String[] args) {
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader("test.txt"));
            String line = reader.readLine();
            System.out.println("Erste Zeile: " + line);
        } catch (IOException e) {
            System.out.println("Fehler beim Lesen: " + e.getMessage());
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    System.out.println("Fehler beim Schliessen: " + e.getMessage());
                }
            }
        }
    }
}

Ausgabe (angenommen, die Datei enthält den Text „Hallo Welt“):

Erste Zeile: Hallo Welt

Das funktioniert - aber schön ist anders. Besonders der finally-Block mit dem doppelten try-catch ist fehleranfällig und schwer lesbar. Und genau hier kommt die Lösung ins Spiel.

Die moderne Lösung: try-with-resources

Mit try-with-resources wird das Ganze viel sauberer. Du schreibst einfach deine Ressource in die runde Klammer nach try, und Java kümmert sich automatisch darum, dass sie am Ende geschlossen wird - egal ob eine Exception geworfen wird oder nicht.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class TryWithResourcesExample {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("test.txt"))) {
            String line = reader.readLine();
            System.out.println("Erste Zeile: " + line);
        } catch (IOException e) {
            System.out.println("Fehler beim Lesen: " + e.getMessage());
        }
    }
}

Ausgabe:

Erste Zeile: Hallo Welt

Das Ergebnis ist identisch, aber der Code ist viel kürzer, klarer und sicherer. Kein finally, kein zusätzliches try-catch zum Schließen. Java ruft automatisch close() auf, sobald der Block verlassen wird - auch wenn vorher eine Exception auftritt.

Wie funktioniert das im Hintergrund?

Das Ganze funktioniert, weil BufferedReader (und viele andere Klassen) das Interface AutoCloseable implementieren. Dieses Interface hat genau eine Methode: close(). Java weiß dadurch, dass es diese Methode am Ende ausführen muss.

Du kannst das auch selbst nutzen, indem du eigene Klassen schreibst, die AutoCloseable implementieren.

public class MyResource implements AutoCloseable {
    public void doSomething() {
        System.out.println("Ich tue etwas mit der Ressource...");
    }

    @Override
    public void close() {
        System.out.println("Ressource wird automatisch geschlossen.");
    }

    public static void main(String[] args) {
        try (MyResource res = new MyResource()) {
            res.doSomething();
        }
    }
}

Ausgabe:

Ich tue etwas mit der Ressource...
Ressource wird automatisch geschlossen.

Du siehst: Auch deine eigenen Objekte kannst du in einem try-with-resources verwenden. Damit kannst du zum Beispiel Verbindungen, Streams oder temporäre Objekte ganz automatisch aufräumen lassen.

Mehrere Ressourcen gleichzeitig

Manchmal brauchst du mehr als eine Ressource - etwa wenn du von einer Datei liest und in eine andere schreibst. Auch das geht einfach:

import java.io.*;

public class CopyFileExample {
    public static void main(String[] args) {
        try (
            BufferedReader reader = new BufferedReader(new FileReader("quelle.txt"));
            BufferedWriter writer = new BufferedWriter(new FileWriter("ziel.txt"))
        ) {
            String line;
            while ((line = reader.readLine()) != null) {
                writer.write(line);
                writer.newLine();
            }
            System.out.println("Datei wurde erfolgreich kopiert!");
        } catch (IOException e) {
            System.out.println("Fehler: " + e.getMessage());
        }
    }
}

Ausgabe:

Datei wurde erfolgreich kopiert!

Hier werden beide Ressourcen - also der reader und der writer - automatisch geschlossen, sobald der Block verlassen wird. Die Reihenfolge ist dabei umgekehrt: zuerst wird writer geschlossen, dann reader. So wird sichergestellt, dass alle Daten auch wirklich geschrieben sind, bevor die Quelle geschlossen wird.

Ein Wort zu Exceptions

Ein großer Vorteil von try-with-resources ist, dass Exceptions beim Schließen nicht einfach unter den Tisch fallen. Wenn im Block eine Exception geworfen wird und gleichzeitig beim Schließen eine weitere Exception auftritt, wird die zweite Exception als sogenannte suppressed exception gespeichert.

Das kannst du dir sogar anzeigen lassen:

public class SuppressedExample {
    public static void main(String[] args) {
        try (MyFaultyResource res = new MyFaultyResource()) {
            throw new RuntimeException("Fehler im try-Block!");
        } catch (Exception e) {
            System.out.println("Gefangene Exception: " + e.getMessage());
            for (Throwable t : e.getSuppressed()) {
                System.out.println("Unterdrueckte Exception: " + t.getMessage());
            }
        }
    }
}

class MyFaultyResource implements AutoCloseable {
    @Override
    public void close() {
        throw new RuntimeException("Fehler beim Schliessen!");
    }
}

Ausgabe:

Gefangene Exception: Fehler im try-Block!
Unterdrueckte Exception: Fehler beim Schliessen!

Das ist besonders nützlich, wenn du komplexe Logik oder mehrere Ressourcen verwendest, denn so geht keine wichtige Information verloren.

Fazit

try-with-resources ist eine der Funktionen, die deinen Code nicht nur schöner, sondern auch sicherer macht. Besonders für Einsteiger ist es wichtig, früh zu verstehen, wie wichtig das korrekte Schließen von Ressourcen ist - nicht nur bei Dateien, sondern auch bei Datenbankverbindungen, Netzwerkstreams oder Systemressourcen.

Wenn du also das nächste Mal eine Ressource verwendest, die du schließen musst, denk an try-with-resources. Es spart dir nicht nur Zeilen Code, sondern bewahrt dich auch vor subtilen Fehlern, die schwer zu finden sind. Kurz gesagt: weniger Boilerplate, mehr Sicherheit - und das ist immer eine gute Kombination.