Introduction à OpenCSV

1. Introduction

Cet article rapide présente OpenCSV 4, une bibliothèque fantastique pour l'écriture, la lecture, la sérialisation, la désérialisation et / ou l'analyse des fichiers .csv ! Ci-dessous, nous allons passer en revue plusieurs exemples montrant comment configurer et utiliser OpenCSV 4 pour vos efforts.

2. Configuration

Voici comment ajouter OpenCSV à votre projet via une dépendance pom.xml :

 com.opencsv opencsv 4.1  

Le .jars pour OpenCSV peut être trouvé sur le site officiel ou via une recherche rapide sur le référentiel Maven.

Notre fichier .csv sera vraiment simple, nous le garderons à deux colonnes et quatre lignes:

colA, ColB A, B C, D G, G G, F

3. Bean ou ne pas haricot

Après avoir ajouté OpenCSV à votre pom.xml , nous pouvons implémenter des méthodes de gestion CSV de deux manières pratiques:

  1. en utilisant les objets pratiques CSVReader et CSVWriter (pour des opérations plus simples) ou
  2. en utilisant CsvToBean pour convertir des fichiers .csv en beans (qui sont implémentés comme des objets plain-old-java annotés ).

Nous nous en tiendrons aux exemples synchrones (ou bloquants ) pour cet article afin que nous puissions nous concentrer sur les bases.

N'oubliez pas qu'une méthode synchrone empêchera le code environnant ou ultérieur de s'exécuter jusqu'à ce que ce soit terminé. Tout environnement de production utilisera probablement des méthodes asynchrones ou ( non bloquantes ) qui permettront à d'autres processus ou méthodes de se terminer pendant que la méthode asynchrone se termine.

Nous plongerons dans des exemples asynchrones pour OpenCSV dans un prochain article.

3.1. Le CSVReader

CSVReader - via les méthodes readAll () et readNext () fournies ! Voyons comment utiliser readAll () de manière synchrone:

public List readAll(Reader reader) throws Exception { CSVReader csvReader = new CSVReader(reader); List list = new ArrayList(); list = csvReader.readAll(); reader.close(); csvReader.close(); return list; }

Ensuite, nous pouvons appeler cette méthode en passant un BufferedReader :

public String readAllExample() throws Exception { Reader reader = Files.newBufferedReader(Paths.get( ClassLoader.getSystemResource("csv/twoColumn.csv").toURI())); return CsvReaderExamples.readAll(reader).toString(); }

De même, nous pouvons abstraire readNext () qui lit un .csv fourni ligne par ligne:

public List oneByOne(Reader reader) throws Exception { List list = new ArrayList(); CSVReader csvReader = new CSVReader(reader); String[] line; while ((line = csvReader.readNext()) != null) { list.add(line); } reader.close(); csvReader.close(); return list; }

Et nous pouvons appeler cette méthode ici en passant un BufferReader:

public String oneByOneExample() throws Exception { Reader reader = Files.newBufferedReader(Paths.get( ClassLoader.getSystemResource("csv/twoColumn.csv").toURI())); return CsvReaderExamples.oneByOne(reader).toString(); } 

Pour une plus grande flexibilité et des options de configuration, vous pouvez également utiliser CSVReaderBuilder :

CSVParser parser = new CSVParserBuilder() .withSeparator(',') .withIgnoreQuotations(true) .build(); CSVReader csvReader = new CSVReaderBuilder(reader) .withSkipLines(0) .withCSVParser(parser) .build();

CSVReaderBuilder permet d'ignorer les en-têtes de colonne et de définir des règles d'analyse via CSVParserBuilder .

À l'aide de CSVParserBuilder , nous pouvons choisir un séparateur de colonne personnalisé, ignorer ou gérer les guillemets, indiquer comment nous allons gérer les champs nuls et comment interpréter les caractères d'échappement. Pour plus d'informations sur ces paramètres de configuration, veuillez consulter les documents de spécifications officiels.

Comme toujours, n'oubliez pas de fermer tous vos lecteurs pour éviter les fuites de mémoire!

3.2. Le CSVWriter

CSVWriter offre également la possibilité d'écrire dans un fichier .csv en une seule fois ou ligne par ligne.

Voyons comment écrire dans un .csv ligne par ligne:

public String csvWriterOneByOne(List stringArray, Path path) throws Exception { CSVWriter writer = new CSVWriter(new FileWriter(path.toString())); for (String[] array : stringArray) { writer.writeNext(array); } writer.close(); return Helpers.readFile(path); } 

Maintenant, spécifions où nous voulons enregistrer ce fichier et appelons la méthode que nous venons d'écrire:

public String csvWriterOneByOne() throws Exception{ Path path = Paths.get( ClassLoader.getSystemResource("csv/writtenOneByOne.csv").toURI()); return CsvWriterExamples.csvWriterOneByOne(Helpers.fourColumnCsvString(), path); }

Nous pouvons également écrire notre .csv en une seule fois en passant une liste de tableaux de chaînes représentant les lignes de notre .csv . :

public String csvWriterAll(List stringArray, Path path) throws Exception { CSVWriter writer = new CSVWriter(new FileWriter(path.toString())); writer.writeAll(stringArray); writer.close(); return Helpers.readFile(path); }

Et voici comment nous l'appelons:

public String csvWriterAll() throws Exception { Path path = Paths.get( ClassLoader.getSystemResource("csv/writtenAll.csv").toURI()); return CsvWriterExamples.csvWriterAll(Helpers.fourColumnCsvString(), path); }

C'est ça!

3.3. Lecture basée sur les haricots

OpenCSV est capable de sérialiser des fichiers .csv dans des schémas prédéfinis et réutilisables implémentés en tant que beans pojo Java annotés . CsvToBean est construit à l'aide de CsvToBeanBuilder . Depuis OpenCSV 4, CsvToBeanBuilder est la méthode recommandée pour travailler avec com.opencsv.bean.CsvToBean.

Voici un bean simple que nous pouvons utiliser pour sérialiser notre .csv à deux colonnes de la section 2 .:

public class SimplePositionBean { @CsvBindByPosition(position = 0) private String exampleColOne; @CsvBindByPosition(position = 1) private String exampleColTwo; // getters and setters } 

Chaque colonne du fichier .csv est associée à un champ du bean. Les mappages entre les en- têtes de colonne .csv peuvent être effectués à l'aide des annotations @CsvBindByPosition ou @CsvBindByName qui spécifient un mappage par correspondance de position ou de chaîne d'en-tête, respectivement.

Tout d'abord, créons une superclasse appelée CsvBean - cela nous permettra de réutiliser et de généraliser les méthodes que nous allons construire ci-dessous:

public class CsvBean { }

Un exemple de classe enfant:

public class NamedColumnBean extends CsvBean { @CsvBindByName(column = "name") private String name; @CsvBindByName private int age; // getters and setters }

Abstraits une liste renvoyée de manière synchrone à l'aide du CsvToBean :

 public List beanBuilderExample(Path path, Class clazz) throws Exception { CsvTransfer csvTransfer = new CsvTransfer(); ColumnPositionMappingStrategy ms = new ColumnPositionMappingStrategy(); ms.setType(clazz); Reader reader = Files.newBufferedReader(path); CsvToBean cb = new CsvToBeanBuilder(reader) .withType(clazz) .withMappingStrategy(ms) .build(); csvTransfer.setCsvList(cb.parse()); reader.close(); return csvTransfer.getCsvList(); }

We pass in our bean (clazz) and set that as the ColumnPositionMappingStrategy. In doing so, we associate the fields of our beans with the respective columns of our .csv rows.

We can call that here using the SimplePositionBean subclass of the CsvBean we wrote above:

public String simplePositionBeanExample() throws Exception { Path path = Paths.get( ClassLoader.getSystemResource("csv/twoColumn.csv").toURI()); return BeanExamples.beanBuilderExample(path, SimplePositionBean.class).toString(); }

or here using the NamedColumnBean – another subclass of the CsvBean:

public String namedColumnBeanExample() throws Exception { Path path = Paths.get( ClassLoader.getSystemResource("csv/namedColumn.csv").toURI()); return BeanExamples.beanBuilderExample(path, NamedColumnBean.class).toString(); }

3.4. Bean-Based Writing

Lastly, let's take a look at how to use the StatefulBeanToCsv class to write to a .csv file:

public String writeCsvFromBean(Path path) throws Exception { Writer writer = new FileWriter(path.toString()); StatefulBeanToCsv sbc = new StatefulBeanToCsvBuilder(writer) .withSeparator(CSVWriter.DEFAULT_SEPARATOR) .build(); List list = new ArrayList(); list.add(new WriteExampleBean("Test1", "sfdsf", "fdfd")); list.add(new WriteExampleBean("Test2", "ipso", "facto")); sbc.write(list); writer.close(); return Helpers.readFile(path); }

Here, we are specifying how we will delimit our data which is supplied as a List of specified CsvBean objects.

Nous pouvons alors appeler notre méthode writeCsvFromBean () après avoir passé le chemin du fichier de sortie souhaité:

public String writeCsvFromBeanExample() { Path path = Paths.get( ClassLoader.getSystemResource("csv/writtenBean.csv").toURI()); return BeanExamples.writeCsvFromBean(path); }

4. Conclusion

Nous y voilà - des exemples de code synchrone pour OpenCSV utilisant des beans, CSVReader et CSVWriter . Consultez les documents officiels ici.

Comme toujours, les exemples de code sont fournis sur GitHub.