Praca z plikami i katalogami tymczasowymi

1. Tworzenie plików tymczasowych: Files.createTempFile

Pliki tymczasowe służą do przechowywania danych pośrednich, cache’u lub wszelkich wyników, które nie są przeznaczone do długotrwałego składowania. Z reguły żyją tak długo, jak działa program, albo dopóki nie zniknie potrzeba korzystania z tych danych.

Najczęściej pliki tymczasowe wykorzystuje się przy pobieraniu dużych dokumentów (najpierw zapisujemy je do katalogu tymczasowego, a potem przenosimy we właściwe miejsce), przy cache’owaniu informacji, które można przeliczyć lub pobrać ponownie, do przechowywania wyników pośrednich przy przetwarzaniu dużych zbiorów danych, a także do wymiany danych między częściami programu lub wątkami. Jeszcze jeden częsty scenariusz — testy: wygodniej pisać do plików tymczasowych, niż zaśmiecać katalogi robocze.

Można powiedzieć, że pliki tymczasowe to szkice programu. Nie są dla publiczności, ale bez nich nie zawsze da się wykonać pracę.

W Javie utworzenie takiego pliku jest bardzo proste — dosłownie jedną linijką. Służy do tego metoda Files.createTempFile.

Prosty przykład

import java.nio.file.*;

public class TempFileExample {
    public static void main(String[] args) throws Exception {
        // Tworzymy plik tymczasowy z prefiksem "myapp_" i sufiksem ".tmp"
        Path tempFile = Files.createTempFile("myapp_", ".tmp");
        System.out.println("Utworzono plik tymczasowy: " + tempFile);

        // Można zapisać tam dane
        Files.writeString(tempFile, "To są dane tymczasowe");

        // Odczytujemy z powrotem
        String data = Files.readString(tempFile);
        System.out.println("Zawartość: " + data);
    }
}

Co się dzieje?

• Plik tworzony jest w systemowym katalogu tymczasowym (zwykle to "/tmp" na Linuksie lub "C:\\Users\\<nazwa_użytkownika>\\AppData\\Local\\Temp" w Windows).
• Nazwa pliku będzie mniej więcej taka: "myapp_1234567890.tmp".
• Plik już istnieje na dysku; można z nim pracować jak ze zwykłym.

Argumenty metody

• Pierwszy argument — prefiks nazwy pliku (np. "myapp_").
• Drugi argument — sufiks (np. ".tmp"). Jeśli go nie podasz, będzie po prostu ".tmp".
• Jeśli oba argumenty są równe null, nazwa zostanie nadana domyślnie.

Gdzie zapisywany jest plik?

Domyślnie plik trafia do systemowego katalogu tymczasowego. Możesz jednak wskazać własny:

Path tempDir = Paths.get("my_temp_folder");
Files.createDirectories(tempDir); // Tworzymy, jeśli nie istnieje
Path tempFile = Files.createTempFile(tempDir, "prefix_", ".txt");

2. Tworzenie katalogów tymczasowych: Files.createTempDirectory

Czasem potrzebny jest nie tylko plik tymczasowy, ale cały katalog tymczasowy — na przykład do rozpakowania archiwum lub tymczasowego przechowywania wielu plików.

Przykład

import java.nio.file.*;

public class TempDirExample {
    public static void main(String[] args) throws Exception {
        // Tworzymy katalog tymczasowy z prefiksem "work_"
        Path tempDir = Files.createTempDirectory("work_");
        System.out.println("Katalog tymczasowy: " + tempDir);

        // Można w nim tworzyć pliki
        Path fileInTempDir = Files.createTempFile(tempDir, "file_", ".dat");
        System.out.println("Plik tymczasowy w środku: " + fileInTempDir);
    }
}

Cechy szczególne:

• Nazwa katalogu będzie mniej więcej taka: "work_1234567890".
• Domyślnie — w systemowym katalogu tymczasowym, ale można wskazać dowolny inny.

Wskazanie katalogu

Path baseDir = Paths.get("my_temp_work");
Files.createDirectories(baseDir);
Path tempDir = Files.createTempDirectory(baseDir, "session_");

3. Usuwanie plików i katalogów tymczasowych

Tu kryje się jedna z głównych „pułapek” Javy: pliki i katalogi tymczasowe nie są usuwane automatycznie! Jeśli ich nie posprzątasz, pozostaną na dysku i będą „cieszyć” swoją obecnością długie lata (albo do następnego czyszczenia przez system).

Jak usuwać pliki tymczasowe?

• Ręcznie: po zakończeniu pracy z plikiem wywołaj Files.delete(...) lub Files.deleteIfExists(...).
• Na końcu programu: można użyć starej, sprawdzonej metody File.deleteOnExit(), ale tylko dla obiektów typu File, a nie Path.

Przykład: usunięcie pliku tymczasowego

import java.nio.file.*;

public class TempFileDeleteExample {
    public static void main(String[] args) throws Exception {
        Path tempFile = Files.createTempFile("demo_", ".tmp");
        System.out.println("Utworzono: " + tempFile);

        // ... pracujemy z plikiem

        // Usuwamy plik
        Files.deleteIfExists(tempFile);
        System.out.println("Usunięto: " + tempFile);
    }
}

Użycie 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("Utworzono: " + tempFile);

        // Oznaczamy plik do usunięcia przy zakończeniu działania JVM
        tempFile.deleteOnExit();
    }
}

Uwaga!
Metoda deleteOnExit() działa tylko z File, a nie z Path. Jeśli używasz nowoczesnego API (Path i Files), usuwaj ręcznie.

Usuwanie katalogów tymczasowych

Katalog tymczasowy można usunąć tylko wtedy, gdy jest pusty:

Files.delete(tempDir); // zgłosi wyjątek, jeśli w środku coś zostało

Jeśli w katalogu są pliki — najpierw je usuń, potem katalog. Zwykle pisze się do tego niewielką metodę rekurencyjną.

4. Praktyczne wskazówki

Gdzie przechowywać pliki tymczasowe?

Systemowy katalog tymczasowy:
Używaj go domyślnie, jeśli nie masz szczególnych wymagań. Ścieżkę można pobrać tak:

String tempDir = System.getProperty("java.io.tmpdir");
System.out.println("Systemowy katalog temp: " + tempDir);

Własny katalog:
Jeśli ważne są bezpieczeństwo lub porządek — utwórz oddzielny katalog (np. wewnątrz katalogu aplikacji).

Bezpieczeństwo

• Nie przechowuj plików tymczasowych w ogólnodostępnych katalogach — zwłaszcza jeśli mogą zawierać coś poufnego.
• Usuwaj pliki tymczasowe po użyciu — w przeciwnym razie mogą się kumulować i zajmować miejsce.

Sprzątanie w razie błędów

Jeśli podczas działania programu wystąpi błąd, nie zapomnij usunąć plików tymczasowych. Do tego wygodnie użyć bloków try-finally:

Path tempFile = Files.createTempFile("task_", ".tmp");
try {
    // używamy pliku
} finally {
    Files.deleteIfExists(tempFile);
}

Pliki tymczasowe i testowanie

W testach często używa się plików i katalogów tymczasowych do izolacji danych. Po teście — koniecznie usuń wszystko, co zostało utworzone!

5. Przykład: tymczasowy katalog roboczy do przetwarzania danych

Załóżmy, że piszesz program, który przetwarza archiwum i tymczasowo rozpakowuje pliki. W tym celu wygodnie jest utworzyć katalog tymczasowy, a po zakończeniu pracy — usunąć go.

import java.nio.file.*;
import java.io.IOException;

public class TempWorkDirExample {
    public static void main(String[] args) throws IOException {
        // Tworzymy katalog tymczasowy
        Path tempWorkDir = Files.createTempDirectory("unzip_");
        System.out.println("Tymczasowy katalog roboczy: " + tempWorkDir);

        try {
            // Tu mogłoby nastąpić rozpakowanie archiwum
            Path tempFile = Files.createTempFile(tempWorkDir, "file_", ".txt");
            Files.writeString(tempFile, "Tymczasowe dane do przetworzenia");

            // ... pracujemy z plikami

        } finally {
            // Usuwamy wszystkie pliki w katalogu i sam katalog
            Files.walk(tempWorkDir)
                .sorted((a, b) -> b.compareTo(a)) // najpierw pliki, potem katalogi
                .forEach(path -> {
                    try {
                        Files.deleteIfExists(path);
                    } catch (IOException ex) {
                        System.err.println("Nie udało się usunąć " + path + ": " + ex.getMessage());
                    }
                });
            System.out.println("Katalog tymczasowy i pliki zostały usunięte.");
        }
    }
}

Zwróć uwagę:
Najpierw usuwamy wszystkie pliki, potem sam katalog. Sortowanie jest potrzebne, aby nie próbować usuwać katalogu, zanim usuniemy jego zawartość.

6. Typowe błędy podczas pracy z plikami tymczasowymi

Błąd nr 1: zapomniano usunąć plik lub katalog tymczasowy. Najczęstszy problem — pliki tymczasowe zostają na dysku, gromadzą się i z czasem prowadzą do „zaśmiecania” systemu. Szczególnie krytyczne jest to dla aplikacji serwerowych i długo działających procesów.

Błąd nr 2: używanie deleteOnExit() dla Path. Metoda deleteOnExit() działa tylko z klasą File, a nie z Path. Jeśli używasz nowoczesnego API, trzeba usuwać ręcznie.

Błąd nr 3: próba usunięcia niepustego katalogu przez Files.delete. Metoda Files.delete() usuwa tylko puste katalogi. Jeśli w środku coś zostało — zostanie zgłoszony wyjątek. Do usuwania niepustych katalogów użyj rekurencyjnego przejścia i usunięcia wszystkich plików.

Błąd nr 4: tworzenie plików tymczasowych w katalogu roboczym projektu. Może to prowadzić do przypadkowego usunięcia ważnych plików lub zamieszania. Lepiej używać systemowego katalogu temp albo oddzielnego katalogu na pliki tymczasowe aplikacji.

Błąd nr 5: brak obsługi wyjątków podczas usuwania plików tymczasowych. Jeśli plik został już usunięty lub jest zablokowany, próba usunięcia może zgłosić wyjątek. Używaj Files.deleteIfExists() i obsługi błędów.