Come creare una directory / cartella temporanea in Java?

Esiste un modo standard e affidabile per creare una directory temporanea all'interno di un'applicazione Java? C'è una voce nel database dei problemi di Java , che ha un po 'di codice nei commenti, ma mi chiedo se c'è una soluzione standard da trovare in una delle solite librerie (Apache Commons ecc.)?

Se si utilizza JDK 7, utilizzare la nuova classe Files.createTempDirectory per creare la directory temporanea.

Path tempDirWithPrefix = Files.createTempDirectory(prefix);

Prima di JDK 7 questo dovrebbe farlo:

public static File createTempDirectory()
    throws IOException
{
    final File temp;

    temp = File.createTempFile("temp", Long.toString(System.nanoTime()));

    if(!(temp.delete()))
    {
        throw new IOException("Could not delete temp file: " + temp.getAbsolutePath());
    }

    if(!(temp.mkdir()))
    {
        throw new IOException("Could not create temp directory: " + temp.getAbsolutePath());
    }

    return (temp);
}

Se lo desideri, potresti fare eccezioni migliori (sottoclasse IOException).

La libreria di Google Guava ha moltissime utilità utili. Una nota qui è la classe Files . Ha un sacco di metodi utili tra cui:

File myTempDir = Files.createTempDir();

Questo fa esattamente quello che hai chiesto in una riga. Se leggi la documentazione qui vedrai che l'adattamento proposto in File.createTempFile("install", "dir")genere introduce vulnerabilità della sicurezza.

Se hai bisogno di una directory temporanea per il test e stai usando jUnit, @Ruleinsieme a TemporaryFolderrisolve il tuo problema:

@Rule
public TemporaryFolder folder = new TemporaryFolder();

Dalla documentazione :

La regola TemporaryFolder consente la creazione di file e cartelle che sono garantiti per l'eliminazione al termine del metodo di test (se passa o meno)

Aggiornare:

Se si utilizza JUnit Jupiter (versione 5.1.1 o successiva), è possibile utilizzare JUnit Pioneer che è il pacchetto di estensione JUnit 5.

Copiato dalla documentazione del progetto :

Ad esempio, il test seguente registra l'estensione per un singolo metodo di test, crea e scrive un file nella directory temporanea e ne controlla il contenuto.

@Test
@ExtendWith(TempDirectory.class)
void test(@TempDir Path tempDir) {
    Path file = tempDir.resolve("test.txt");
    writeFile(file);
    assertExpectedFileContent(file);
}

Maggiori informazioni in JavaDoc e JavaDoc di TempDirectory

Gradle:

dependencies {
    testImplementation 'org.junit-pioneer:junit-pioneer:0.1.2'
}

Esperto di:

<dependency>
   <groupId>org.junit-pioneer</groupId>
   <artifactId>junit-pioneer</artifactId>
   <version>0.1.2</version>
   <scope>test</scope>
</dependency>

Aggiornamento 2:

L' annotazione @TempDir è stata aggiunta alla versione JUnit Jupiter 5.4.0 come funzionalità sperimentale. Esempio copiato dalla Guida dell'utente di JUnit 5 :

@Test
void writeItemsToFile(@TempDir Path tempDir) throws IOException {
    Path file = tempDir.resolve("test.txt");

    new ListWriter(file).write("a", "b", "c");

    assertEquals(singletonList("a,b,c"), Files.readAllLines(file));
}

Il codice scritto in modo ingenuo per risolvere questo problema soffre di condizioni di gara, tra cui alcune delle risposte qui. Storicamente potresti pensare attentamente alle condizioni di gara e scriverlo tu stesso, oppure potresti utilizzare una libreria di terze parti come la Guava di Google (come suggerito dalla risposta di Spina). Oppure potresti scrivere un codice difettoso.

Ma a partire da JDK 7, ci sono buone notizie! La stessa libreria standard Java ora fornisce una soluzione correttamente funzionante (non audace) a questo problema. Volete java.nio.file.Files # createTempDirectory () . Dalla documentazione :

public static Path createTempDirectory(Path dir,
                       String prefix,
                       FileAttribute<?>... attrs)
                                throws IOException

Crea una nuova directory nella directory specificata, usando il prefisso specificato per generare il suo nome. Il percorso risultante è associato allo stesso FileSystem della directory specificata.

I dettagli su come viene costruito il nome della directory dipendono dall'implementazione e quindi non vengono specificati. Ove possibile, il prefisso viene utilizzato per costruire nomi candidati.

Ciò risolve efficacemente la segnalazione di bug antica e imbarazzante nel tracker dei bug di Sun che richiedeva proprio tale funzione.

Questo è il codice sorgente per Files.createTempDir () della libreria Guava. Non è affatto complesso come potresti pensare:

public static File createTempDir() {
  File baseDir = new File(System.getProperty("java.io.tmpdir"));
  String baseName = System.currentTimeMillis() + "-";

  for (int counter = 0; counter < TEMP_DIR_ATTEMPTS; counter++) {
    File tempDir = new File(baseDir, baseName + counter);
    if (tempDir.mkdir()) {
      return tempDir;
    }
  }
  throw new IllegalStateException("Failed to create directory within "
      + TEMP_DIR_ATTEMPTS + " attempts (tried "
      + baseName + "0 to " + baseName + (TEMP_DIR_ATTEMPTS - 1) + ')');
}

Di default:

private static final int TEMP_DIR_ATTEMPTS = 10000;

Vedere qui

Non utilizzare deleteOnExit()anche se lo si elimina esplicitamente in seguito.

Google "deleteonexit is evil" per ulteriori informazioni, ma l'essenza del problema è:

1. deleteOnExit() elimina solo per i normali arresti JVM, non arresti anomali o interruzione del processo JVM.

2. deleteOnExit() cancella solo l'arresto di JVM - non va bene per processi server di lunga durata perché:

3. Il più cattivo di tutti: deleteOnExit()consuma memoria per ogni voce del file temporaneo. Se il processo è in esecuzione da mesi o crea molti file temporanei in breve tempo, si consuma memoria e non si rilascia mai fino allo spegnimento di JVM.

A partire da Java 1.7 createTempDirectory(prefix, attrs)e createTempDirectory(dir, prefix, attrs)sono inclusi injava.nio.file.Files

Esempio: File tempDir = Files.createTempDirectory("foobar").toFile();

Questo è quello che ho deciso di fare per il mio codice:

/**
 * Create a new temporary directory. Use something like
 * {@link #recursiveDelete(File)} to clean this directory up since it isn't
 * deleted automatically
 * @return  the new directory
 * @throws IOException if there is an error creating the temporary directory
 */
public static File createTempDir() throws IOException
{
    final File sysTempDir = new File(System.getProperty("java.io.tmpdir"));
    File newTempDir;
    final int maxAttempts = 9;
    int attemptCount = 0;
    do
    {
        attemptCount++;
        if(attemptCount > maxAttempts)
        {
            throw new IOException(
                    "The highly improbable has occurred! Failed to " +
                    "create a unique temporary directory after " +
                    maxAttempts + " attempts.");
        }
        String dirName = UUID.randomUUID().toString();
        newTempDir = new File(sysTempDir, dirName);
    } while(newTempDir.exists());

    if(newTempDir.mkdirs())
    {
        return newTempDir;
    }
    else
    {
        throw new IOException(
                "Failed to create temp dir named " +
                newTempDir.getAbsolutePath());
    }
}

/**
 * Recursively delete file or directory
 * @param fileOrDir
 *          the file or dir to delete
 * @return
 *          true iff all files are successfully deleted
 */
public static boolean recursiveDelete(File fileOrDir)
{
    if(fileOrDir.isDirectory())
    {
        // recursively delete contents
        for(File innerFile: fileOrDir.listFiles())
        {
            if(!FileUtilities.recursiveDelete(innerFile))
            {
                return false;
            }
        }
    }

    return fileOrDir.delete();
}

Bene, "createTempFile" crea effettivamente il file. Quindi perché non cancellarlo prima e poi fare il mkdir su di esso?

Questo codice dovrebbe funzionare abbastanza bene:

public static File createTempDir() {
    final String baseTempPath = System.getProperty("java.io.tmpdir");

    Random rand = new Random();
    int randomInt = 1 + rand.nextInt();

    File tempDir = new File(baseTempPath + File.separator + "tempDir" + randomInt);
    if (tempDir.exists() == false) {
        tempDir.mkdir();
    }

    tempDir.deleteOnExit();

    return tempDir;
}

Come discusso in questa RFE e nei suoi commenti, potresti chiamare per tempDir.delete()primo. Oppure puoi usare System.getProperty("java.io.tmpdir")e creare una directory lì. Ad ogni modo, dovresti ricordarti di chiamare tempDir.deleteOnExit(), altrimenti il ​​file non verrà eliminato dopo aver finito.

Solo per completamento, questo è il codice della libreria guava di google. Non è il mio codice, ma penso che sia prezioso mostrarlo qui in questo thread.

  /** Maximum loop count when creating temp directories. */
  private static final int TEMP_DIR_ATTEMPTS = 10000;

  /**
   * Atomically creates a new directory somewhere beneath the system's temporary directory (as
   * defined by the {@code java.io.tmpdir} system property), and returns its name.
   *
   * <p>Use this method instead of {@link File#createTempFile(String, String)} when you wish to
   * create a directory, not a regular file. A common pitfall is to call {@code createTempFile},
   * delete the file and create a directory in its place, but this leads a race condition which can
   * be exploited to create security vulnerabilities, especially when executable files are to be
   * written into the directory.
   *
   * <p>This method assumes that the temporary volume is writable, has free inodes and free blocks,
   * and that it will not be called thousands of times per second.
   *
   * @return the newly-created directory
   * @throws IllegalStateException if the directory could not be created
   */
  public static File createTempDir() {
    File baseDir = new File(System.getProperty("java.io.tmpdir"));
    String baseName = System.currentTimeMillis() + "-";

    for (int counter = 0; counter < TEMP_DIR_ATTEMPTS; counter++) {
      File tempDir = new File(baseDir, baseName + counter);
      if (tempDir.mkdir()) {
        return tempDir;
      }
    }
    throw new IllegalStateException(
        "Failed to create directory within "
            + TEMP_DIR_ATTEMPTS
            + " attempts (tried "
            + baseName
            + "0 to "
            + baseName
            + (TEMP_DIR_ATTEMPTS - 1)
            + ')');
  }

Ho avuto lo stesso problema, quindi questa è solo un'altra risposta per coloro che sono interessati ed è simile a una delle precedenti:

public static final String tempDir = System.getProperty("java.io.tmpdir")+"tmp"+System.nanoTime();
static {
    File f = new File(tempDir);
    if(!f.exists())
        f.mkdir();
}

E per la mia applicazione, ho deciso di aggiungere un'opzione per cancellare la temperatura all'uscita, quindi ho aggiunto un hook di spegnimento:

Runtime.getRuntime().addShutdownHook(new Thread() {
        @Override
        public void run() {
            //stackless deletion
            String root = MainWindow.tempDir;
            Stack<String> dirStack = new Stack<String>();
            dirStack.push(root);
            while(!dirStack.empty()) {
                String dir = dirStack.pop();
                File f = new File(dir);
                if(f.listFiles().length==0)
                    f.delete();
                else {
                    dirStack.push(dir);
                    for(File ff: f.listFiles()) {
                        if(ff.isFile())
                            ff.delete();
                        else if(ff.isDirectory())
                            dirStack.push(ff.getPath());
                    }
                }
            }
        }
    });

Il metodo elimina tutti i file secondari e i file prima di eliminare il temp , senza usare il callstack (che è totalmente facoltativo e potresti farlo con ricorsione a questo punto), ma voglio essere al sicuro.

Come puoi vedere nelle altre risposte, non è emerso alcun approccio standard. Quindi hai già menzionato Apache Commons, propongo il seguente approccio usando FileUtils di Apache Commons IO :

/**
 * Creates a temporary subdirectory in the standard temporary directory.
 * This will be automatically deleted upon exit.
 * 
 * @param prefix
 *            the prefix used to create the directory, completed by a
 *            current timestamp. Use for instance your application's name
 * @return the directory
 */
public static File createTempDirectory(String prefix) {

    final File tmp = new File(FileUtils.getTempDirectory().getAbsolutePath()
            + "/" + prefix + System.currentTimeMillis());
    tmp.mkdir();
    Runtime.getRuntime().addShutdownHook(new Thread() {

        @Override
        public void run() {

            try {
                FileUtils.deleteDirectory(tmp);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    });
    return tmp;

}

Questo è preferito poiché apache condivide la libreria che si avvicina di più allo "standard" richiesto e funziona sia con JDK 7 che con le versioni precedenti. Ciò restituisce anche un'istanza di file "vecchia" (che è basata sul flusso) e non una "nuova" istanza di percorso (che è basata sul buffer e sarebbe il risultato del metodo getTemporaryDirectory () di JDK7) -> Pertanto restituisce ciò di cui la maggior parte delle persone ha bisogno quando vogliono creare una directory temporanea.

Mi piacciono i molteplici tentativi di creare un nome univoco ma anche questa soluzione non esclude una condizione di competizione. Un altro processo può insinuarsi dopo il test exists()e la if(newTempDir.mkdirs())chiamata al metodo. Non ho idea di come renderlo completamente sicuro senza ricorrere al codice nativo, che presumo sia ciò che è sepolto all'interno File.createTempFile().

Prima di Java 7 potresti anche:

File folder = File.createTempFile("testFileUtils", ""); // no suffix
folder.delete();
folder.mkdirs();
folder.deleteOnExit();

Prova questo piccolo esempio:

Codice:

try {
    Path tmpDir = Files.createTempDirectory("tmpDir");
    System.out.println(tmpDir.toString());
    Files.delete(tmpDir);
} catch (IOException e) {
    e.printStackTrace();
}

Importazioni:
java.io.IOException
java.nio.file.Files
java.nio.file.Path

Output della console su computer Windows:
C: \ Users \ nomeutente \ AppData \ Local \ Temp \ tmpDir2908538301081367877

Commento:
Files.createTempDirectory genera un ID univoco atomaticamente - 2908538301081367877.

Nota:
leggere quanto segue per eliminare ricorsivamente le directory:
eliminare ricorsivamente le directory in Java

Usare File#createTempFilee deleteper creare un nome univoco per la directory sembra ok. È necessario aggiungere a ShutdownHookper eliminare la directory (ricorsivamente) all'arresto di JVM.