Comment lire un fichier JSON à partir d'un chemin relatif en Java

JavaBeginner
Pratiquer maintenant

Introduction

Dans le développement Java moderne, la gestion du JSON (JavaScript Object Notation) est une compétence fondamentale. Le JSON est le standard de facto pour l'échange de données dans les applications web et les API, grâce à son format lisible par l'homme et à sa facilité d'analyse par les machines.

Ce tutoriel fournit un guide complet pour lire et analyser des fichiers JSON à partir d'un chemin relatif dans vos applications Java. Vous apprendrez comment configurer un projet Maven avec les dépendances nécessaires, créer et structurer un fichier JSON, le lire à partir d'un chemin relatif et analyser son contenu, y compris des données imbriquées complexes.

À la fin de ce laboratoire, vous maîtriserez la gestion des données JSON au sein de vos projets Java, une compétence essentielle pour tout développeur travaillant avec des services web, des API ou des fichiers de configuration.

Configuration du Projet et Création du Fichier JSON

Avant de pouvoir lire un fichier JSON, nous devons configurer notre environnement de projet et créer le fichier lui-même. Ce laboratoire utilise Apache Maven pour gérer les dépendances du projet. La configuration initiale a déjà créé une structure de projet Maven standard pour vous.

Comprendre la Structure du Projet

Dans l'explorateur de fichiers du WebIDE à gauche, vous verrez la structure suivante à l'intérieur du répertoire ~/project :

  • pom.xml : Le fichier Project Object Model (POM) pour Maven. Il définit les dépendances et les configurations de build du projet.
  • src/main/java : Le répertoire pour votre code source Java.
  • src/main/resources : Le répertoire pour les fichiers de ressources, tels que les fichiers de configuration ou de données.

Le fichier pom.xml a été pré-configuré pour inclure la bibliothèque org.json, un choix populaire pour travailler avec JSON en Java.

Création du Fichier de Données JSON

Maintenant, créons le fichier JSON que nous allons lire dans les étapes suivantes.

  1. Dans l'explorateur de fichiers du WebIDE, naviguez vers le répertoire src/main/resources.
  2. Faites un clic droit sur le dossier resources et sélectionnez "New File".
  3. Nommez le fichier data.json.
  4. Ouvrez le fichier data.json nouvellement créé et ajoutez le contenu suivant :
{
  "name": "John Doe",
  "age": 28,
  "email": "john.doe@example.com",
  "isEmployed": true,
  "address": {
    "street": "123 Main St",
    "city": "Anytown"
  },
  "skills": ["Java", "SQL", "JavaScript"]
}

Ce fichier JSON représente le profil d'un utilisateur. Il contient des paires clé-valeur simples (comme "name": "John Doe"), un objet imbriqué (address) et un tableau de chaînes de caractères (skills). Enregistrez le fichier après avoir collé le contenu.

Vous avez maintenant configuré avec succès le projet et créé le fichier de données JSON. Dans la prochaine étape, nous écrirons du code Java pour lire et analyser ce fichier.

Lecture et Analyse d'un Fichier JSON Simple

Avec notre fichier JSON en place, nous pouvons maintenant écrire un programme Java pour le lire. Nous utiliserons un chemin relatif, ce qui est une pratique courante pour garantir la portabilité de l'application dans différents environnements.

Comprendre les Chemins Relatifs

Un chemin relatif est spécifié à partir du répertoire de travail actuel. Lors de l'exécution d'un projet Maven depuis le terminal, le répertoire de travail est généralement le dossier racine du projet, qui est ~/project dans notre cas. Par conséquent, le chemin relatif vers notre fichier JSON est src/main/resources/data.json.

Création du Lecteur JSON Java

Créons une classe Java pour lire le fichier.

  1. Dans l'explorateur de fichiers du WebIDE, naviguez vers src/main/java/com/labex.
  2. Faites un clic droit sur le dossier com/labex et sélectionnez "New File".
  3. Nommez le fichier JsonReader.java.
  4. Ouvrez le fichier et ajoutez le code Java suivant :
package com.labex;

import org.json.JSONObject;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class JsonReader {
    public static void main(String[] args) {
        try {
            // Define the relative path to the JSON file
            String filePath = "src/main/resources/data.json";
            System.out.println("Reading file from: " + filePath);

            // Read the file content into a string
            String content = new String(Files.readAllBytes(Paths.get(filePath)));

            // Create a JSONObject from the string content
            JSONObject jsonObject = new JSONObject(content);

            // Access and print the values of simple keys
            String name = jsonObject.getString("name");
            int age = jsonObject.getInt("age");
            boolean isEmployed = jsonObject.getBoolean("isEmployed");

            System.out.println("\n--- Parsed JSON Data ---");
            System.out.println("Name: " + name);
            System.out.println("Age: " + age);
            System.out.println("Is Employed: " + isEmployed);

        } catch (IOException e) {
            System.out.println("Error reading file: " + e.getMessage());
        } catch (Exception e) {
            System.out.println("Error parsing JSON: " + e.getMessage());
        }
    }
}

Explication du Code

  • package com.labex; : Déclare que cette classe appartient au package com.labex, conformément aux conventions Java standard.
  • String filePath = "src/main/resources/data.json"; : Définit le chemin relatif vers notre fichier.
  • Files.readAllBytes(Paths.get(filePath)) : Lit le contenu entier du fichier dans un tableau d'octets, qui est ensuite converti en une String.
  • new JSONObject(content) : Analyse la chaîne contenant les données JSON en un JSONObject.
  • jsonObject.getString("name") : Récupère la valeur de type chaîne associée à la clé "name". Des méthodes similaires comme getInt() et getBoolean() sont utilisées pour d'autres types de données.

Compilation et Exécution du Programme

Maintenant, compilons et exécutons notre code à l'aide de Maven.

  1. Ouvrez le terminal dans le WebIDE.
  2. Exécutez la commande suivante pour compiler et exécuter votre classe :
mvn compile exec:java -Dexec.mainClass="com.labex.JsonReader"

Vous devriez voir la sortie suivante dans le terminal :

Reading file from: src/main/resources/data.json

--- Parsed JSON Data ---
Name: John Doe
Age: 28
Is Employed: true

Cette sortie confirme que votre programme a lu avec succès le fichier data.json à partir de son chemin relatif et a analysé ses propriétés de base.

Gestion des Données JSON Complexes

Les données JSON du monde réel contiennent souvent des structures imbriquées, telles que des objets à l'intérieur d'autres objets ou des tableaux de valeurs. Notre fichier data.json inclut un objet address imbriqué et un tableau skills. Étendons nos connaissances pour analyser ces structures complexes.

Création d'un Analyseur JSON Complexe

Nous allons créer une nouvelle classe pour démontrer l'analyse de ces parties plus complexes du fichier JSON.

  1. Dans l'explorateur de fichiers du WebIDE, naviguez vers src/main/java/com/labex.
  2. Créez un nouveau fichier nommé ComplexJsonParser.java.
  3. Ajoutez le code suivant au fichier :
package com.labex;

import org.json.JSONArray;
import org.json.JSONObject;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class ComplexJsonParser {
    public static void main(String[] args) {
        try {
            String filePath = "src/main/resources/data.json";
            String content = new String(Files.readAllBytes(Paths.get(filePath)));
            JSONObject person = new JSONObject(content);

            System.out.println("--- Parsing Complex JSON Data ---");

            // Access the nested 'address' object
            JSONObject address = person.getJSONObject("address");
            String street = address.getString("street");
            String city = address.getString("city");

            System.out.println("\nAddress:");
            System.out.println("  Street: " + street);
            System.out.println("  City: " + city);

            // Access the 'skills' array
            JSONArray skills = person.getJSONArray("skills");
            System.out.println("\nSkills:");
            for (int i = 0; i < skills.length(); i++) {
                String skill = skills.getString(i);
                System.out.println("  - " + skill);
            }

        } catch (IOException e) {
            System.out.println("Error reading file: " + e.getMessage());
        } catch (Exception e) {
            System.out.println("Error parsing JSON: " + e.getMessage());
        }
    }
}

Explication du Code

  • person.getJSONObject("address") : Cette méthode récupère l'objet JSON imbriqué associé à la clé "address". Vous pouvez ensuite appeler des méthodes comme getString() sur ce nouvel JSONObject.
  • person.getJSONArray("skills") : Cette méthode récupère le tableau JSON associé à la clé "skills".
  • skills.length() : Renvoie le nombre d'éléments dans le JSONArray.
  • skills.getString(i) : Récupère l'élément de type chaîne à un index i spécifique dans le JSONArray.

Compilation et Exécution de l'Analyseur

Exécutons cette nouvelle classe pour voir la sortie.

  1. Ouvrez le terminal dans le WebIDE.
  2. Exécutez la commande suivante :
mvn compile exec:java -Dexec.mainClass="com.labex.ComplexJsonParser"

La sortie attendue est :

--- Parsing Complex JSON Data ---

Address:
  Street: 123 Main St
  City: Anytown

Skills:
  - Java
  - SQL
  - JavaScript

Cela démontre votre capacité à naviguer et à extraire des données à partir d'objets et de tableaux imbriqués dans une structure JSON, une compétence cruciale pour gérer des flux de données complexes et des réponses d'API.

Création d'un Utilitaire JSON Réutilisable

Dans le développement logiciel, il est de bonne pratique d'écrire du code réutilisable. Au lieu de répéter la logique de lecture de fichier dans chaque classe qui en a besoin, nous pouvons créer une classe utilitaire. Cette approche, connue sous le nom de "Don't Repeat Yourself" (DRY), rend votre code plus propre, plus facile à maintenir et moins sujet aux erreurs.

Création de la Classe JsonUtils

Créons une classe utilitaire pour encapsuler la logique de lecture d'un fichier JSON.

  1. Dans le WebIDE, créez un nouveau fichier nommé JsonUtils.java dans le répertoire src/main/java/com/labex.
  2. Ajoutez le code suivant :
package com.labex;

import org.json.JSONObject;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class JsonUtils {

    /**
     * Reads a JSON file from a relative path and parses it into a JSONObject.
     *
     * @param filePath The relative path to the JSON file.
     * @return A JSONObject representing the file's content.
     * @throws IOException if an I/O error occurs reading from the file.
     */
    public static JSONObject readJsonObjectFromFile(String filePath) throws IOException {
        String content = new String(Files.readAllBytes(Paths.get(filePath)));
        return new JSONObject(content);
    }
}

Cette classe contient une seule méthode static, readJsonObjectFromFile. Une méthode static appartient à la classe elle-même plutôt qu'à une instance, vous pouvez donc l'appeler directement en utilisant le nom de la classe (par exemple, JsonUtils.readJsonObjectFromFile(...)) sans créer d'objet.

Utilisation de la Classe Utilitiare

Maintenant, créons une classe d'application principale qui utilise notre nouvel utilitaire.

  1. Dans le WebIDE, créez un nouveau fichier nommé Main.java dans le répertoire src/main/java/com/labex.
  2. Ajoutez le code suivant à Main.java :
package com.labex;

import org.json.JSONObject;

public class Main {
    public static void main(String[] args) {
        try {
            // Use the utility class to read the JSON file
            JSONObject data = JsonUtils.readJsonObjectFromFile("src/main/resources/data.json");

            // Now we can work with the JSONObject as before
            String name = data.getString("name");
            String city = data.getJSONObject("address").getString("city");

            System.out.println("--- Data read using JsonUtils ---");
            System.out.println("Name: " + name);
            System.out.println("City: " + city);
            System.out.println("\nSuccessfully read JSON using JsonUtils.");

        } catch (Exception e) {
            System.out.println("An error occurred: " + e.getMessage());
        }
    }
}

Cette classe Main est beaucoup plus propre. Elle délègue la tâche de lecture et d'analyse du fichier à JsonUtils, se concentrant uniquement sur ce qu'il faut faire avec le JSONObject résultant.

Exécution de l'Application Principale

Enfin, exécutons notre classe Main.

  1. Ouvrez le terminal dans le WebIDE.
  2. Exécutez la commande suivante :
mvn compile exec:java -Dexec.mainClass="com.labex.Main"

Vous verrez la sortie suivante :

--- Data read using JsonUtils ---
Name: John Doe
City: Anytown

Successfully read JSON using JsonUtils.

En créant une classe utilitaire, vous avez rendu votre code plus modulaire et réutilisable, ce qui est un principe clé d'une ingénierie logicielle efficace.

Résumé

Dans ce laboratoire, vous avez acquis des compétences pratiques pour la gestion des fichiers JSON en Java. Vous êtes passé d'une configuration de base à des techniques d'analyse avancées, pour aboutir à la création de code réutilisable.

Voici un récapitulatif de ce que vous avez appris :

  • Configuration du Projet : Vous avez appris à structurer un projet Maven et à inclure des bibliothèques externes comme org.json pour travailler avec JSON.
  • Création de Fichier JSON : Vous avez créé un fichier JSON bien formé contenant divers types de données, notamment des chaînes de caractères, des nombres, des booléens, des objets imbriqués et des tableaux.
  • Lecture à partir d'un Chemin Relatif : Vous avez lu avec succès un fichier en utilisant un chemin relatif, une technique qui rend les applications plus portables.
  • Analyse JSON : Vous avez utilisé la bibliothèque org.json pour analyser des chaînes JSON en objets JSONObject et JSONArray, vous permettant d'accéder aux données par programmation.
  • Gestion des Structures Complexes : Vous avez appris à naviguer dans des objets JSON imbriqués et à parcourir des tableaux JSON pour extraire des données complexes.
  • Réutilisabilité du Code : Vous avez appliqué le principe DRY (Don't Repeat Yourself) en créant une classe JsonUtils pour encapsuler la logique de lecture de fichier, ce qui conduit à un code plus propre et plus facile à maintenir.

La capacité à lire, analyser et manipuler des données JSON est essentielle pour tout développeur Java impliqué dans les services web, l'intégration d'API ou la configuration d'applications. Les bases que vous avez construites dans ce laboratoire vous seront précieuses pour aborder des défis de développement plus complexes.