Guide pratique pour extraire les valeurs du tableau JSON des chaînes en Java

Cet article explore comment extraire efficacement les valeurs de tableau JSON à partir de journaux ou d'autres chaînes en Java. Le contenu de base comprend la stratégie recommandée d'utiliser des bibliothèques d'analyse JSON telles que Jackson pour le traitement des données structurées ou dynamiques, ainsi que l'extraction manuelle d'expressions régulières sous des restrictions spécifiques, et met l'accent sur leurs avantages et leurs inconvénients respectifs, en visant à fournir une solution robuste et maintenable.

Lors du traitement de la sortie du journal ou des données de chaîne obtenues à partir de sources non standard, nous devons souvent en extraire des structures JSON spécifiques, telles que toutes les valeurs d'un tableau JSON. Bien que les expressions régulières soient puissantes dans la correspondance de texte, elles sont souvent insuffisantes dans la maintenabilité et la robustesse pour les structures JSON complexes. Cet article introduira deux méthodes principales: l'utilisation d'une bibliothèque d'analyse JSON mature et l'utilisation d'expressions régulières pour l'extraction manuelle dans des scénarios spécifiques.

1. Il est recommandé d'utiliser la bibliothèque d'analyse JSON

Lors du traitement des données JSON, la méthode la plus recommandée et la plus robuste est d'utiliser des bibliothèques d'analyse JSON spéciales, telles que Jackson, GSON, etc. Ces bibliothèques peuvent gérer la complexité de JSON, y compris les structures imbriquées, les caractères échappés, etc., et fournir des méthodes d'analyse de type type, de simplifier considérablement le travail de développement et d'améliorer la maintenabilité du code.

1.1 Utilisation de POJO pour l'analyse des données structurées

Si la structure des données JSON est connue à l'avance et relativement fixe, la structure JSON peut être mappée en définissant un objet Java (Old Java Object, Pojo). C'est le moyen le plus courant et recommandé d'analyser.

Exemple de données JSON:

 {
   "valeurs":[
      "ABC123",
      "Def456",
      "xyz789"
   ]]
}

Définition de POJO correspondante:

 Importer java.util.list;

classe publique mypojo {
    Valeurs de liste privée <string>;

    // Constructeur public mypojo () {}

    // Getter
    Liste publique <string> getValues ​​() {
        valeurs de retour;
    }

    // setter
    public void setValues ​​(list <string> valeurs) {
        this.values ​​= valeurs;
    }

    @Outrepasser
    public String toString () {
        return "mypojo {"  
               "valeurs =" valeurs  
               '}';
    }
}</string></string></string>

Utilisez la bibliothèque Jackson pour l'analyse:

 import com.fasterxml.jackson.databind.objectmapper;
Importer com.fasterxml.jackson.databind.json.jsonmapper;
Importer java.util.list;

classe publique jsonpojoparser {
    public static void main (String [] args) lève une exception {
        String jSontr = "{\" Values ​​\ ": [\" ABC123 \ ", \" Def456 \ ", \" xyz789 \ "]}";

        ObjectMapper Mappeur = new JSONMapper ();
        Mypojo pojo = mapper.readvalue (jsonstr, mypojo.class);

        System.out.println ("Valeur extraite:" pojo.getValues ​​());
        // Sortie: Valeur extraite: [ABC123, DEF456, XYZ789]
    }
}

Grâce à la méthode POJO, les chaînes JSON sont directement désérialisées en objets Java. Les développeurs peuvent obtenir des données comme les objets Java ordinaires en fonctionnement, avec du code clair et sans erreur.

1.2 Utiliser JSONNode pour l'analyse de données dynamique

Lorsque la structure JSON n'est pas fixe, ou que nous n'avons qu'à extraire une partie des données et ne voulons pas définir un POJO pour l'ensemble du JSON, nous pouvons analyser le JSON dans un arbre (JSONNode) et y accéder via le chemin du nœud.

Utilisez la bibliothèque Jackson pour l'analyse JSONNode:

 import com.fasterxml.jackson.core.type.Typereference;
import com.fasterxml.jackson.databind.jsonNode;
import com.fasterxml.jackson.databind.objectmapper;
Importer com.fasterxml.jackson.databind.json.jsonmapper;
Importer java.util.list;

classe publique JSONNodeParser {
    public static void main (String [] args) lève une exception {
        String jSontr = "{\" Values ​​\ ": [\" ABC123 \ ", \" Def456 \ ", \" xyz789 \ "]}";

        ObjectMapper Mappeur = new JSONMapper ();
        // parses json string dans jsonNode arbre jsonNode rootnode = mappper.readtree (jsonstr);
        // Obtenez le nœud nommé "VALEUR" JSONNODE VALEURSNODE = rootNode.get ("valeurs");

        // désérialiser le contenu du nœud de valeurs à liste <string>
        List <string> valeurs = mappper.readerFor (new TypeReference <list>> () {}). ReadValue (valeursNode);

        System.out.println ("Valeur extraite:");
        valeurs.ForEach (System.out :: println);
        / *
         * Sortir:
         * ABC123
         * DEF456
         * xyz789
         * /
    }
}</list></string></string>

Cette approche offre une plus grande flexibilité et convient aux scénarios de gestion où les structures sont variables ou que seules des données partielles sont nécessaires.

2. Extraction manuelle à travers des expressions régulières

Les expressions régulières peuvent être prises en compte dans de rares cas, par exemple lorsque vous avez un environnement d'exécution strictement restreint, l'incapacité d'introduire des bibliothèques tierces, ou simplement besoin d'extraire des fragments spécifiques à partir de chaînes à formates très simples et très cohérentes. Cependant, il est important de noter que les expressions régulières ne sont pas un outil idéal pour gérer JSON, qui manquent de support pour la complexité de JSON (telles que la nidification, les caractères échappés, différents types de données), sont sujets aux erreurs et difficiles à maintenir.

2.1 Scénarios et limitations applicables

• Scénario applicable: les fragments JSON contenus dans la chaîne sont très simples, avec une structure fixe, et seule la valeur du tableau le plus externe doit être extraite. Par exemple, extraire les fragments des journaux avec le formulaire {"valeurs": ["a", "b", "c"]}.
• Limites: Impossible de gérer JSON imbriqué, les objets JSON, différents types de données (nombres, valeurs booléennes, etc.), des chaînes contenant des caractères spéciaux ou des caractères échappés. Les expressions régulières sont sujettes à échouer pour un JSON légèrement complexe ou moins strict.

2.2 Amélioration de la stratégie d'expression régulière

Les expressions régulières \ "valeurs \" \ s *: \ s * \ [(\ s * \ "(\ w) \" \ s * ,?) *] essayées dans la question d'origine: * Le groupe de capture du quantificateur ne conserve que le dernier résultat correspondant. Afin d'obtenir toutes les valeurs, nous devons capturer le contenu de l'ensemble du tableau, puis effectuer un traitement quadratique sur le contenu capturé.

Expression régulière améliorée: "valeurs" \ s *: \ s * \ [(.)]

L'idée de cette expression régulière est:

1. "valeurs" \ s *: \ s * \ [: correspond aux valeurs ": [section, où \ s * correspond à zéro ou plus d'espaces.
2. (.): Il s'agit d'un groupe de capture qui utilise. Pour correspondre à n'importe quel personnage (sauf les pauses de ligne), une ou plusieurs fois. Il correspondra à autant de fois que possible jusqu'à sa rencontre]. Cela capture le contenu des chaînes à l'intérieur du tableau entier, tel que "ABC123", "Def456", "XYZ789".
3. ]: Faites correspondre les supports d'extrémité du tableau.

Implémentation Java:

 import java.util.arrays;
Importer java.util.list;
import java.util.regex.matcher;
import java.util.regex.pattern;
Importer java.util.stream.collectors;

classe publique regexjsonArrayExtractor {

    Source de chaîne statique privée () {
        String s = "{\" valeurs \ ": [\ n"
                  "\" ABC123 \ ", \" Def456 \ ","
                  "\" xyz789 \ "] \ n"
                  "}";
        retour s;
    }

    public static void main (String [] args) {
        String jSontr = source (); // Supposons qu'il s'agit d'une chaîne JSON obtenue à partir du log // étape 1: utilisez l'expression régulière pour capturer le contenu de l'ensemble du modèle de modèle Pattern1 = Pattern.Compile ("\" valeurs \ "\\ s *: \\ s * \\ [(.)]");
        Matcher Matcher = Pattern1.matcher (jsonstr);

        List <string> valeurs = list.of (); // Initialiser à la liste vide if (Matcher.Find ()) {
            // Matcher.group (1) contiendra la chaîne à l'intérieur de l'ensemble du tableau, par exemple: "ABC123", "Def456", "xYZ789"
            String ArrayContent = Matcher.Group (1);

            // Étape 2: diviser et nettoyer les valeurs de contenu du tableau capturées = arrays.stream (arrayContent.split (",")) // Split by Comas.map (S -> S.ReplaceAll ("\" "," ") .strip ()) // Supprimez les citations et supprimez le début et les fins Blanks.Collect (collection.tolist ());
        }

        System.out.println ("Valeur extraite par l'expression régulière:");
        valeurs.ForEach (System.out :: println);
        / *
         * Sortir:
         * ABC123
         * DEF456
         * xyz789
         * /
    }
}</string>

Cette méthode capture d'abord tous les contenus à l'intérieur du tableau JSON via une expression régulière, puis utilise les fonctions de traitement des chaînes de Java (Split, Rempaceall, Strip) pour extraire et nettoyer chaque valeur.

2.3 choses à noter

• Mauvaise robustesse: cette expression régulière ne sera pas valide si le format JSON change légèrement (par exemple, la valeur contient des virgules, des citations ou des structures imbriquées).
• Coût de maintenance élevée: lorsque la structure JSON change, il est nécessaire de modifier l'expression régulière et la logique de traitement des chaînes ultérieure, ce qui est beaucoup plus compliqué que de modifier le chemin d'accès Pojo ou JsonNode.
• Performances: Pour les très grandes chaînes, les opérations fréquentes de l'expression régulière et les opérations de chaîne peuvent affecter les performances.

3. Résumé et suggestions

Lors de l'extraction des valeurs de tableau JSON des chaînes en Java, il est fortement recommandé de hiérarchiser les bibliothèques d'analyse JSON matures telles que Jackson ou GSON.

• Pour JSON fixé à la structure: désérialisation avec POJO, fournissant un code de type, une réadabilité élevée et un code facile à maintenir.
• Pour la structure dynamique ou uniquement des données partielles: utilisez JSONNode pour l'analyse des arbres, offrant une flexibilité et un accès à la demande.

L'extraction manuelle n'est considérée que dans les scénarios où la structure JSON est extrêmement simple et le format est très cohérent. Même dans ce cas, ses coûts de maintenance potentiels et ses risques de robustesse devraient être entièrement évalués. Le choix du bon outil peut assurer la fiabilité, la lisibilité et la maintenabilité future du code.

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!