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 au jour le jour.

Dans ce didacticiel, nous explorerons certaines des classes d'utilitaires clés du module Commons IO et leurs fonctions les plus connues.

2. Dépendance de Maven

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

 commons-io commons-io 2.5 

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

3. Classes d'utilité

En termes simples, les classes utilitaires fournissent des ensembles de méthodes statiques qui peuvent être utilisées pour effectuer des tâches courantes sur des fichiers .

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.

Voyons comment lire ou copier des fichiers à l' aide de FileUtils :

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. Nom de fichierUtils

Cet utilitaire fournit une manière indépendante du système d'exploitation d'exécuter des fonctions courantes sur les noms de fichiers . 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 utiliser FileSystemUtils pour vérifier l'espace libre sur un volume ou un lecteur donné :

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

4. Entrée et sortie

Ce package fournit plusieurs implémentations pour travailler avec les flux d'entrée et de sortie .

Nous allons nous concentrer sur TeeInputStream et TeeOutputSteam . 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 pouvons écrire un seul flux d'entrée dans deux flux de sortie différents :

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. Filtres

Commons IO comprend une liste de filtres de fichiers utiles. Ceux-ci peuvent être utiles lorsqu'un développeur souhaite se limiter à une liste de fichiers spécifique souhaitée à partir d'une liste hétérogène de fichiers.

La bibliothèque prend également en charge les opérations logiques ET et OU 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 utilise WildcardFileFilter et SuffixFileFilter 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 utilisant ANDFileFilter :

@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 package Comparator fournit différents types de comparaisons sur des fichiers . Nous allons explorer deux comparateurs différents ici.

6.1. PathFileComparator

La classe PathFileComparator peut être utilisée pour trier des listes ou des tableaux de fichiers par leur chemin, de manière sensible à la casse, à la casse ou à la casse dépendante du système. 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 configuration IOCase.INSENSITIVE . PathFileComparator fournit également un certain nombre d' instances de singleton qui ont différentes options de sensibilité à la casse et de tri inverse .

Ces champs statiques incluent PATH_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é pour comparer les tailles (longueurs) de deux fichiers . 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 Commons IO offre la possibilité de suivre les modifications d'un fichier ou d'un répertoire . Voyons un exemple rapide de la façon dont FileAlterationMonitor peut être utilisé avec FileAlterationObserver et FileAlterationListener pour surveiller un fichier ou un dossier.

Lorsque FileAlterationMonitor démarre, nous commencerons à recevoir des notifications pour les modifications de fichiers sur le répertoire qui est 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 a couvert certains des composants couramment utilisés du package Commons IO. Cependant, le package est également livré avec de nombreuses autres fonctionnalités. Veuillez consulter la documentation de l'API pour plus de détails.

Le code utilisé dans cet exemple se trouve dans le projet GitHub.