1. Temporäre Dateien erstellen: Files.createTempFile
Temporäre Dateien werden benötigt, um Zwischendaten, Caches oder beliebige Ergebnisse zu speichern, die nicht für eine langfristige Aufbewahrung gedacht sind. In der Regel leben sie genau so lange, wie das Programm läuft, oder bis die Notwendigkeit für diese Daten entfällt.
Am häufigsten nutzt man temporäre Dateien beim Herunterladen großer Dokumente (zuerst werden sie in einen temporären Ordner geladen und anschließend an den gewünschten Ort verschoben), beim Caching von Informationen, die neu berechnet oder erneut abgerufen werden können, zur Speicherung von Zwischenergebnissen bei der Verarbeitung großer Datenmengen sowie für den Datenaustausch zwischen Teilen des Programms oder Threads. Ein weiteres häufiges Szenario – Tests: Es ist bequemer, in temporäre Dateien zu schreiben, als Arbeitsverzeichnisse zu überfrachten.
Man kann sagen: Temporäre Dateien sind die Entwürfe der Anwendung. Sie sind nicht für die Öffentlichkeit, aber ohne sie ist die Arbeit nicht immer zu erledigen.
In Java ist das Erstellen einer solchen Datei sehr einfach – buchstäblich mit einer einzigen Zeile. Dafür gibt es die Methode Files.createTempFile.
Einfaches Beispiel
import java.nio.file.*;
public class TempFileExample {
public static void main(String[] args) throws Exception {
// Wir erstellen eine temporäre Datei mit dem Präfix "myapp_" und dem Suffix ".tmp"
Path tempFile = Files.createTempFile("myapp_", ".tmp");
System.out.println("Temporäre Datei erstellt: " + tempFile);
// Man kann dort Daten hineinschreiben
Files.writeString(tempFile, "Dies sind temporäre Daten");
// Wieder auslesen
String data = Files.readString(tempFile);
System.out.println("Inhalt: " + data);
}
}
Was passiert?
- Die Datei wird im systemweiten temporären Verzeichnis erstellt (in der Regel "/tmp" unter Linux oder "C:\\Users\\<Benutzername>\\AppData\\Local\\Temp" unter Windows).
- Der Dateiname sieht etwa so aus: "myapp_1234567890.tmp".
- Die Datei existiert bereits auf dem Datenträger; Sie können damit wie mit einer normalen Datei arbeiten.
Argumente der Methode
- Das erste Argument – Präfix des Dateinamens (z. B. "myapp_").
- Das zweite Argument – Suffix (z. B. ".tmp"). Wenn nicht angegeben, wird einfach ".tmp" verwendet.
- Wenn beide Argumente null sind, wird ein Standardname verwendet.
Wo wird die Datei gespeichert?
Standardmäßig wird die Datei im systemweiten temporären Verzeichnis gespeichert. Sie können aber auch ein eigenes angeben:
Path tempDir = Paths.get("my_temp_folder");
Files.createDirectories(tempDir); // Erstellen, falls nicht vorhanden
Path tempFile = Files.createTempFile(tempDir, "prefix_", ".txt");
2. Temporäre Verzeichnisse erstellen: Files.createTempDirectory
Manchmal braucht man nicht nur eine temporäre Datei, sondern einen ganzen temporären Ordner – etwa zum Entpacken eines Archivs oder zur temporären Ablage vieler Dateien.
Beispiel
import java.nio.file.*;
public class TempDirExample {
public static void main(String[] args) throws Exception {
// Wir erstellen ein temporäres Verzeichnis mit dem Präfix "work_"
Path tempDir = Files.createTempDirectory("work_");
System.out.println("Temporärer Ordner: " + tempDir);
// Darin kann man Dateien anlegen
Path fileInTempDir = Files.createTempFile(tempDir, "file_", ".dat");
System.out.println("Temporäre Datei darin: " + fileInTempDir);
}
}
Besonderheiten:
- Der Ordnername sieht ungefähr so aus: "work_1234567890".
- Standardmäßig – im systemweiten temporären Verzeichnis, man kann aber auch ein beliebiges anderes angeben.
Verzeichnis angeben
Path baseDir = Paths.get("my_temp_work");
Files.createDirectories(baseDir);
Path tempDir = Files.createTempDirectory(baseDir, "session_");
3. Temporäre Dateien und Verzeichnisse löschen
Hier verbirgt sich einer der größten Fallstricke in Java: Temporäre Dateien und Ordner werden nicht automatisch gelöscht! Wenn Sie sie nicht entfernen, bleiben sie auf dem Datenträger und „erfreuen“ Sie noch jahrelang (oder bis zur nächsten Systembereinigung).
Wie löscht man temporäre Dateien?
- Manuell: Nach Abschluss der Arbeit mit der Datei rufen Sie Files.delete(...) oder Files.deleteIfExists(...) auf.
- Am Programmschluss: Man kann die altbewährte Methode File.deleteOnExit() verwenden, allerdings nur für Objekte vom Typ File, nicht für Path.
Beispiel: Eine temporäre Datei löschen
import java.nio.file.*;
public class TempFileDeleteExample {
public static void main(String[] args) throws Exception {
Path tempFile = Files.createTempFile("demo_", ".tmp");
System.out.println("Erstellt: " + tempFile);
// ... mit der Datei arbeiten
// Datei löschen
Files.deleteIfExists(tempFile);
System.out.println("Gelöscht: " + tempFile);
}
}
Verwendung von deleteOnExit()
import java.io.File;
public class DeleteOnExitDemo {
public static void main(String[] args) throws Exception {
File tempFile = File.createTempFile("legacy_", ".tmp");
System.out.println("Erstellt: " + tempFile);
// Datei zum Löschen beim Beenden der JVM vormerken
tempFile.deleteOnExit();
}
}
Achtung!
Die Methode deleteOnExit() funktioniert nur mit File, nicht mit Path. Wenn Sie die moderne API verwenden (Path und Files), löschen Sie manuell.
Temporäre Verzeichnisse löschen
Ein temporäres Verzeichnis lässt sich nur löschen, wenn es leer ist:
Files.delete(tempDir); // wirft eine Ausnahme, wenn darin noch etwas vorhanden ist
Wenn im Ordner Dateien liegen – löschen Sie diese zuerst, dann den Ordner. Üblicherweise schreibt man dafür eine kleine rekursive Methode.
4. Praktische Empfehlungen
Wo sollte man temporäre Dateien speichern?
Systemweites temporäres Verzeichnis:
Verwenden Sie es standardmäßig, sofern keine besonderen Anforderungen bestehen. Den Pfad erhalten Sie so:
String tempDir = System.getProperty("java.io.tmpdir");
System.out.println("System-Temp-Ordner: " + tempDir);
Eigener Ordner:
Wenn Sicherheit oder Ordnung wichtig sind – legen Sie einen separaten Ordner an (z. B. im Verzeichnis der Anwendung).
Sicherheit
- Speichern Sie temporäre Dateien nicht in öffentlich zugänglichen Ordnern – insbesondere nicht, wenn dort etwas Vertrauliches liegen könnte.
- Bereinigen Sie temporäre Dateien nach der Verwendung – andernfalls können sie sich ansammeln und Speicherplatz belegen.
Aufräumen bei Fehlern
Tritt während der Programmausführung ein Fehler auf, vergessen Sie nicht, temporäre Dateien zu löschen. Dafür eignen sich try-finally-Blöcke:
Path tempFile = Files.createTempFile("task_", ".tmp");
try {
// Datei verwenden
} finally {
Files.deleteIfExists(tempFile);
}
Temporäre Dateien und Tests
In Tests werden temporäre Dateien und Ordner häufig zur Isolierung von Daten verwendet. Nach dem Test – unbedingt alles Erzeugte löschen!
5. Beispiel: temporäres Arbeitsverzeichnis für die Datenverarbeitung
Angenommen, Sie schreiben ein Programm, das ein Archiv verarbeitet und Dateien temporär entpackt. Dafür ist es praktisch, einen temporären Ordner zu erstellen und ihn nach Abschluss der Arbeit zu löschen.
import java.nio.file.*;
import java.io.IOException;
public class TempWorkDirExample {
public static void main(String[] args) throws IOException {
// Wir erstellen ein temporäres Arbeitsverzeichnis
Path tempWorkDir = Files.createTempDirectory("unzip_");
System.out.println("Temporärer Arbeitsordner: " + tempWorkDir);
try {
// Hier könnte das Entpacken eines Archivs stattfinden
Path tempFile = Files.createTempFile(tempWorkDir, "file_", ".txt");
Files.writeString(tempFile, "Temporäre Daten zur Verarbeitung");
// ... mit den Dateien arbeiten
} finally {
// Alle Dateien im Ordner und den Ordner selbst löschen
Files.walk(tempWorkDir)
.sorted((a, b) -> b.compareTo(a)) // erst Dateien, dann Ordner
.forEach(path -> {
try {
Files.deleteIfExists(path);
} catch (IOException ex) {
System.err.println("Konnte " + path + " nicht löschen: " + ex.getMessage());
}
});
System.out.println("Temporärer Ordner und Dateien wurden gelöscht.");
}
}
}
Beachten Sie:
Zuerst löschen wir alle Dateien, dann den Ordner selbst. Die Sortierung ist nötig, um nicht zu versuchen, den Ordner zu löschen, bevor sein Inhalt entfernt wurde.
6. Typische Fehler beim Umgang mit temporären Dateien
Fehler Nr. 1: Temporäre Datei oder Ordner nicht gelöscht. Das häufigste Problem – temporäre Dateien bleiben auf dem Datenträger, sammeln sich an und führen mit der Zeit zur „Vermüllung“ des Systems. Besonders kritisch ist das bei Serveranwendungen und langlebigen Prozessen.
Fehler Nr. 2: Sie verwenden deleteOnExit() für Path. Die Methode deleteOnExit() funktioniert nur mit der Klasse File, nicht mit Path. Wenn Sie die moderne API nutzen, müssen Sie manuell löschen.
Fehler Nr. 3: Sie versuchen, einen nicht leeren Ordner über Files.delete zu löschen. Die Methode Files.delete() löscht nur leere Verzeichnisse. Wenn darin noch etwas vorhanden ist, wird eine Ausnahme geworfen. Zum Löschen nicht leerer Verzeichnisse verwenden Sie einen rekursiven Durchlauf und löschen alle Dateien.
Fehler Nr. 4: Sie erstellen temporäre Dateien im Arbeitsverzeichnis des Projekts. Das kann zum versehentlichen Löschen wichtiger Dateien oder zu Verwirrung führen. Verwenden Sie besser den systemweiten Temp-Ordner oder einen separaten Ordner für temporäre Dateien der Anwendung.
Fehler Nr. 5: Sie behandeln Ausnahmen beim Löschen temporärer Dateien nicht. Wenn die Datei bereits gelöscht oder gesperrt ist, kann der Löschversuch eine Ausnahme auslösen. Verwenden Sie Files.deleteIfExists() und eine Fehlerbehandlung.
GO TO FULL VERSION