Gson : Comment exclure des champs spécifiques de la sérialisation sans annotation ?

Question

J'essaie d'apprendre Gson et j'ai du mal avec l'exclusion de champs. Voici mes classes

public class Student {    
  private Long                id;
  private String              firstName        = "Philip";
  private String              middleName       = "J.";
  private String              initials         = "P.F";
  private String              lastName         = "Fry";
  private Country             country;
  private Country             countryOfBirth;
}

public class Country {    
  private Long                id;
  private String              name;
  private Object              other;
}

Je peux utiliser le GsonBuilder et ajouter une ExclusionStrategy pour un nom de champ, par exemple firstName ou country mais je ne parviens pas à exclure les propriétés de certains champs comme country.name .

Utilisation de la méthode public boolean shouldSkipField(FieldAttributes fa) si FieldAttributes ne contient pas suffisamment d'informations pour faire correspondre le champ avec un filtre tel que country.name .

P.S. : Je veux éviter les annotations car je veux améliorer cela et utiliser RegEx pour filtrer les champs.

Modifier : J'essaie de voir s'il est possible d'émuler le comportement de Plugin Struts2 JSON

en utilisant Gson

<interceptor-ref name="json">
  <param name="enableSMD">true</param>
  <param name="excludeProperties">
    login.password,
    studentList.*\.sin
  </param>
</interceptor-ref>

Edit : J'ai rouvert la question avec l'ajout suivant :

J'ai ajouté un deuxième champ du même type pour clarifier davantage ce problème. En gros, je veux exclure country.name mais pas countrOfBirth.name . Je ne veux pas non plus exclure le Pays comme type. Les types sont donc les mêmes, c'est l'emplacement réel dans le graphe d'objets que je veux localiser et exclure.

Answer 1

Pour tous les champs que vous ne voulez pas sérialiser en général, vous devez utiliser le modificateur "transient", et cela s'applique également aux sérialiseurs json (du moins pour quelques-uns que j'ai utilisés, dont gson).

Si vous ne voulez pas que le nom apparaisse dans le json sérialisé, donnez-lui un mot-clé transitoire, par exemple :

private transient String name;

Plus de détails dans la documentation de Gson

Answer 2

Nishant a fourni une bonne solution, mais il existe un moyen plus simple. Il suffit de marquer les champs souhaités avec l'annotation @Expose, comme :

@Expose private Long id;

Laissez de côté tous les champs que vous ne souhaitez pas sérialiser. Ensuite, créez simplement votre objet Gson de cette façon :

Gson gson = new GsonBuilder().excludeFieldsWithoutExposeAnnotation().create();

Answer 3

Donc, vous voulez exclure firstName et country.name . Voici ce que votre ExclusionStrategy devrait ressembler à

    public class TestExclStrat implements ExclusionStrategy {

        public boolean shouldSkipClass(Class<?> arg0) {
            return false;
        }

        public boolean shouldSkipField(FieldAttributes f) {

            return (f.getDeclaringClass() == Student.class && f.getName().equals("firstName"))||
            (f.getDeclaringClass() == Country.class && f.getName().equals("name"));
        }

    }

Si vous voyez de près il retourne true pour Student.firstName et Country.name ce qui est ce que vous voulez exclure.

Vous devez appliquer cette ExclusionStrategy comme ça,

    Gson gson = new GsonBuilder()
        .setExclusionStrategies(new TestExclStrat())
        //.serializeNulls() <-- uncomment to serialize NULL fields as well
        .create();
    Student src = new Student();
    String json = gson.toJson(src);
    System.out.println(json);

Cela revient :

{ "middleName": "J.", "initials": "P.F", "lastName": "Fry", "country": { "id": 91}}

Je suppose que l'objet pays est initialisé avec id = 91L dans la classe des élèves.

---

Vous risquez de devenir fantaisiste. Par exemple, vous ne voulez pas sérialiser un champ dont le nom contient la chaîne "name". Faites ceci :

public boolean shouldSkipField(FieldAttributes f) {
    return f.getName().toLowerCase().contains("name"); 
}

Cela reviendra :

{ "initials": "P.F", "country": { "id": 91 }}

---

EDIT : J'ai ajouté plus d'informations comme demandé.

Ce site ExclusionStrategy fera l'affaire, mais vous devez passer le "Fully Qualified Field Name". Voir ci-dessous :

    public class TestExclStrat implements ExclusionStrategy {

        private Class<?> c;
        private String fieldName;
        public TestExclStrat(String fqfn) throws SecurityException, NoSuchFieldException, ClassNotFoundException
        {
            this.c = Class.forName(fqfn.substring(0, fqfn.lastIndexOf(".")));
            this.fieldName = fqfn.substring(fqfn.lastIndexOf(".")+1);
        }
        public boolean shouldSkipClass(Class<?> arg0) {
            return false;
        }

        public boolean shouldSkipField(FieldAttributes f) {

            return (f.getDeclaringClass() == c && f.getName().equals(fieldName));
        }

    }

Voici comment nous pouvons l'utiliser de manière générique.

    Gson gson = new GsonBuilder()
        .setExclusionStrategies(new TestExclStrat("in.naishe.test.Country.name"))
        //.serializeNulls()
        .create();
    Student src = new Student();
    String json = gson.toJson(src);
    System.out.println(json); 

Il revient :

{ "firstName": "Philip" , "middleName": "J.", "initials": "P.F", "lastName": "Fry", "country": { "id": 91 }}

Answer 4

J'ai rencontré ce problème, dans lequel j'avais un petit nombre de champs que je voulais exclure uniquement de la sérialisation. J'ai donc mis au point une solution assez simple qui utilise la méthode de Gson @Expose avec des stratégies d'exclusion personnalisées.

La seule façon intégrée d'utiliser @Expose c'est en fixant GsonBuilder.excludeFieldsWithoutExposeAnnotation() mais, comme son nom l'indique, les champs qui n'ont pas de nom de domaine explicite sont considérés comme des champs à part entière. @Expose sont ignorés. Comme je n'avais que quelques champs à exclure, j'ai trouvé la perspective d'ajouter l'annotation à chaque champ très encombrante.

Je voulais effectivement l'inverse, dans lequel tout était inclus sauf si j'utilisais explicitement @Expose pour l'exclure. J'ai utilisé les stratégies d'exclusion suivantes pour y parvenir :

new GsonBuilder()
        .addSerializationExclusionStrategy(new ExclusionStrategy() {
            @Override
            public boolean shouldSkipField(FieldAttributes fieldAttributes) {
                final Expose expose = fieldAttributes.getAnnotation(Expose.class);
                return expose != null && !expose.serialize();
            }

            @Override
            public boolean shouldSkipClass(Class<?> aClass) {
                return false;
            }
        })
        .addDeserializationExclusionStrategy(new ExclusionStrategy() {
            @Override
            public boolean shouldSkipField(FieldAttributes fieldAttributes) {
                final Expose expose = fieldAttributes.getAnnotation(Expose.class);
                return expose != null && !expose.deserialize();
            }

            @Override
            public boolean shouldSkipClass(Class<?> aClass) {
                return false;
            }
        })
        .create();

Maintenant, je peux facilement exclure quelques champs avec @Expose(serialize = false) ou @Expose(deserialize = false) (notez que la valeur par défaut pour les deux annotations @Expose Les attributs sont true ). Vous pouvez bien sûr utiliser @Expose(serialize = false, deserialize = false) mais cela se fait de manière plus concise en déclarant le champ transient à la place (qui prend toujours effet avec ces stratégies d'exclusion personnalisées).

Answer 5

J'ai imaginé une fabrique de classes pour prendre en charge cette fonctionnalité. Passez n'importe quelle combinaison de champs ou de classes que vous voulez exclure.

public class GsonFactory {

    public static Gson build(final List<String> fieldExclusions, final List<Class<?>> classExclusions) {
        GsonBuilder b = new GsonBuilder();
        b.addSerializationExclusionStrategy(new ExclusionStrategy() {
            @Override
            public boolean shouldSkipField(FieldAttributes f) {
                return fieldExclusions == null ? false : fieldExclusions.contains(f.getName());
            }

            @Override
            public boolean shouldSkipClass(Class<?> clazz) {
                return classExclusions == null ? false : classExclusions.contains(clazz);
            }
        });
        return b.create();

    }
}

Pour l'utiliser, créez deux listes (chacune est facultative), et créez votre objet GSON :

static {
 List<String> fieldExclusions = new ArrayList<String>();
 fieldExclusions.add("id");
 fieldExclusions.add("provider");
 fieldExclusions.add("products");

 List<Class<?>> classExclusions = new ArrayList<Class<?>>();
 classExclusions.add(Product.class);
 GSON = GsonFactory.build(null, classExclusions);
}

private static final Gson GSON;

public String getSomeJson(){
    List<Provider> list = getEntitiesFromDatabase();
    return GSON.toJson(list);
}