TOC

Apache Commons IO

Apache Commons IO

1. Vue d'ensemble

Le projet Apache Commons a été créé pour fournir aux développeurs un ensemble de bibliothèques communes qu'ils peuvent utiliser dans leur code quotidien.

Dans ce didacticiel, nous allons explorer certaines des principales classes d’utilité du module Commons IO et leurs fonctions les plus connues.

2. Dépendance Maven

Pour utiliser la bibliothèque, incluons la dépendance Maven suivante dans lespom.xml: 


    commons-io
    commons-io
    2.5

Les dernières versions de la bibliothèque se trouvent dansMaven Central.

3. Classes utilitaires

En termes simples, les classes utilitaires fournissent des ensembles de méthodes statiques qui peuvent être utilisées pourperform common tasks on files.

3.1. FileUtils

Cette classe fournit différentes opérations sur les fichiers, telles que l'ouverture, la lecture, la copie et le déplacement.

Regardonshow to read or copy files en utilisantFileUtils: 

File file = FileUtils.getFile(getClass().getClassLoader()
  .getResource("fileTest.txt")
  .getPath());
File tempDir = FileUtils.getTempDirectory();
FileUtils.copyFileToDirectory(file, tempDir);
File newTempFile = FileUtils.getFile(tempDir, file.getName());
String data = FileUtils.readFileToString(newTempFile,
  Charset.defaultCharset());

3.2. FilenameUtils

Cet utilitaire fournit unoperating-system-agnostic way of executing common functions on file names. Voyons quelques-unes des différentes méthodes que nous pouvons utiliser: 

String fullPath = FilenameUtils.getFullPath(path);
String extension = FilenameUtils.getExtension(path);
String baseName = FilenameUtils.getBaseName(path);

3.3. FileSystemUtils

Nous pouvons utiliserFileSystemUtils àcheck the free space on a given volume or drive: 

long freeSpace = FileSystemUtils.freeSpaceKb("/");

4. Entrée et sortie

Ce paquet fournit plusieurs implémentations pourworking with input and output streams.

Nous allons nous concentrer surTeeInputStream etTeeOutputSteam. Le mot «Tee» (dérivé de la lettre «T») est normalement utilisé pour décrire qu'une seule entrée doit être divisée en deux sorties différentes.

Regardons un exemple qui montre comment nous pouvonswrite a single input stream to two different output streams: 

String str = "Hello World.";
ByteArrayInputStream inputStream = new ByteArrayInputStream(str.getBytes());
ByteArrayOutputStream outputStream1 = new ByteArrayOutputStream();
ByteArrayOutputStream outputStream2 = new ByteArrayOutputStream();

FilterOutputStream teeOutputStream
  = new TeeOutputStream(outputStream1, outputStream2);
new TeeInputStream(inputStream, teeOutputStream, true)
  .read(new byte[str.length()]);

assertEquals(str, String.valueOf(outputStream1));
assertEquals(str, String.valueOf(outputStream2));

5. Les filtres

Commons IO inclut une liste de filtres de fichiers utiles. Celles-ci peuvent être utiles lorsqu'un développeur souhaitenarrow down to a specific desired list of files à partir d'une liste hétérogène de fichiers.

La bibliothèque prend également en charge les opérations logiquesAND etOR sur une liste de fichiers donnée. Par conséquent, nous pouvons mélanger et assortir ces filtres pour obtenir le résultat souhaité.

Voyons un exemple qui utiliseWildcardFileFilter etSuffixFileFilter pour récupérer des fichiers qui ont «ple» dans leurs noms avec un suffixe «txt». Notez que nous enveloppons les filtres ci-dessus en utilisantANDFileFilter: 

@Test
public void whenGetFilewith_ANDFileFilter_thenFind_sample_txt()
  throws IOException {

    String path = getClass().getClassLoader()
      .getResource("fileTest.txt")
      .getPath();
    File dir = FileUtils.getFile(FilenameUtils.getFullPath(path));

    assertEquals("sample.txt",
      dir.list(new AndFileFilter(
        new WildcardFileFilter("*ple*", IOCase.INSENSITIVE),
        new SuffixFileFilter("txt")))[0]);
}

6. Comparateurs

Le packageComparator fournitdifferent types of comparisons on files. Nous allons explorer deux comparateurs différents ici.

6.1. PathFileComparator

La classePathFileComparator peut être utilisée pour lessort lists or arrays of files by their path de manière sensible à la casse, à la casse ou à la casse. Voyons comment trier les chemins de fichiers dans le répertoire des ressources à l'aide de cet utilitaire: 

@Test
public void whenSortDirWithPathFileComparator_thenFirstFile_aaatxt()
  throws IOException {

    PathFileComparator pathFileComparator = new PathFileComparator(
      IOCase.INSENSITIVE);
    String path = FilenameUtils.getFullPath(getClass()
      .getClassLoader()
      .getResource("fileTest.txt")
      .getPath());
    File dir = new File(path);
    File[] files = dir.listFiles();

    pathFileComparator.sort(files);

    assertEquals("aaa.txt", files[0].getName());
}

Notez que nous avons utilisé la configurationIOCase.INSENSITIVE. PathFileComparator fournit également un certain nombre desingleton instances that have different case-sensitivity and reverse-sorting options.

Ces champs statiques incluentPATH_COMPARATOR, PATH_INSENSITIVE_COMPARATOR, PATH_INSENSITIVE_REVERSE, PATH_SYSTEM_COMPARATOR, pour n'en nommer que quelques-uns.

6.2. SizeFileComparator

SizeFileComparator est, comme son nom l'indique, utilisé pourcompare the sizes (lengths) of two files. Il renvoie une valeur entière négative si la taille du premier fichier est inférieure à celle du deuxième fichier. Il renvoie zéro si les tailles de fichier sont égales et une valeur positive si la taille du premier fichier est supérieure à la taille du second fichier.

Écrivons un test unitaire démontrant une comparaison des tailles de fichiers: 

@Test
public void whenSizeFileComparator_thenLargerFile_large()
  throws IOException {

    SizeFileComparator sizeFileComparator = new SizeFileComparator();
    File largerFile = FileUtils.getFile(getClass().getClassLoader()
      .getResource("fileTest.txt")
      .getPath());
    File smallerFile = FileUtils.getFile(getClass().getClassLoader()
      .getResource("sample.txt")
      .getPath());

    int i = sizeFileComparator.compare(largerFile, smallerFile);

    Assert.assertTrue(i > 0);
}

7. Moniteur de fichiers

Le package de moniteur d'E / S Commons fournit la capacité àtrack changes to a file or directory. Voyons un exemple rapide de la façon dontFileAlterationMonitor peut être utilisé avecFileAlterationObserver etFileAlterationListener pour surveiller un fichier ou un dossier.

Au démarrage deFileAlterationMonitor, nous commencerons à recevoir des notifications pour les modifications de fichiers sur le répertoire surveillé: 

FileAlterationObserver observer = new FileAlterationObserver(folder);
FileAlterationMonitor monitor = new FileAlterationMonitor(5000);

FileAlterationListener fal = new FileAlterationListenerAdaptor() {

    @Override
    public void onFileCreate(File file) {
        // on create action
    }

    @Override
    public void onFileDelete(File file) {
        // on delete action
    }
};

observer.addListener(fal);
monitor.addObserver(observer);
monitor.start();

8. Conclusion

Cet article couvrait certains des composants couramment utilisés du paquet IO Commons. Cependant, le paquet vient également avec beaucoup d'autres possibilités. Veuillez vous référer àAPI documentation pour plus de détails.

Le code utilisé dans cet exemple se trouve dans lesGitHub project.

Related