comment créer un personnalisé JsonDeserializer en Java?

J'ai un Map<A,B> fieldOfC comme un champ d'une classe C. Quand j'essaie de désérialiser C avec Jackson, une Exception est levée, car il ne peut pas trouver un Deserializer pour la Carte de clé de A. Alors, je pense que la solution est d'étendre StdJsonDeserializer et le faire manuellement.
Mon problème est que je ne peux pas trouver un exemple sur la façon d'utiliser l'analyseur et le contexte de la méthode "désérialiser" que j'ai à mettre en œuvre.

Quelqu'un peut-il écrire le code pour cet exemple simple, donc je peux l'utiliser pour commencer à construire mon vrai deserializer?

public class A{
  private String a1;
  private Integer a2;
}

public class B{
  private String b1;
}

public class C{
  @JsonDeserialize(keyUsing=ADeserializer.class)
  //also tried this: @JsonDeserialize(keyAs=A.class) without success
  private Map<A,B> fieldOfC;
  private String c1;
}

public class ADeserializer extends StdKeyDeserializer {

  protected ADeserializer(Class<A> cls) {
    super(cls);
  }

  protected Object _parse(String key, DeserializationContext ctxt) throws Exception {
    ObjectMapper mapper = new ObjectMapper();
    return mapper.readValue(key, A.class);
  }
}

Merci d'avance

MODIFIER: recherches sur google, j'ai trouvé un test de le même problème que j'ai. C'est exactement mon problème

MODIFIER: modification de la classe étendue de StdDeserializer à StdKeyDeserializer comme je l'ai lu ici dans la méthode findKeyDeserializer(org.codehaus.jackson.map.DeserializationConfig, org.codehaus.jackson.type.JavaType, org.codehaus.jackson.map.BeanProperty)

MODIFIER: Après la résolution de ce problème je l'ai eu cette une qui est lié.

Je sais que ce n'est pas une solution tout à fait encore, mais Jackson 1.8 possède un support complet pour la touche personnalisée sérialiseurs et deserializers, à la fois via des annotations et par le biais de l'API des modules. Donc, il devrait aider beaucoup: cela a été douloureux pour le faire correctement avec les versions antérieures.

OriginalL'auteur Neuquino | 2011-04-10

Je suis un débutant complet avec Jackson, mais la suivante fonctionne pour moi.

J'ai d'abord ajouter un JsonCreator méthode:

public class A {
    private String a1;
    private Integer a2;
    public String getA1() { return a1; }
    public Integer getA2() { return a2; }
    public void setA1(String a1) { this.a1 = a1; }
    public void setA2(Integer a2) { this.a2 = a2; }

    @JsonCreator
    public static A fromJSON(String val) throws JsonParseException, JsonMappingException, IOException {
        ObjectMapper mapper = new ObjectMapper();
        A a = mapper.readValue(val,A.class);
        return a;
    }
}

Qui seule permet de résoudre le problème de la désérialisation. La partie la plus difficile pour moi a été la bonne sérialisation des clés. Ce que j'ai fait il y a à définir une touche sérialiseur qui sérialise nommé classes qu'il la sérialisation JSON, comme ceci:

public class KeySerializer extends SerializerBase<Object> {
    private static final SerializerBase<Object> DEFAULT = new StdKeySerializer();

    private Set<Class<?>> objectKeys_ = Collections.synchronizedSet(new HashSet<Class<?>>());

    protected KeySerializer(Class<?>... objectKeys) {
        super(Object.class);
        for(Class<?> cl:objectKeys) {
            objectKeys_.add(cl);
        }
    }


    @Override
    public JsonNode getSchema(SerializerProvider provider, Type typeHint) throws JsonMappingException {
        return DEFAULT.getSchema(provider, typeHint);
    }


    @Override
    public void serialize(Object value, JsonGenerator jgen,
            SerializerProvider provider) throws IOException,
            JsonGenerationException {
        if (objectKeys_.contains(value.getClass())) {
            ObjectMapper mapper = new ObjectMapper();
            StringWriter writer = new StringWriter();
            mapper.writeValue(writer, value);
            jgen.writeFieldName(writer.toString());
        } else {
            DEFAULT.serialize(value, jgen, provider);
        }
    }
}

Alors pour prouver que cela fonctionne, la sérialisation et la désérialisation d'une instance de la classe C:

    ObjectMapper mapper = new ObjectMapper();
    StdSerializerProvider provider = new StdSerializerProvider();
    provider.setKeySerializer(new KeySerializer(A.class));
    mapper.setSerializerProvider(provider);

    StringWriter out = new StringWriter();
    mapper.writeValue(out, c);
    String json = out.toString();
    System.out.println("JSON= "+json);

    C c2 = mapper.readValue(json, C.class);
    System.out.print("C2= ");
    StringWriter outC2 = new StringWriter();
    mapper.writeValue(outC2, c2);
    System.out.println(outC2.toString());

Pour moi, ce produit de la sortie:

JSON= {"c1":"goo","map":{"{\"a1\":\"1ccf\",\"a2\":7376}":{"b1":"5ox"},"{\"a1\":\"1cd2\",\"a2\":7379}":{"b1":"5p0"},"{\"a1\":\"1cd5\",\"a2\":7382}":{"b1":"5p3"},"{\"a1\":\"1cd8\",\"a2\":7385}":{"b1":"5p6"}}}
C2= {"c1":"goo","map":{"{\"a1\":\"1ccf\",\"a2\":7376}":{"b1":"5ox"},"{\"a1\":\"1cd2\",\"a2\":7379}":{"b1":"5p0"},"{\"a1\":\"1cd5\",\"a2\":7382}":{"b1":"5p3"},"{\"a1\":\"1cd8\",\"a2\":7385}":{"b1":"5p6"}}}

Je pense que cela aurait été une meilleure façon de faire dire comment sérialiser la clé en utilisant les annotations, mais je ne pouvais pas travailler.

Je vais essayer de fusionner cette solution avec ce que je suis en train de faire avec StdKeyDeserializer et voir si je trouve une meilleure façon.
J'ai utilisé votre solution, la seule chose différente, c'est que j'ai mis en œuvre la méthode serialize sans l'aide de la objectKeys attribut. Mon application est exactement les quatre lignes que vous avez à l'intérieur si le bloc. Maintenant, je vais avoir des problèmes avec la Période de joda-time de la classe, mais je vais faire un nouveau post avec celui-là. Merci, Simon.

OriginalL'auteur Simon G.

Vous devez vous connecter pour publier un commentaire.