gson analyse des objets json imbriqués

Question

J'essaye d'analyser une chaîne JSON en objet Java. Actuellement, le code lit manuellement le fichier et génère l'objet java. Cependant, je cherche à prendre la mise en œuvre de gson.

Voici le JSON que je reçois de l'appel de service Web:

{ "comment": [ 
     "This file is used to define the behavior for the elements parsed.", 
     "Each entry in the file will have the format of element:name, skip:bool", 
     "If SkipFlag is true, it means that element need not be processed.", 
     "Convention used for elements and rule names is camelCase" 
    ], 
    "rules": [ { "element": "html", "skip": true }, 
       { "element": "head", "skip": true }, 
       { "element": "head", "skip": true }, 
       { "element": "body", "skip": true } 
    ] 
} 

je dois ignorer les commentaires et convertir des règles. Voici le type java je suis en train de définir des règles objet java:

// Arraylist < Map < elementname, Map < name, value > > > 
ArrayList< Map<String, Map<String, String> > > rules; 

est-il un moyen facile de faire cela avec gson?

Answer 1

Vous pouvez déclarer des classes spécifiques:

import java.io.BufferedReader; 
import java.io.FileReader; 
import java.io.IOException; 

import com.google.gson.Gson; 

class Rule { 
    String element; 
    boolean skip; 
} 

class ElementParser { 
    String[] comment; 
    Rule[] rules; 
} 

public class JSonDecoder { 
    public static void main(String[] args) throws IOException { 
     try(BufferedReader reader = 
       new BufferedReader(new FileReader("Skip.json"))) { 
     System.out.println( 
      new Gson().fromJson(reader, ElementParser.class).toString()); 
     } 
    } 
} 

Voici la version longue :

import java.io.BufferedReader; 
import java.io.FileReader; 
import java.io.IOException; 

import com.google.gson.Gson; 

class Rule { 
    String element; 
    boolean skip; 

    @Override public String toString() { 
     StringBuilder sb = new StringBuilder(); 
     sb.append('\t'); 
     sb.append(element); 
     sb.append(" ==> "); 
     sb.append(skip); 
     sb.append('\n'); 
     return sb.toString(); 
    } 
} 
class ElementParser { 
    String[] comment; 
    Rule[] rules; 

    @Override public String toString() { 
     StringBuilder sb = new StringBuilder(); 
     sb.append("Comment:\n"); 
     for(String c : comment) { 
     sb.append('\t'); 
     sb.append(c); 
     sb.append('\n'); 
     } 
     sb.append("Rules:\n"); 
     for(Rule r : rules) { 
     sb.append(r.toString()); 
     } 
     return sb.toString(); 
    } 
} 

public class JSonDecoder { 
    public static void main(String[] args) throws IOException { 
     try(BufferedReader reader = new BufferedReader(new FileReader("Skip.json"))) { 
     System.out.println( 
      new Gson().fromJson(reader, ElementParser.class).toString()); 
     } 
    } 
} 

Résultat:

Comment: 
    This file is used to define the behavior for the elements parsed. 
    Each entry in the file will have the format of element:name, skip:bool 
    If SkipFlag is true, it means that element need not be processed. 
    Convention used for elements and rule names is camelCase 
Rules: 
    html ==> true 
    head ==> true 
    head ==> true 
    body ==> true 

Answer 2

Utilisez cette

GsonBuilder builder = new GsonBuilder();  
Gson gson = builder.enableComplexMapKeySerialization().create(); 
Type type = new TypeToken<ArrayList< Map<String, ArrayList<Map<String, String> > > >>() {}.getType(); 
ArrayList< Map<String, ArrayList<Map<String, String> > > > obj = gson.fromJson(str, type); 

Answer 3

Vous pouvez essayer cela aussi ..

Une classe de données pour la tenue de vos règles et commentaires

import java.util.List; 

public class Data { 

    private List<String> comments; 
    private List<Rule> rules; 

    public Data() {} 

    public List<String> getComments() { 
     return comments; 
    } 

    public void setComments(List<String> comments) { 
     this.comments = comments; 
    } 

    public List<Rule> getRules() { 
     return rules; 
    } 

    public void setRules(List<Rule> rules) { 
     this.rules = rules; 
    } 

} 

La classe de règle pour l'élément de maintien et sauter Règle public class {

private String element; 
    private boolean skip; 

    public Rule() {} 

    public String getElement() { 
     return element; 
    } 

    public void setElement(String element) { 
     this.element = element; 
    } 

    public boolean isSkip() { 
     return skip; 
    } 

    public void setSkip(boolean skip) { 
     this.skip = skip; 
    } 

} 

Enfin, vous pouvez utiliser quelque chose comme ceci pour convertir les règles de votre json en java:

import java.io.BufferedReader; 
import java.io.FileNotFoundException; 
import java.io.FileReader; 
import java.util.List; 

import com.google.gson.Gson; 

public class GsonTest { 

    public static void main(String[] args) throws FileNotFoundException { 
     BufferedReader bufferedReader = new BufferedReader(new FileReader("C:/Users/JESNAMOL/Desktop/json.txt"));//i have kept your json string in a file for demonstration 
     Gson gson = new Gson(); 
     Data data = gson.fromJson(bufferedReader, Data.class); 
     List<Rule> rules = data.getRules(); 

     for (Rule rule : rules) { 
      System.out.println("element: " + rule.getElement()); 
      System.out.println("skip: " + rule.isSkip()); 
     } 
    } 

}