Lavorare con file e directory temporanei

1. Creazione di file temporanei: Files.createTempFile

I file temporanei servono per memorizzare dati intermedi, cache o qualsiasi risultato non destinato a una conservazione a lungo termine. Di norma, esistono solo finché il programma è in esecuzione o finché quei dati non sono più necessari.

Di solito i file temporanei si usano quando si scaricano documenti di grandi dimensioni (prima li si scarica in una cartella temporanea e poi li si sposta nel percorso desiderato), per memorizzare in cache informazioni che si possono ricalcolare o recuperare di nuovo, per conservare risultati intermedi durante l’elaborazione di grandi quantità di dati, nonché per lo scambio di dati tra parti del programma o thread. Un altro scenario frequente — i test: è più comodo scrivere su file temporanei che riempire le directory di lavoro.

Si può dire che i file temporanei sono le bozze del programma. Non sono per il pubblico, ma senza di loro non sempre si porta a termine il lavoro.

In Java creare un file del genere è molto semplice — basta una sola riga. A questo serve il metodo Files.createTempFile.

Esempio semplice

import java.nio.file.*;

public class TempFileExample {
    public static void main(String[] args) throws Exception {
        // Creiamo un file temporaneo con prefisso "myapp_" e suffisso ".tmp"
        Path tempFile = Files.createTempFile("myapp_", ".tmp");
        System.out.println("File temporaneo creato: " + tempFile);

        // Possiamo scriverci dei dati
        Files.writeString(tempFile, "Questi sono dati temporanei");

        // Leggiamo di nuovo
        String data = Files.readString(tempFile);
        System.out.println("Contenuto: " + data);
    }
}

Che cosa succede?

• Il file viene creato nella directory temporanea di sistema (di solito "/tmp" su Linux o "C:\\Users\\<name>\\AppData\\Local\\Temp" su Windows).
• Il nome del file sarà qualcosa come "myapp_1234567890.tmp".
• Il file esiste già sul disco, e ci si può lavorare come con un file normale.

Argomenti del metodo

• Il primo argomento — prefisso del nome del file (ad esempio, "myapp_").
• Il secondo argomento — suffisso (ad esempio, ".tmp"). Se non lo si specifica, sarà semplicemente ".tmp".
• Se entrambi gli argomenti sono null, il nome sarà quello predefinito.

Dove viene salvato il file?

Per impostazione predefinita il file viene salvato nella directory temporanea di sistema. Ma potete indicarne una vostra:

Path tempDir = Paths.get("my_temp_folder");
Files.createDirectories(tempDir); // Creiamo, se non esiste
Path tempFile = Files.createTempFile(tempDir, "prefix_", ".txt");

2. Creazione di directory temporanee: Files.createTempDirectory

A volte serve non solo un file temporaneo, ma un’intera cartella temporanea — ad esempio per estrarre un archivio o per conservare temporaneamente molti file.

Esempio

import java.nio.file.*;

public class TempDirExample {
    public static void main(String[] args) throws Exception {
        // Creiamo una directory temporanea con prefisso "work_"
        Path tempDir = Files.createTempDirectory("work_");
        System.out.println("Cartella temporanea: " + tempDir);

        // È possibile creare file al suo interno
        Path fileInTempDir = Files.createTempFile(tempDir, "file_", ".dat");
        System.out.println("File temporaneo all'interno: " + fileInTempDir);
    }
}

Particolarità:

• Il nome della cartella sarà all’incirca: "work_1234567890".
• Per impostazione predefinita — nella directory temporanea di sistema, ma è possibile specificarne un’altra.

Specificare la directory

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

3. Eliminazione di file e directory temporanei

Ecco uno dei principali “tranelli” di Java: i file e le cartelle temporanei non vengono eliminati automaticamente! Se non li rimuovete, resteranno sul disco e vi “allieteranno” a lungo (o fino alla prossima pulizia da parte del sistema).

Come eliminare i file temporanei?

• A mano: al termine del lavoro con il file chiamate Files.delete(...) oppure Files.deleteIfExists(...).
• Alla fine del programma: potete usare il caro vecchio metodo File.deleteOnExit(), ma solo per oggetti di tipo File, non Path.

Esempio: eliminare un file temporaneo

import java.nio.file.*;

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

        // ... si lavora con il file

        // Eliminiamo il file
        Files.deleteIfExists(tempFile);
        System.out.println("Eliminato: " + tempFile);
    }
}

Uso di 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("Creato: " + tempFile);

        // Contrassegniamo il file per l'eliminazione alla chiusura della JVM
        tempFile.deleteOnExit();
    }
}

Attenzione!
Il metodo deleteOnExit() funziona solo con File, non con Path. Se usate le API moderne (Path e Files), eliminate a mano.

Eliminazione delle directory temporanee

Si può eliminare una cartella temporanea solo se è vuota:

Files.delete(tempDir); // lancerà un'eccezione se all'interno è rimasto qualcosa

Se nella cartella sono presenti dei file — prima eliminate quelli, poi la cartella. Di solito si scrive un piccolo metodo ricorsivo per farlo.

4. Raccomandazioni pratiche

Dove conservare i file temporanei?

Directory temporanea di sistema:
Usatela per impostazione predefinita, se non avete requisiti particolari. Potete ottenere il percorso così:

String tempDir = System.getProperty("java.io.tmpdir");
System.out.println("Cartella temporanea di sistema: " + tempDir);

Cartella dedicata:
Se sicurezza o organizzazione sono importanti — create una cartella separata (ad esempio all’interno della directory dell’applicazione).

Sicurezza

• Non conservate file temporanei in cartelle accessibili a tutti — soprattutto se possono contenere qualcosa di riservato.
• Pulite i file temporanei dopo l’uso — altrimenti possono accumularsi e occupare spazio.

Pulizia in caso di errore

Se durante l’esecuzione del programma si verifica un errore, non dimenticate di eliminare i file temporanei. Per questo è comodo usare i blocchi try-finally:

Path tempFile = Files.createTempFile("task_", ".tmp");
try {
    // usiamo il file
} finally {
    Files.deleteIfExists(tempFile);
}

File temporanei e test

Nei test si usano spesso file e cartelle temporanei per isolare i dati. Dopo il test — eliminate sempre tutto ciò che è stato creato!

5. Esempio: cartella di lavoro temporanea per l’elaborazione dei dati

Supponiamo che scriviate un programma che elabora un archivio ed estrae temporaneamente i file. Per questo è comodo creare una cartella temporanea e, al termine del lavoro, eliminarla.

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

public class TempWorkDirExample {
    public static void main(String[] args) throws IOException {
        // Creiamo una directory temporanea
        Path tempWorkDir = Files.createTempDirectory("unzip_");
        System.out.println("Cartella di lavoro temporanea: " + tempWorkDir);

        try {
            // Qui potrebbe esserci l'estrazione di un archivio
            Path tempFile = Files.createTempFile(tempWorkDir, "file_", ".txt");
            Files.writeString(tempFile, "Dati temporanei per l'elaborazione");

            // ... lavoriamo con i file

        } finally {
            // Eliminiamo tutti i file nella cartella e la cartella stessa
            Files.walk(tempWorkDir)
                .sorted((a, b) -> b.compareTo(a)) // prima i file, poi le cartelle
                .forEach(path -> {
                    try {
                        Files.deleteIfExists(path);
                    } catch (IOException ex) {
                        System.err.println("Impossibile eliminare " + path + ": " + ex.getMessage());
                    }
                });
            System.out.println("La cartella temporanea e i file sono stati eliminati.");
        }
    }
}

Da notare:
Prima eliminiamo tutti i file, poi la cartella stessa. L’ordinamento serve per non provare a eliminare la cartella prima di aver eliminato il suo contenuto.

6. Errori tipici nel lavoro con i file temporanei

Errore n. 1: vi dimenticate di eliminare un file o una cartella temporanei. Il problema più comune — i file temporanei rimangono sul disco, si accumulano e col tempo “sporcano” il sistema. È particolarmente critico per le applicazioni server e i processi di lunga durata.

Errore n. 2: usate deleteOnExit() con Path. Il metodo deleteOnExit() funziona solo con la classe File, non con Path. Se usate le API moderne, dovrete eliminare a mano.

Errore n. 3: provate a eliminare una cartella non vuota tramite Files.delete. Il metodo Files.delete() elimina solo le directory vuote. Se dentro è rimasto qualcosa — verrà lanciata un’eccezione. Per eliminare directory non vuote usate una visita ricorsiva e l’eliminazione di tutti i file.

Errore n. 4: create file temporanei nella directory di lavoro del progetto. Può portare all’eliminazione accidentale di file importanti o a confusione. Meglio usare la cartella temporanea di sistema o una cartella separata per i file temporanei dell’applicazione.

Errore n. 5: non gestite le eccezioni quando eliminate file temporanei. Se il file è già stato eliminato o è bloccato, il tentativo di eliminazione può lanciare un’eccezione. Usate Files.deleteIfExists() e gestite gli errori.