Как создать собственный JsonDeserializer на Java?

Question

У меня есть Map<A,B> fieldOfC в качестве поля класса C. Когда я пытаюсь десериализовать C с Джексоном, возникает исключение, потому что он не может найти десериализатор для ключа карты A. Итак, я думаю, что решение расширить StdJsonDeserializer и сделать это вручную.
Моя проблема в том, что я не могу найти пример того, как использовать синтаксический анализатор и контекст метода "десериализации", который я должен реализовать.

Может кто-нибудь написать код для этого простого примера, чтобы я мог использовать его в качестве начала для создания своего настоящего десериализатора?

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

Заранее спасибо

РЕДАКТИРОВАТЬ : погуглив, я нашел тест той же проблемы, что и у меня. Это именно моя проблема

EDIT : изменен расширенный класс с StdDeserializer на StdKeyDeserializer, когда я читаю здесь в методе findKeyDeserializer(org.codehaus.jackson.map.DeserializationConfig, org.codehaus.jackson.type.JavaType, org.codehaus.jackson.map.BeanProperty)

РЕДАКТИРОВАТЬ : После решения этой проблемы я получил этот , который связан.

Answer 1

Я полный новичок с Джексоном, но мне подходит следующее.

Сначала я добавляю метод JsonCreator в A:

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

Уже одно это решает проблему десериализации. Самым сложным для меня была правильная сериализация ключей. Что я сделал там, так это определил ключевой сериализатор, который сериализует именованные классы так же, как и сериализацию JSON, например:

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

Затем, чтобы доказать, что это работает, сериализовать и десериализовать экземпляр класса 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());

Для меня это привело к выводу:

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"}}}

Я чувствую, что должен быть лучший способ сказать, как сериализовать ключ, используя аннотации, но я не мог решить это.