Java Gson Exclure des domaines au cours de la sérialisation

J'ai un ConfigInstance classe qui contient une password et un password_hash.
Maintenant, je veux sérialiser l'objet à l'aide de gson, mais exclure le password champ.

public class ConfigInstance {
    public String database_address;
    public int database_port;
    public String database_user;

    @Expose(serialize = false)
    private String database_pass;
    public String database_pass_hash;

    public String GetPass() { return database_pass; }

    public void Encrypt() { /* Creates the hash before serializing*/ }

    public void Decrypt() { /* Creates the password after deserializing */}
}

Comme vous pouvez le voir, j'ai essayé d'utiliser @Expose(serialize = false) mais il ne semble pas faire quoi que ce soit. Aussi je l'ai déjà réglé le domaine privé puisque je me suis dit que ce serait de "remplacer" le @Expose

mais l'exécution de code suivant:

private void toFile(File file, ConfigInstance map) {
    map.Encrypt();
    Gson gson = new GsonBuilder().setPrettyPrinting().create();
    String jsonConfig = gson.toJson(map);
    FileWriter writer;
    try {
        writer = new FileWriter(file);
        writer.write(jsonConfig);
        writer.flush();
        writer.close();
    } catch (IOException e) {
        System.out.println("Error exporting config: " + e.toString());
    }
}

encore les résultats dans le fichier de contenu sans Erreurs:

{
  "database_address": "127.0.0.1",
  "database_port": 1521,
  "database_user": "test",
  "database_pass": "test1234",
  "database_pass_hash": "B9FE2C011B59F0D0D383D70073E48A19"
}

Donc ce que je fais mal? Je suis assez paumé dès maintenant et vous serais reconnaissant de toute aide depuis CETTE ne semble pas fonctionner.

Merci d'avance.

Si vous devez modifier les accès à la classe de l'objet à sérialiser, vous pouvez utiliser l'annotation 'Exposés' tel que mentionné par @bosco. Si vous n'avez pas de modifier l'accès, qui est, si elle est dans une lib externe, vous pouvez utiliser d'autres approches, comme celles énumérées ici baeldung.com/gson-exclude-fields-serialization

OriginalL'auteur ThexBasic | 2016-12-01

Afin d'obtenir ce résultat, vous avez besoin d'annoter tous les champs avec les @Expose:

public class ConfigInstance {

    @Expose
    public String database_address;
    @Expose
    public int database_port;
    @Expose
    public String database_user;

    @Expose(serialize = false)
    private String database_pass;
    @Expose
    public String database_pass_hash;

Et configurer Gson à exposer uniquement les champs qui sont annotés et ignorer le reste, comme illustré ci-dessous:

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

Ensuite, vous obtiendrez:

{
  "database_address": "127.0.0.1",
  "database_port": 1521,
  "database_user": "test",
  "database_pass_hash": "B9FE2C011B59F0D0D383D70073E48A19"
}

Aussi, quand deserialising la chaîne, vous aurez encore l'attribut de mot de passe.

Encore, vous avez la possibilité de configurer un Gson Sérialiseur pour accomplir cette tâche.

Cela fonctionne parfaitement. Un grand merci

OriginalL'auteur bosco

C'est une autre façon.

de la sérialisation:

Gson gson = new GsonBuilder()
            .addSerializationExclusionStrategy(new ExclusionStrategy() {
                @Override
                public boolean shouldSkipField(FieldAttributes f) {
                    return f.getName().toLowerCase().contains("fieldName");
                }

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

désérialisation:

Gson gson = new GsonBuilder()
            .addDeserializationExclusionStrategy(new ExclusionStrategy() {
                @Override
                public boolean shouldSkipField(FieldAttributes f) {
                    return f.getName().toLowerCase().contains("fieldName");
                }

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

Afin de les aider!

OriginalL'auteur utkusonmez

13

Si vous aimez le domaine particulier de ne pas être sérialisé donner un transitoire mot-clé
```
private transient String database_pass;
```
visite https://sites.google.com/site/gson/gson-user-guide#TOC-Finer-Points-with-Objects pour plus d'informations

en effet, j'ai essayé ça aussi, mais le problème est que transitoire champs sont complètement ignorées par Gson, également lors de la désérialisation. Donc, dans le cas où les mots de passe se modifie dans le fichier, le database_pass champ wouldnt être attribué lors de la désérialisation,

OriginalL'auteur kPieczonka

@utkusonmez
Cette réponse œuvres quoique la méthode mentionnée est erronée.
Il devrait être à l'aide de 'addSerializationExclusionStrategy' au lieu de 'addDeserializationExclusionStrategy'

Donc la réponse devrait ressembler à

Gson gson = new GsonBuilder()
            .addSerializationExclusionStrategy(new ExclusionStrategy() {
                @Override
                public boolean shouldSkipField(FieldAttributes f) {
                    return f.getName().toLowerCase().contains("fieldName");
                }

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

gson.toJson(*OBJ_TO_SERIALIZE*))

OriginalL'auteur Olmstov

3

Si vous souhaitez désactiver uniquement la sérialisation ou seulement de la désérialisation, vous pouvez jouer avec @Expose annotation des attributs, par exemple:
```
@Expose(serialize = false, deserialize = true)
```
Option par défaut est true, donc désérialiser est inutile ici.

OriginalL'auteur Jakub Turcovsky

C'est une réponse tardive, mais il peut aider quelqu'un.

Vous n'avez qu'à faire le @Expose(serialize = false, deserialize = false) ou tout simplement ce que vous voulez.

Si vous avez serialize et deserialize true ses pas nesseccary avoir @Expose à tous.

Créer cette Classe:

import com.google.gson.ExclusionStrategy;
import com.google.gson.FieldAttributes;
import com.google.gson.annotations.Expose;

public class NoModuleExclusionStrategy implements ExclusionStrategy {

    private final boolean deserialize;

    public NoModuleExclusionStrategy(boolean isdeserialize) {
        deserialize = isdeserialize;
    }

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

    @Override
    public boolean shouldSkipField(FieldAttributes field) {
        return !(field.getAnnotation(Expose.class) == null || (deserialize ? field.getAnnotation(Expose.class).deserialize() : field.getAnnotation(Expose.class).serialize()));
    }

}

et ensuite construire Gson avec GsonBuilder

Gson gson = new GsonBuilder()
.addSerializationExclusionStrategy(new NoModuleExclusionStrategy(false))
.addDeserializationExclusionStrategy(new NoModuleExclusionStrategy(true))
.create();

Votre ConfigInstance Classe va se présenter comme suit

{
  "database_address": "127.0.0.1",
  "database_port": 1521,
  "database_user": "test",
  "database_pass_hash": "B9FE2C011B59F0D0D383D70073E48A19"
}

OriginalL'auteur Klotzi111

0

Vous pouvez faire le truc avec cette:
```
Gson gson = new GsonBuilder()
            .excludeFieldsWithModifiers(Modifier.STATIC)
            .create();
```
Puis dans tous les champs que vous souhaitez excelude de l'Objet, il suffit d'ajouter le modificateur "statique"
```
@Expose(serialize = false)
private static String database_pass;
```
Vous pouvez utiliser le modificateur Transitoire ou quelque chose qui vous convient

L'approche serait bon si je n'aurais pas plusieurs Instances de l'objet. Donc, en utilisant les champs statiques n'est pas une option.
parce que pour le même objet que vous souhaitez remplir l'attribut, à certains moments, et d'autres que vous ne marche pas?
Alors peut-être vous pouvez créer 2 nouvelles instances, ConfigInstancePrivate et ConfigInstancePublic et de définir l'attribut de mot de passe sur chaque que vous avez besoin, dans votre logique d'utiliser l'instance qui vous convient le mieux
c'est une telle idée horrible
avez-vous proposer une meilleure idée @Rafael Lima?

OriginalL'auteur cralfaro
0

Voici une solution très simple avec juste une ligne de code, sans aucune @Exposer annotation ou l'exclusion de la stratégie.

Le comportement par défaut qui est mis en œuvre dans Gson est que objet null champs sont ignorés. Donc, tout ce que vous devez faire est de définir le champ mot de passe null avant de sérialisation.
```
map.setPassword(null); //or map.password = null;
String jsonConfig = gson.toJson(map); //This won't serialize null password field
```
ne fonctionne pas sur les primitives

OriginalL'auteur ntsh

Vous devez vous connecter pour publier un commentaire.