Comment travailler avec JSON à Java

Pour travailler avec JSON en Java, utilisez une bibliothèque tierce comme Jackson, GSON ou JSON-B, car Java manque de support intégré; 2. Pour la désérialisation, mappez les objets JSON à Java utilisant ObjectMapper dans Jackson ou GSON.fromjson; 3. Pour la sérialisation, convertissez les objets Java en chaînes JSON via WriteValueAsString ou Tojson; 4. Gérer les structures imbriquées en utilisant des types de typographie ou de collecte; 5. Parse Dynamic JSON avec MAP ou JSONNODE pour la flexibilité; 6. Évitez les problèmes courants en faisant correspondre les noms de champ, en réutilisant ObjectMapper et en configurant des formats de date ou en manipulation de propriétés inconnus, en garantissant un traitement JSON robuste et efficace dans les applications Java.

Travailler avec JSON en Java est une exigence commune lors de la création d'applications Web, de la consommation d'API REST ou du stockage de données structurées. Java n'a pas de support JSON intégré dans la bibliothèque standard (avant Java 11 avec des modules limités), les développeurs comptent donc généralement sur des bibliothèques tierces. Voici comment travailler efficacement avec JSON en Java en utilisant des approches populaires.

1. Choisissez une bibliothèque JSON

Les bibliothèques JSON les plus utilisées en Java sont:

• Jackson - haute performance, flexible et riche en fonctionnalités.
• GSON - développé par Google, simple à utiliser et idéal pour les cas d'utilisation de base à moyenne.
• JSON-B (Jakarta JSON Binding) - Une API standard, qui fait partie de Jakarta EE, souvent utilisée avec des frameworks.

Pour la plupart des applications modernes, Jackson est recommandé en raison de sa vitesse et de son intégration avec des cadres comme Spring.

2. Convertir JSON en objets Java (désérialisation)

Ceci est utile lors de la réception de JSON d'une API ou d'un fichier et de le mappant à vos classes de domaine.

Exemple avec Jackson:

Tout d'abord, ajoutez la dépendance (maven):

 <dépendance>
    <GroupId> com.fasterxml.jackson.core </rombandid>
    <ArtefactId> Jackson-Databind </ Arfactive>
    <version> 2.15.2 </ version>
</Dependance>

Créez un pojo:

 classe publique User {
    nom de chaîne privé;
    Âge privé;

    // constructeurs
    Utilisateur public () {}

    // Getters et Setters
    public String getName () {Nom de retour; }
    public void setName (String name) {this.name = name; }

    public int getage () {return âge; }
    public void Setage (int Age) {this.age = Âge; }

    @Outrepasser
    public String toString () {
        return "User {name = '" name "', age =" Age "}";
    }
}

Analyser la chaîne JSON dans l'objet:

 import com.fasterxml.jackson.databind.objectmapper;

classe publique JSonexample {
    public static void main (String [] args) lève une exception {
        String json = "{\" name \ ": \" John \ ", \" Age \ ": 30}";

        ObjectMapper Mappeur = new ObjectMapper ();
        User user = mapper.readvalue (json, user.class);

        System.out.println (utilisateur); // Sortie: utilisateur {name = 'John', âge = 30}
    }
}

3. Convertir les objets Java en JSON (sérialisation)

Utile lors de l'envoi de données sur les réponses HTTP ou de l'enregistrement dans un fichier.

 Utilisateur utilisateur = nouveau utilisateur ();
user.setName ("Alice");
user.setage (25);

ObjectMapper Mappeur = new ObjectMapper ();
String JSON = mAper.WriteValueAsString (utilisateur);

System.out.println (JSON); // Sortie: {"Name": "Alice", "Age": 25}

À JSON assez imprimé:

 String jolijson = mapper.writerWithDefaultPrettypriter (). WriteValueAsString (utilisateur);
System.out.println (Prettyjson);
// Sortir:
// {
// "nom": "Alice",
// "Age": 25
//}

4. Travailler avec des objets et des listes imbriquées

Jackson gère automatiquement les structures complexes.

Exemple avec une liste:

 String jSonArray = "[{\" name \ ": \" John \ ", \" Age \ ": 30}, {\" name \ ": \" Jane \ ", \" Age \ ": 28}]";

List <User> users = mapper.readvalue (JSONArray, mapper.getTypeFactory (). ConstructCollectionType (list.class, user.class));

System.out.println (utilisateurs);

Ou en utilisant TypeReference pour les génériques:

 List <utilisateur> users = mapper.readvalue (jsonArray, new TypeReference <list <utilisateur >> () {});

5. Gestion de JSON inconnu ou dynamique

Si vous n'avez pas de classe prédéfinie, vous pouvez analyser JSON dans une Map ou JsonNode .

Utilisation Map :

 Map <string, objet> map = mapper.readvalue (json, new typereference <map <string, objet >> () {});
System.out.println (map.get ("name")); // John

Utilisation de JsonNode (modèle d'arbre):

 JSONNODE Node = MAPPER.READTREE (JSON);
String name = node.get ("name"). AsText ();
int age = node.get ("Âge"). ASInt ();

Ceci est utile lorsque vous traitez des champs optionnels ou des structures variables.

6. Pièges et conseils communs

• Noms de champ : Assurez-vous que les touches JSON correspondent aux noms de champ Java ou utilisez @JsonProperty("custom_name") pour la cartographie.
• Temps privés : Jackson peut accéder aux champs privés via la réflexion (pas besoin de domaines publics).
• Dates : utilisez des annotations comme @JsonFormat pour contrôler le formatage de la date.
• Ignorez les champs inconnus : Utilisez mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); Pour éviter les erreurs sur les champs JSON supplémentaires.
• Performance : réutilisez l'instance ObjectMapper (c'est thread-safe).

Alternative: Utilisation de GSON

GSON est plus simple pour une utilisation de base:

 Gson gson = new gson ();
User user = gson.fromjson (json, user.class);
String json = gson.tojson (utilisateur);

Ajouter une dépendance:

 <dépendance>
    <proupId> com.google.code.gson </prôdId>
    <ArtefactId> GSON </ artifactid>
    <version> 2.10.1 </ version>
</Dependance>

Travailler avec JSON en Java est simple une fois que vous avez choisi une bibliothèque et que vous comprenez les modèles de sérialisation / désérialisation. Jackson est puissant et largement adopté, en particulier dans les applications basées sur les entreprises et le ressort. Pour les besoins plus simples, GSON est un choix solide. La clé est la cohérence de la gestion des structures de données et de la gestion appropriée des erreurs (par exemple, IOException pendant l'analyse).

Fondamentalement, mappez vos données sur POJOS, utilisez une bibliothèque fiable et tirez parti d'annotations en cas de besoin.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!