Como criar um diretório / pasta temporário em Java?

Existe uma maneira padrão e confiável de criar um diretório temporário dentro de um aplicativo Java? Há uma entrada no banco de dados de problemas do Java , que tem um pouco de código nos comentários, mas eu me pergunto se há uma solução padrão a ser encontrada em uma das bibliotecas comuns (Apache Commons etc.)?

Se você estiver usando o JDK 7, use a nova classe Files.createTempDirectory para criar o diretório temporário.

Path tempDirWithPrefix = Files.createTempDirectory(prefix);

Antes do JDK 7, isso deveria ser feito:

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

Você pode criar exceções melhores (subclasse IOException), se desejar.

A biblioteca do Google Guava possui vários utilitários úteis. Uma nota aqui é a classe Arquivos . Possui vários métodos úteis, incluindo:

File myTempDir = Files.createTempDir();

Isso faz exatamente o que você pediu em uma linha. Se você ler a documentação aqui, verá que a adaptação proposta File.createTempFile("install", "dir")geralmente apresenta vulnerabilidades de segurança.

Se você precisa de um diretório temporário para testar e você estiver usando JUnit, @Rulejuntamente com TemporaryFolderresolve o seu problema:

@Rule
public TemporaryFolder folder = new TemporaryFolder();

A partir da documentação :

A regra TemporaryFolder permite a criação de arquivos e pastas que são garantidos para serem excluídos quando o método de teste terminar (se passa ou falha)

Atualizar:

Se você estiver usando o JUnit Jupiter (versão 5.1.1 ou superior), terá a opção de usar o JUnit Pioneer, que é o JUnit 5 Extension Pack.

Copiado da documentação do projeto :

Por exemplo, o teste a seguir registra a extensão para um único método de teste, cria e grava um arquivo no diretório temporário e verifica seu conteúdo.

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

Mais informações no JavaDoc e no JavaDoc do 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>

Atualização 2:

A anotação @TempDir foi adicionada à versão do JUnit Jupiter 5.4.0 como um recurso experimental. Exemplo copiado do Guia do Usuário 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));
}

O código escrito de forma ingênua para resolver esse problema sofre com as condições da corrida, incluindo várias das respostas aqui. Historicamente, você pode pensar cuidadosamente sobre as condições da corrida e escrevê-lo, ou pode usar uma biblioteca de terceiros como o Guava do Google (como sugeriu a resposta de Spina.) Ou pode escrever um código de buggy.

Mas a partir do JDK 7, há boas notícias! A própria biblioteca padrão Java agora oferece uma solução (não atrevida) adequada para esse problema. Você deseja java.nio.file.Files # createTempDirectory () . A partir da documentação :

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

Cria um novo diretório no diretório especificado, usando o prefixo fornecido para gerar seu nome. O caminho resultante está associado ao mesmo sistema de arquivos que o diretório fornecido.

Os detalhes de como o nome do diretório é construído dependem da implementação e, portanto, não são especificados. Sempre que possível, o prefixo é usado para construir nomes de candidatos.

Isso efetivamente resolve o relatório de erros embaraçosamente antigo no rastreador de erros da Sun, que solicitava exatamente essa função.

Este é o código fonte do arquivo Files.createTempDir () da biblioteca Guava. Não é tão complexo quanto você imagina:

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

Por padrão:

private static final int TEMP_DIR_ATTEMPTS = 10000;

Veja aqui

Não use deleteOnExit()mesmo se você explicitamente excluí-lo mais tarde.

O Google 'deleteonexit is evil' para mais informações, mas a essência do problema é:

1. deleteOnExit() exclui apenas os encerramentos normais da JVM, não trava ou mata o processo da JVM.

2. deleteOnExit() exclui apenas no encerramento da JVM - não é bom para processos de servidor de longa execução porque:

3. O pior de todos - deleteOnExit()consome memória para cada entrada de arquivo temporário. Se seu processo estiver em execução por meses ou criar muitos arquivos temporários em pouco tempo, você consome memória e nunca a libera até que a JVM seja encerrada.

A partir do Java 1.7 createTempDirectory(prefix, attrs)e createTempDirectory(dir, prefix, attrs)estão incluídos nojava.nio.file.Files

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

Isto é o que eu decidi fazer pelo meu próprio código:

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

Bem, "createTempFile" na verdade cria o arquivo. Então, por que não excluí-lo primeiro e depois fazer o mkdir?

Este código deve funcionar razoavelmente bem:

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

Conforme discutido nesta RFE e seus comentários, você pode ligar tempDir.delete()primeiro. Ou você pode usar System.getProperty("java.io.tmpdir")e criar um diretório lá. De qualquer forma, lembre-se de ligar tempDir.deleteOnExit()ou o arquivo não será excluído depois que você terminar.

Apenas para conclusão, este é o código da biblioteca do google goiaba. Não é meu código, mas acho que é valioso mostrá-lo aqui neste tópico.

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

Eu tenho o mesmo problema, então essa é apenas mais uma resposta para aqueles que estão interessados, e é semelhante a um dos itens acima:

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 para o meu aplicativo, decidi adicionar uma opção para limpar a temperatura na saída, adicionando um gancho de desligamento:

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

O método exclui todos os subdiretórios e arquivos antes de excluir o temp , sem usar o callstack (que é totalmente opcional e você pode fazê-lo com recursão neste momento), mas quero estar do lado seguro.

Como você pode ver nas outras respostas, nenhuma abordagem padrão surgiu. Portanto, você já mencionou o Apache Commons, proponho a seguinte abordagem usando o FileUtils do 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;

}

Isso é preferido, pois o apache comunica a biblioteca que mais se aproxima do "padrão" solicitado e funciona com o JDK 7 e versões mais antigas. Isso também retorna uma instância de arquivo "antiga" (que é baseada em fluxo) e não uma instância de caminho "nova" (que é baseada em buffer e seria o resultado do método getTemporaryDirectory () do JDK7) -> Portanto, ele retorna o que a maioria das pessoas precisa quando eles querem criar um diretório temporário.

Gosto das várias tentativas de criar um nome único, mas mesmo essa solução não descarta uma condição de corrida. Outro processo pode ocorrer após o teste exists()e a if(newTempDir.mkdirs())invocação do método. Não tenho idéia de como tornar isso completamente seguro sem recorrer ao código nativo, que eu presumo é o que está escondido dentro dele File.createTempFile().

Antes do Java 7, você também podia:

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

Tente este pequeno exemplo:

Código:

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

Importações:
java.io.IOException
java.nio.file.Files
java.nio.file.Path

Saída do console na máquina Windows:
C: \ Users \ userName \ AppData \ Local \ Temp \ tmpDir2908538301081367877

Comentário:
Files.createTempDirectory gera ID exclusivo automaticamente - 2908538301081367877.

Nota:
Leia o seguinte para excluir diretórios recursivamente:
Exclua diretórios recursivamente em Java

Usar File#createTempFilee deletecriar um nome exclusivo para o diretório parece ok. Você deve adicionar a ShutdownHookpara excluir o diretório (recursivamente) no encerramento da JVM.