Introduzione a OpenCSV

1. Introduzione

Questo rapido articolo introduce OpenCSV 4, una fantastica libreria per scrivere, leggere, serializzare, deserializzare e / o analizzare i file .csv ! Di seguito, esamineremo diversi esempi che dimostrano come configurare e utilizzare OpenCSV 4 per i tuoi sforzi.

2. Configurazione

Ecco come aggiungere OpenCSV al tuo progetto tramite una dipendenza pom.xml :

 com.opencsv opencsv 4.1  

I file .jars per OpenCSV possono essere trovati sul sito ufficiale o tramite una rapida ricerca su Maven Repository.

Il nostro file .csv sarà davvero semplice, lo manterremo su due colonne e quattro righe:

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

3. Fagiolo o non fagiolo

Dopo aver aggiunto OpenCSV al tuo pom.xml , possiamo implementare metodi di gestione CSV in due modi convenienti:

  1. utilizzando i pratici oggetti CSVReader e CSVWriter (per operazioni più semplici) o
  2. utilizzando CsvToBean per convertire i file .csv in bean (che sono implementati come oggetti java normali e annotati ).

Ci atteneremo agli esempi sincroni (o bloccanti ) per questo articolo in modo che possiamo concentrarci sulle basi.

Ricorda, un metodo sincrono impedirà l'esecuzione del codice circostante o successivo fino al termine. Qualsiasi ambiente di produzione utilizzerà probabilmente metodi asincroni o ( non bloccanti ) che consentiranno il completamento di altri processi o metodi mentre il metodo asincrono finisce.

Ci immergeremo in esempi asincroni per OpenCSV in un prossimo articolo.

3.1. Il CSVReader

CSVReader - attraverso i metodi readAll () e readNext () forniti ! Diamo un'occhiata a come utilizzare readAll () in modo sincrono:

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

Quindi possiamo chiamare quel metodo passando un BufferedReader :

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

Allo stesso modo, possiamo astrarre readNext () che legge un file .csv fornito riga per riga:

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

E possiamo chiamare quel metodo qui passando un BufferReader:

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

Per una maggiore flessibilità e opzioni di configurazione puoi in alternativa utilizzare CSVReaderBuilder :

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

CSVReaderBuilder consente di saltare le intestazioni delle colonne e impostare le regole di analisi tramite CSVParserBuilder .

Utilizzando CSVParserBuilder , possiamo scegliere un separatore di colonna personalizzato, ignorare o gestire le virgolette, indicare come gestiremo i campi nulli e come interpretare i caratteri di escape. Per ulteriori informazioni su queste impostazioni di configurazione, fare riferimento ai documenti ufficiali delle specifiche.

Come sempre, ricordati di chiudere tutti i tuoi lettori per evitare perdite di memoria!

3.2. Il CSVWriter

CSVWriter fornisce allo stesso modo la possibilità di scrivere in un file .csv tutto in una volta o riga per riga.

Diamo un'occhiata a come scrivere in un file .csv riga per riga:

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

Ora, specifichiamo dove vogliamo salvare quel file e chiamiamo il metodo che abbiamo appena scritto:

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

Possiamo anche scrivere il nostro .csv tutto in una volta passando un elenco di array di stringhe che rappresentano le righe del nostro .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); }

Ed ecco come lo chiamiamo:

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

Questo è tutto!

3.3. Lettura basata su fagioli

OpenCSV è in grado di serializzare i file .csv in schemi preimpostati e riutilizzabili implementati come bean pojo Java annotati . CsvToBean viene costruito utilizzando CsvToBeanBuilder . A partire da OpenCSV 4, CsvToBeanBuilder è il modo consigliato per lavorare con com.opencsv.bean.CsvToBean.

Ecco un semplice bean che possiamo usare per serializzare il nostro .csv a due colonne dalla sezione 2 .:

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

Ogni colonna nel file .csv è associata a un campo nel bean. Le mappature tra le intestazioni di colonna .csv possono essere eseguite utilizzando le annotazioni @CsvBindByPosition o @CsvBindByName che specificano rispettivamente una mappatura in base alla posizione o alla corrispondenza della stringa di intestazione.

Per prima cosa, creiamo una superclasse chiamata CsvBean: questo ci permetterà di riutilizzare e generalizzare i metodi che costruiremo di seguito:

public class CsvBean { }

Un esempio di classe figlio:

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

Astraggiamo un elenco restituito in modo sincrono utilizzando 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.

Possiamo quindi chiamare il nostro metodo writeCsvFromBean () dopo aver passato il percorso del file di output desiderato:

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

4. Conclusione

Ecco fatto: esempi di codice sincrono per OpenCSV che utilizzano bean, CSVReader e CSVWriter . Dai un'occhiata ai documenti ufficiali qui.

Come sempre, gli esempi di codice vengono forniti su GitHub.