Conversion de JSON en CSV en Java

1. Introduction

Dans ce court didacticiel, nous verrons comment utiliser Jackson pour convertir JSON en CSV et vice versa.

Il existe des bibliothèques alternatives disponibles, comme la classe CDL de org.json, mais nous allons nous concentrer uniquement sur la bibliothèque Jackson ici.

Après avoir examiné notre exemple de structure de données, nous utiliserons une combinaison d' ObjectMapper et de CSVMapper pour convertir entre JSON et CSV.

2. Dépendances

Ajoutons la dépendance pour le formateur de données Jackson CSV:

 com.fasterxml.jackson.dataformat jackson-dataformat-csv 2.11.1 

Nous pouvons toujours trouver la version la plus récente de cette dépendance sur Maven Central.

Nous ajouterons également la dépendance pour la base de données Jackson principale:

 com.fasterxml.jackson.core jackson-databind 2.11.1 

Encore une fois, nous pouvons trouver la version la plus récente de cette dépendance sur Maven Central.

3. Structure des données

Avant de reformater un document JSON en CSV, nous devons examiner dans quelle mesure notre modèle de données mappera entre les deux formats.

Alors tout d'abord, considérons quelles données les différents formats prennent en charge:

  • Nous utilisons JSON pour représenter une variété de structures d'objets, y compris celles qui contiennent des tableaux et des objets imbriqués
  • Nous utilisons CSV pour représenter les données d'une liste d'objets, chaque objet de la liste apparaissant sur une nouvelle ligne

Cela signifie que si notre document JSON a un tableau d'objets, nous pouvons reformater chaque objet dans une nouvelle ligne de notre fichier CSV. Donc, à titre d'exemple, utilisons un document JSON contenant la liste suivante des éléments d'une commande:

[ { "item" : "No. 9 Sprockets", "quantity" : 12, "unitPrice" : 1.23 }, { "item" : "Widget (10mm)", "quantity" : 4, "unitPrice" : 3.45 } ]

Nous utiliserons les noms de champ du document JSON comme en-têtes de colonne et le reformaterons dans le fichier CSV suivant:

item,quantity,unitPrice "No. 9 Sprockets",12,1.23 "Widget (10mm)",4,3.45

4. Lire JSON et écrire CSV

Tout d'abord, nous utilisons l' ObjectMapper de Jackson pour lire notre exemple de document JSON dans une arborescence d' objets JsonNode :

JsonNode jsonTree = new ObjectMapper().readTree(new File("src/main/resources/orderLines.json"));

Ensuite, créons un CsvSchema . Cela détermine les en-têtes de colonne, les types et la séquence des colonnes dans le fichier CSV. Pour ce faire, nous créons un CsvSchema Builder et définissons les en-têtes de colonne pour qu'ils correspondent aux noms de champ JSON:

Builder csvSchemaBuilder = CsvSchema.builder(); JsonNode firstObject = jsonTree.elements().next(); firstObject.fieldNames().forEachRemaining(fieldName -> {csvSchemaBuilder.addColumn(fieldName);} ); CsvSchema csvSchema = csvSchemaBuilder.build().withHeader();

Ensuite, nous créons un CsvMapper avec notre CsvSchema , et enfin, nous écrivons le jsonTree dans notre fichier CSV :

CsvMapper csvMapper = new CsvMapper(); csvMapper.writerFor(JsonNode.class) .with(csvSchema) .writeValue(new File("src/main/resources/orderLines.csv"), jsonTree);

Lorsque nous exécutons cet exemple de code, notre exemple de document JSON est converti en fichier CSV attendu.

5. Lire CSV et écrire JSON

Maintenant, utilisons le CsvMapper de Jackson pour lire notre fichier CSV dans une liste d' objets OrderLine . Pour ce faire, nous créons d'abord la classe OrderLine sous la forme d'un simple POJO:

public class OrderLine { private String item; private int quantity; private BigDecimal unitPrice; // Constructors, Getters, Setters and toString }

Nous utiliserons les en-têtes de colonne dans le fichier CSV pour définir notre CsvSchema . Ensuite, nous utilisons le CsvMapper pour lire les données du CSV dans un MappingIterator d' objets OrderLine :

CsvSchema orderLineSchema = CsvSchema.emptySchema().withHeader(); CsvMapper csvMapper = new CsvMapper(); MappingIterator orderLines = csvMapper.readerFor(OrderLine.class) .with(orderLineSchema) .readValues(new File("src/main/resources/orderLines.csv"));

Ensuite, nous utiliserons MappingIterator pour obtenir une liste d' objets OrderLine . Ensuite, nous utilisons l' ObjectMapper de Jackson pour écrire la liste sous forme de document JSON:

new ObjectMapper() .configure(SerializationFeature.INDENT_OUTPUT, true) .writeValue(new File("src/main/resources/orderLinesFromCsv.json"), orderLines.readAll());

When we run this sample code, our example CSV file is converted to the expected JSON document.

6. Configuring the CSV File Format

Let's use some of Jackson's annotations to adjust the format of the CSV file. We'll change the ‘item' column heading to ‘name', the ‘quantity' column heading to ‘count', remove the ‘unitPrice' column, and make ‘count' the first column.

So, our expected CSV file becomes:

count,name 12,"No. 9 Sprockets" 4,"Widget (10mm)"

We'll create a new abstract class to define the required format for the CSV file:

@JsonPropertyOrder({ "count", "name" }) public abstract class OrderLineForCsv { @JsonProperty("name") private String item; @JsonProperty("count") private int quantity; @JsonIgnore private BigDecimal unitPrice; }

Then, we use our OrderLineForCsv class to create a CsvSchema:

CsvMapper csvMapper = new CsvMapper(); CsvSchema csvSchema = csvMapper .schemaFor(OrderLineForCsv.class) .withHeader(); 

Nous utilisons également OrderLineForCsv comme Jackson Mixin. Cela indique à Jackson d'utiliser les annotations que nous avons ajoutées à la classe OrderLineForCsv lorsqu'il traite un objet OrderLine :

csvMapper.addMixIn(OrderLine.class, OrderLineForCsv.class); 

Enfin, nous utilisons un ObjectMapper pour lire notre document JSON dans un tableau OrderLine , et utilisons notre csvMapper pour écrire le this dans un fichier CSV:

OrderLine[] orderLines = new ObjectMapper() .readValue(new File("src/main/resources/orderLines.json"), OrderLine[].class); csvMapper.writerFor(OrderLine[].class) .with(csvSchema) .writeValue(new File("src/main/resources/orderLinesReformated.csv"), orderLines); 

Lorsque nous exécutons cet exemple de code, notre exemple de document JSON est converti en fichier CSV attendu.

7. Conclusion

Dans ce rapide didacticiel, nous avons appris à lire et à écrire des fichiers CSV à l'aide de la bibliothèque de formats de données Jackson. Nous avons également examiné quelques options de configuration qui nous aident à obtenir nos données comme nous le souhaitons.

Comme toujours, le code peut être trouvé sur GitHub.