gson d'analyse imbriqués objets json

Je suis en train d'analyser une chaîne json pour objet java. Actuellement, le code manuellement la lecture du fichier et la génération d'objet java. Cependant, je suis à la recherche de 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 }
    ]
}

J'ai besoin d'ignorer les commentaires et les convertir règles. Voici le type java, je suis en train de définir les règles d'objet java:

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

Est-il un moyen facile de le faire avec gson?

OriginalL'auteur Kiran | 2013-03-16

  1. 3

    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());
      }
   }
}

    Ici est la long version:

    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
    La règle est "une seule public de la classe par fichier'. docs.oracle.com/javase/specs/jls/se7/html/jls-7.html#jls-7.6

    OriginalL'auteur Aubin

  2. 5

    Utiliser 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);
    Pouvez-vous expliquer un peu pls? La spécification du type de gson.fromJson cherche automatiquement le type de correspondance à partir du json? J'essaie de comprendre comment le "commentaire" de l'objet est ignorée.
    La spécification du type de (nouveaux TypeToken etc.) aider Gson pour sérialiser des types complexes (c'est à dire la liste des objets ou même des cartes lors de la clé dérivée de l'objet, mais dans votre cas, votre carte utilise la plaine de la Chaîne). Je suppose que vous pouvez créer un type personnalisé adapté à votre chaîne JSON , de sérialiser (y compris les commentaires !) et tout simplement les ignorer

    OriginalL'auteur Shmil The Cat

  3. 2

    Vous pouvez l'essayer 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 Règle de classe pour la tenue de l'élément et sauter
    public class Règle {

        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 cela pour la conversion de règles dans votre json à 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());
}
}
}
    pas de travailler comme cela. règles vient d'être nulle.

    OriginalL'auteur Sarath Kumar Sivan