Analyseurs Univocity

1. Introduction

Dans ce didacticiel, nous allons jeter un coup d'œil à Univocity Parsers, une bibliothèque pour analyser les fichiers CSV, TSV et à largeur fixe en Java.

Nous commencerons par les bases de la lecture et de l'écriture de fichiers avant de passer à la lecture et à l'écriture de fichiers vers et depuis les beans Java. Ensuite, nous examinerons rapidement les options de configuration avant de terminer.

2. Configuration

Pour utiliser les analyseurs, nous devons ajouter la dernière dépendance Maven à notre fichier pom.xml de projet :

 com.univocity univocity-parsers 2.8.4 

3. Utilisation de base

3.1. En train de lire

Dans Univocity, nous pouvons rapidement analyser un fichier entier en une collection de tableaux String qui représentent chaque ligne du fichier.

Tout d'abord, analysons un fichier CSV en fournissant un lecteur à notre fichier CSV dans un CsvParser avec les paramètres par défaut:

try (Reader inputReader = new InputStreamReader(new FileInputStream( new File("src/test/resources/productList.csv")), "UTF-8")) { CsvParser parser = new CsvParser(new CsvParserSettings()); List parsedRows = parser.parseAll(inputReader); return parsedRows; } catch (IOException e) { // handle exception }

Nous pouvons facilement basculer cette logique pour analyser un fichier TSV en passant à TsvParser et en lui fournissant un fichier TSV.

Le traitement d'un fichier à largeur fixe n'est que légèrement plus compliqué. La principale différence est que nous devons fournir nos largeurs de champ dans les paramètres de l'analyseur.

Lisons un fichier de largeur fixe en fournissant un objet FixedWidthFields à notre FixedWidthParserSettings :

try (Reader inputReader = new InputStreamReader(new FileInputStream( new File("src/test/resources/productList.txt")), "UTF-8")) { FixedWidthFields fieldLengths = new FixedWidthFields(8, 30, 10); FixedWidthParserSettings settings = new FixedWidthParserSettings(fieldLengths); FixedWidthParser parser = new FixedWidthParser(settings); List parsedRows = parser.parseAll(inputReader); return parsedRows; } catch (IOException e) { // handle exception }

3.2. L'écriture

Maintenant que nous avons couvert la lecture de fichiers avec les analyseurs, apprenons à les écrire.

L'écriture de fichiers est très similaire à leur lecture en ce sens que nous fournissons un Writer avec nos paramètres souhaités à l'analyseur qui correspond à notre type de fichier.

Créons une méthode pour écrire des fichiers dans les trois formats possibles:

public boolean writeData(List products, OutputType outputType, String outputPath) { try (Writer outputWriter = new OutputStreamWriter(new FileOutputStream(new File(outputPath)),"UTF-8")){ switch(outputType) { case CSV: CsvWriter writer = new CsvWriter(outputWriter, new CsvWriterSettings()); writer.writeRowsAndClose(products); break; case TSV: TsvWriter writer = new TsvWriter(outputWriter, new TsvWriterSettings()); writer.writeRowsAndClose(products); break; case FIXED_WIDTH: FixedWidthFields fieldLengths = new FixedWidthFields(8, 30, 10); FixedWidthWriterSettings settings = new FixedWidthWriterSettings(fieldLengths); FixedWidthWriter writer = new FixedWidthWriter(outputWriter, settings); writer.writeRowsAndClose(products); break; default: logger.warn("Invalid OutputType: " + outputType); return false; } return true; } catch (IOException e) { // handle exception } }

Comme pour la lecture de fichiers, l'écriture de fichiers CSV et de fichiers TSV est presque identique. Pour les fichiers à largeur fixe, nous devons fournir la largeur du champ à nos paramètres.

3.3. Utilisation des processeurs de lignes

Univocity fournit un certain nombre de processeurs de lignes que nous pouvons utiliser et nous permet également de créer les nôtres.

Pour avoir une idée de l'utilisation des processeurs de lignes, utilisons le BatchedColumnProcessor pour traiter un fichier CSV plus volumineux par lots de cinq lignes:

try (Reader inputReader = new InputStreamReader(new FileInputStream(new File(relativePath)), "UTF-8")) { CsvParserSettings settings = new CsvParserSettings(); settings.setProcessor(new BatchedColumnProcessor(5) { @Override public void batchProcessed(int rowsInThisBatch) {} }); CsvParser parser = new CsvParser(settings); List parsedRows = parser.parseAll(inputReader); return parsedRows; } catch (IOException e) { // handle exception }

Pour utiliser ce processeur de lignes, nous le définissons dans notre CsvParserSettings puis tout ce que nous avons à faire est d'appeler parseAll .

3.4. Lire et écrire dans des Java Beans

La liste des tableaux String est correcte, mais nous travaillons souvent avec des données dans des beans Java. Univocity permet également de lire et d'écrire dans des beans Java spécialement annotés.

Définissons un bean Product avec les annotations Univocity:

public class Product { @Parsed(field = "product_no") private String productNumber; @Parsed private String description; @Parsed(field = "unit_price") private float unitPrice; // getters and setters }

L'annotation principale est l' annotation @Parsed .

Si notre en-tête de colonne correspond au nom du champ, nous pouvons utiliser @Parsed sans aucune valeur spécifiée. Si notre en-tête de colonne diffère du nom de champ, nous pouvons spécifier l'en-tête de colonne à l'aide de la propriété field .

Maintenant que nous avons défini notre bean Product , lisons-y notre fichier CSV:

try (Reader inputReader = new InputStreamReader(new FileInputStream( new File("src/test/resources/productList.csv")), "UTF-8")) { BeanListProcessor rowProcessor = new BeanListProcessor(Product.class); CsvParserSettings settings = new CsvParserSettings(); settings.setHeaderExtractionEnabled(true); settings.setProcessor(rowProcessor); CsvParser parser = new CsvParser(settings); parser.parse(inputReader); return rowProcessor.getBeans(); } catch (IOException e) { // handle exception }

Nous avons d'abord construit un processeur de lignes spécial, BeanListProcessor, avec notre classe annotée. Ensuite, nous l'avons fourni au CsvParserSettings et l' avons utilisé pour lire une liste de produits .

Ensuite, écrivons notre liste de produits dans un fichier de largeur fixe:

try (Writer outputWriter = new OutputStreamWriter(new FileOutputStream(new File(outputPath)), "UTF-8")) { BeanWriterProcessor rowProcessor = new BeanWriterProcessor(Product.class); FixedWidthFields fieldLengths = new FixedWidthFields(8, 30, 10); FixedWidthWriterSettings settings = new FixedWidthWriterSettings(fieldLengths); settings.setHeaders("product_no", "description", "unit_price"); settings.setRowWriterProcessor(rowProcessor); FixedWidthWriter writer = new FixedWidthWriter(outputWriter, settings); writer.writeHeaders(); for (Product product : products) { writer.processRecord(product); } writer.close(); return true; } catch (IOException e) { // handle exception }

La différence notable est que nous spécifions nos en-têtes de colonne dans nos paramètres.

4. Paramètres

Univocity a un certain nombre de paramètres que nous pouvons appliquer aux analyseurs. Comme nous l'avons vu précédemment, nous pouvons utiliser des paramètres pour appliquer un processeur de lignes aux analyseurs.

Il existe de nombreux autres paramètres qui peuvent être modifiés pour répondre à nos besoins. Bien que de nombreuses configurations soient communes aux trois types de fichiers, chaque analyseur possède également des paramètres spécifiques au format.

Ajustez nos paramètres d'analyse CSV pour mettre des limites sur les données que nous lisons:

CsvParserSettings settings = new CsvParserSettings(); settings.setMaxCharsPerColumn(100); settings.setMaxColumns(50); CsvParser parser = new CsvParser(new CsvParserSettings());

5. Conclusion

Dans ce rapide tutoriel, nous avons appris les bases de l'analyse des fichiers à l'aide de la bibliothèque Univocity.

Nous avons appris à lire et à écrire des fichiers dans des listes de tableaux de chaînes et de beans Java. Avant, nous nous sommes lancés dans les beans Java, nous avons examiné rapidement l'utilisation de différents processeurs de lignes. Enfin, nous avons brièvement abordé la manière de personnaliser les paramètres.

Comme toujours, le code source est disponible à l'adresse over sur GitHub.