Java'da geçici bir dizin / klasör nasıl oluşturulur?

Bir Java uygulamasında geçici bir dizin oluşturmanın standart ve güvenilir bir yolu var mı? Orada Java'nın sorunu veritabanındaki bir giriş yorumlarında kod biraz vardır, ama her zamanki kütüphaneleri (Apache Commons vs.) birinde bulunabilir için standart bir çözüm olup olmadığını merak?

JDK 7 kullanıyorsanız , geçici dizini oluşturmak için yeni Files.createTempDirectory sınıfını kullanın.

Path tempDirWithPrefix = Files.createTempDirectory(prefix);

JDK 7'den önce bunu yapmalısınız:

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

İsterseniz daha iyi istisnalar (alt sınıf IOException) yapabilirsiniz.

Google Guava kütüphanesinde çok sayıda yardımcı program bulunmaktadır. Buradaki notlardan biri Files sınıfıdır . Aşağıdakiler de dahil olmak üzere bir dizi yararlı yöntem vardır:

File myTempDir = Files.createTempDir();

Bu, tam olarak istediğiniz şeyi tek bir satırda yapar. Buradaki belgeleri okursanız, önerilen uyarlamanın File.createTempFile("install", "dir")genellikle güvenlik açıkları getirdiğini görürsünüz .

Eğer test için geçici bir dizin gerekiyor ve, JUnit kullanıyorsanız @Ruleile birlikte TemporaryFolderçözer senin sorunun:

@Rule
public TemporaryFolder folder = new TemporaryFolder();

Gönderen belgeler :

TemporaryFolder Kuralı, sınama yöntemi tamamlandığında (geçip geçmediği) silinmesi garanti edilen dosya ve klasörlerin oluşturulmasına izin verir

Güncelleme:

JUnit Jupiter (sürüm 5.1.1 veya üstü) kullanıyorsanız, JUnit 5 Extension Pack olan JUnit Pioneer'ı kullanma seçeneğiniz vardır.

Proje belgelerinden kopyalandı :

Örneğin, aşağıdaki sınama, tek bir sınama yöntemi için uzantıyı kaydeder, bir dosya oluşturur ve geçici dizine yazar ve içeriğini denetler.

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

JavaDoc ve TempDirectory JavaDoc'unda daha fazla bilgi

Gradle:

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

Uzman:

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

Güncelleme 2:

@TempDir açıklama deneysel bir özellik olarak JUnit Jüpiter 5.4.0 serbest bırakmak için ilave edildi. JUnit 5 Kullanıcı Kılavuzundan kopyalanan örnek :

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

Bu sorunu çözmek için naif olarak yazılmış kod, buradaki cevapların bir kısmı da dahil olmak üzere yarış koşullarından muzdariptir. Tarihsel olarak yarış koşullarını dikkatlice düşünebilir ve kendiniz yazabilir veya Google'ın Guava'sı gibi bir üçüncü taraf kütüphanesi kullanabilirsiniz (Spina'nın cevabının önerdiği gibi) Veya buggy kodu yazabilirsiniz.

Ancak JDK 7'den itibaren iyi haberler var! Java standart kitaplığının kendisi artık bu soruna düzgün çalışan (açık olmayan) bir çözüm sunmaktadır. Java.nio.file.Files # createTempDirectory () öğesini istiyorsunuz . Gönderen belgeler :

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

Adını oluşturmak için verilen öneki kullanarak belirtilen dizinde yeni bir dizin oluşturur. Ortaya çıkan Yol, verilen dizine ait FileSystem ile ilişkilendirilir.

Dizin adının nasıl oluşturulduğuna ilişkin ayrıntılar uygulamaya bağlıdır ve bu nedenle belirtilmez. Mümkün olduğunda önek, aday adları oluşturmak için kullanılır.

Bu, böyle bir işlev isteyen Sun hata izleyicisindeki utanç verici eski hata raporunu etkili bir şekilde çözer .

Bu, Guava kütüphanesinin Files.createTempDir () kaynağının kaynak kodudur. Düşündüğünüz kadar karmaşık değil:

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

Varsayılan olarak:

private static final int TEMP_DIR_ATTEMPTS = 10000;

Buraya bakın

Daha deleteOnExit()sonra açıkça silseniz bile kullanmayın .

Google daha fazla bilgi için 'deleteonexit kötüdür' , ancak sorunun özü şudur:

1. deleteOnExit() sadece normal JVM kapatmaları için siler, çökme veya JVM işlemini öldürmez.

2. deleteOnExit() sadece JVM kapatıldığında silinir - uzun süre çalışan sunucu işlemleri için iyi değildir, çünkü

3. En kötüsü - deleteOnExit()her geçici dosya girişi için bellek tüketir. İşleminiz aylarca çalışıyorsa veya kısa sürede çok sayıda geçici dosya oluşturuyorsa, belleği tüketirsiniz ve JVM kapanana kadar asla serbest bırakmazsınız.

Java 1.7 itibariyle createTempDirectory(prefix, attrs)ve createTempDirectory(dir, prefix, attrs)içerdiğijava.nio.file.Files

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

Kendi kodum için yapmaya karar verdim:

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

Eh, "createTempFile" aslında dosyayı oluşturur. Öyleyse neden sadece onu silmiyorsunuz, sonra mkdir'i yapıyorsunuz?

Bu kod oldukça iyi çalışmalıdır:

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

Bu RFE ve yorumlarında tartışıldığı gibi , tempDir.delete()önce arayabilirsiniz . Ya da System.getProperty("java.io.tmpdir")orada bir dizin kullanabilir ve oluşturabilirsiniz. Her iki durumda da aramayı unutmamalısınız tempDir.deleteOnExit(), yoksa dosya işiniz bittikten sonra silinmez.

Sadece tamamlamak için, bu google guava kütüphanesinden kod. Benim kodum değil, ama burada bu iş parçacığında göstermek için değerli olduğunu düşünüyorum.

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

Aynı sorunu aldım, bu yüzden ilgilenenler için başka bir cevap ve yukarıdakilerden birine benzer:

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

Ve uygulamam için, çıkıştaki sıcaklığı temizlemek için bir seçenek eklemeye karar verdim, böylece bir kapatma kancasına ekledim:

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

Yöntem , çağrı silmeden (ki tamamen isteğe bağlıdır ve bu noktada özyineleme ile yapabilirsiniz) temp silmeden önce tüm alt dizinleri ve dosyaları silmek , ancak güvenli tarafta olmak istiyorum.

Diğer cevaplarda da görebileceğiniz gibi, standart bir yaklaşım ortaya çıkmamıştır. Dolayısıyla zaten Apache Commons i? Fileutils kullanarak aşağıdaki yaklaşım öneriyoruz söz 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;

}

Apache, istenen "standart" a en yakın gelen ve hem JDK 7 hem de daha eski sürümlerle çalışan kütüphaneyi paylaştığı için bu tercih edilir. Bu ayrıca "yeni" bir Yol örneği değil (arabellek tabanlı ve JDK7'nin getTemporaryDirectory () yönteminin sonucu olacaktır) değil, "eski" bir Dosya örneği (akış tabanlı) döndürür -> Bu nedenle çoğu insanın ne zaman ihtiyaç duyduğunu döndürür geçici bir dizin oluşturmak istiyorlar.

Benzersiz bir isim yaratma girişimlerini seviyorum, ancak bu çözüm bile bir yarış koşulunu dışlamaz. Test exists()ve if(newTempDir.mkdirs())yöntem çağırma işleminden sonra başka bir işlem kayabilir . İçinde gömülü olduğunu düşündüğüm yerel koda başvurmadan tamamen güvenli hale nasıl bir fikrim yok File.createTempFile().

Java 7'den önce şunları da yapabilirsiniz:

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

Bu küçük örneği deneyin:

Kod:

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

İthalat:
java.io.IOException
java.nio.file.Files
java.nio.file.Path

Windows makinesinde konsol çıkışı:
C: \ Users \ kullanıcıAdı \ AppData \ Local \ Temp \ tmpDir2908538301081367877

Yorum:
Files.createTempDirectory otomatik olarak benzersiz kimlik oluşturur - 2908538301081367877.

Not:
Dizinleri tekrar tekrar silmek için aşağıdakileri okuyun:
Java'da dizinleri tekrar tekrar silin

Dizini benzersiz bir ad oluşturmak için File#createTempFileve kullanarak deleteTamam görünüyor. ShutdownHookJVM kapatıldığında dizini (yinelemeli olarak) silmek için bir eklemeniz gerekir .