Wie erstelle ich ein temporäres Verzeichnis / einen temporären Ordner in Java?

Gibt es eine standardmäßige und zuverlässige Methode zum Erstellen eines temporären Verzeichnisses in einer Java-Anwendung? Es gibt einen Eintrag in Javas Problemdatenbank , der ein wenig Code in den Kommentaren enthält, aber ich frage mich, ob es eine Standardlösung in einer der üblichen Bibliotheken (Apache Commons usw.) gibt.

Wenn Sie JDK 7 verwenden, verwenden Sie die neue Klasse Files.createTempDirectory , um das temporäre Verzeichnis zu erstellen.

Path tempDirWithPrefix = Files.createTempDirectory(prefix);

Vor JDK 7 sollte dies Folgendes tun:

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);
}

Sie können bessere Ausnahmen machen (Unterklasse IOException), wenn Sie möchten.

Die Google Guava-Bibliothek enthält eine Menge hilfreicher Dienstprogramme. Bemerkenswert ist hier die Files-Klasse . Es gibt eine Reihe nützlicher Methoden, darunter:

File myTempDir = Files.createTempDir();

Dies macht genau das, wonach Sie in einer Zeile gefragt haben. Wenn Sie die Dokumentation hier lesen, werden Sie feststellen, dass die vorgeschlagene Anpassung von File.createTempFile("install", "dir")normalerweise Sicherheitslücken verursacht.

Wenn Sie zum Testen ein temporäres Verzeichnis benötigen und jUnit verwenden, löst @Rulezusammen mit: TemporaryFolderIhr Problem:

@Rule
public TemporaryFolder folder = new TemporaryFolder();

Aus der Dokumentation :

Mit der TemporaryFolder-Regel können Dateien und Ordner erstellt werden, die nach Abschluss der Testmethode (unabhängig davon, ob sie erfolgreich ist oder nicht) gelöscht werden.

Aktualisieren:

Wenn Sie JUnit Jupiter (Version 5.1.1 oder höher) verwenden, können Sie JUnit Pioneer verwenden, das JUnit 5 Extension Pack.

Aus der Projektdokumentation kopiert :

Der folgende Test registriert beispielsweise die Erweiterung für eine einzelne Testmethode, erstellt und schreibt eine Datei in das temporäre Verzeichnis und überprüft deren Inhalt.

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

Weitere Informationen im JavaDoc und im JavaDoc von TempDirectory

Gradle:

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

Maven:

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

Update 2:

Die Annotation @TempDir wurde der JUnit Jupiter 5.4.0-Version als experimentelle Funktion hinzugefügt. Beispiel aus dem JUnit 5-Benutzerhandbuch kopiert :

@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));
}

Naiv geschriebener Code zur Lösung dieses Problems leidet unter den Rennbedingungen, einschließlich einiger der Antworten hier. In der Vergangenheit konnten Sie sorgfältig über die Rennbedingungen nachdenken und diese selbst schreiben oder eine Bibliothek eines Drittanbieters wie Google Guava verwenden (wie Spinas Antwort vorschlug). Oder Sie konnten fehlerhaften Code schreiben.

Aber ab JDK 7 gibt es gute Nachrichten! Die Java-Standardbibliothek selbst bietet jetzt eine ordnungsgemäß funktionierende (nicht rassige) Lösung für dieses Problem. Sie möchten java.nio.file.Files # createTempDirectory () . Aus der Dokumentation :

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

Erstellt ein neues Verzeichnis im angegebenen Verzeichnis unter Verwendung des angegebenen Präfixes, um dessen Namen zu generieren. Der resultierende Pfad ist demselben Dateisystem wie das angegebene Verzeichnis zugeordnet.

Die Details, wie der Name des Verzeichnisses aufgebaut ist, sind implementierungsabhängig und daher nicht angegeben. Wenn möglich, wird das Präfix verwendet, um Kandidatennamen zu erstellen.

Dies behebt effektiv den peinlich alten Fehlerbericht im Sun-Bug-Tracker, der nach einer solchen Funktion gefragt hat.

Dies ist der Quellcode für Files.createTempDir () der Guava-Bibliothek. Es ist nirgends so komplex, wie Sie vielleicht denken:

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) + ')');
}

Standardmäßig:

private static final int TEMP_DIR_ATTEMPTS = 10000;

Siehe hier

Nicht verwenden, deleteOnExit()auch wenn Sie es später explizit löschen.

Google 'deleteonexit is evil' für weitere Informationen, aber der Kern des Problems ist:

1. deleteOnExit() Löscht nur für normale JVM-Abschaltungen, nicht für Abstürze oder das Beenden des JVM-Prozesses.

2. deleteOnExit() wird nur beim Herunterfahren der JVM gelöscht - nicht gut für lange laufende Serverprozesse, weil:

3. Das Schlimmste von allen - deleteOnExit()verbraucht Speicher für jeden temporären Dateieintrag. Wenn Ihr Prozess monatelang ausgeführt wird oder in kurzer Zeit viele temporäre Dateien erstellt, verbrauchen Sie Speicher und geben ihn erst frei, wenn die JVM heruntergefahren wird.

Ab Java 1.7 createTempDirectory(prefix, attrs)und createTempDirectory(dir, prefix, attrs)sind in enthaltenjava.nio.file.Files

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

Folgendes habe ich für meinen eigenen Code beschlossen:

/**
 * 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();
}

Nun, "createTempFile" erstellt die Datei tatsächlich. Warum also nicht zuerst löschen und dann das mkdir darauf ausführen?

Dieser Code sollte einigermaßen gut funktionieren:

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;
}

Wie in dieser RFE und ihren Kommentaren erläutert , können Sie tempDir.delete()zuerst anrufen . Oder Sie können dort System.getProperty("java.io.tmpdir")ein Verzeichnis verwenden und erstellen. In jedem Fall sollten Sie daran denken, anzurufen tempDir.deleteOnExit(), da sonst die Datei nicht gelöscht wird, wenn Sie fertig sind.

Nur zur Vervollständigung ist dies der Code aus der Google Guava-Bibliothek. Es ist nicht mein Code, aber ich denke, es ist wertvoll, ihn hier in diesem Thread zu zeigen.

  /** 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)
            + ')');
  }

Ich habe das gleiche Problem, daher ist dies nur eine weitere Antwort für diejenigen, die interessiert sind, und es ähnelt einer der oben genannten:

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

Und für meine Anwendung habe ich beschlossen, eine Option hinzuzufügen, um die Temperatur beim Beenden zu löschen, also habe ich einen Shutdown-Hook hinzugefügt:

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());
                    }
                }
            }
        }
    });

Die Methode löschen Sie alle subdirs und Dateien vor dem Löschen von Temp , ohne die Aufrufhierarchie verwendet (die völlig optional ist und man könnte es mit Rekursion an dieser Stelle tun), aber ich möchte auf der sicheren Seite sein.

Wie Sie in den anderen Antworten sehen können, ist kein Standardansatz entstanden. Daher haben Sie bereits Apache Commons erwähnt. Ich schlage den folgenden Ansatz mit FileUtils von Apache Commons IO vor :

/**
 * 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;

}

Dies wird bevorzugt, da Apache die Bibliothek gemeinsam nutzt, die dem angeforderten "Standard" am nächsten kommt und sowohl mit JDK 7 als auch mit älteren Versionen funktioniert. Dies gibt auch eine "alte" Dateiinstanz (die streambasiert ist) und keine "neue" Pfadinstanz zurück (die pufferbasiert ist und das Ergebnis der getTemporaryDirectory () -Methode von JDK7 wäre) -> Daher wird zurückgegeben, was die meisten Benutzer wann benötigen Sie möchten ein temporäres Verzeichnis erstellen.

Ich mag die mehrfachen Versuche, einen eindeutigen Namen zu erstellen, aber selbst diese Lösung schließt eine Rennbedingung nicht aus. Ein anderer Prozess kann nach dem Test für exists()und dem if(newTempDir.mkdirs())Methodenaufruf einspringen. Ich habe keine Ahnung, wie ich dies vollständig sicher machen kann, ohne auf nativen Code zurückzugreifen, von dem ich annehme, dass er darin vergraben ist File.createTempFile().

Vor Java 7 konnten Sie auch:

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

Versuchen Sie dieses kleine Beispiel:

Code:

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

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

Konsolenausgabe auf Windows-Computern:
C: \ Benutzer \ Benutzername \ AppData \ Local \ Temp \ tmpDir2908538301081367877

Kommentar:
Files.createTempDirectory generiert atomatisch eine eindeutige ID - 2908538301081367877.

Hinweis:
Lesen Sie Folgendes, um Verzeichnisse rekursiv zu löschen:
Löschen Sie Verzeichnisse rekursiv in Java

Die Verwendung von File#createTempFileund deletezum Erstellen eines eindeutigen Namens für das Verzeichnis scheint in Ordnung zu sein. Sie sollten ein hinzufügen ShutdownHook, um das Verzeichnis (rekursiv) beim Herunterfahren von JVM zu löschen.