如何从 Jackson 中的自定义反序列化程序调用默认反序列化程序

java hibernate spring jackson

2022-08-31 08:08:30

我在杰克逊的自定义反序列化程序中遇到了问题。我想访问默认序列化程序以填充要反序列化到的对象。在填充之后，我将执行一些自定义操作，但首先我想使用默认的 Jackson 行为反序列化对象。

这是我目前拥有的代码。

public class UserEventDeserializer extends StdDeserializer<User> {

  private static final long serialVersionUID = 7923585097068641765L;

  public UserEventDeserializer() {
    super(User.class);
  }

  @Override
  @Transactional
  public User deserialize(JsonParser jp, DeserializationContext ctxt)
      throws IOException, JsonProcessingException {

    ObjectCodec oc = jp.getCodec();
    JsonNode node = oc.readTree(jp);
    User deserializedUser = null;
    deserializedUser = super.deserialize(jp, ctxt, new User()); 
    // The previous line generates an exception java.lang.UnsupportedOperationException
    // Because there is no implementation of the deserializer.
    // I want a way to access the default spring deserializer for my User class.
    // How can I do that?

    //Special logic

    return deserializedUser;
  }

}

我需要的是一种初始化默认反序列化程序的方法，以便我可以在开始特殊逻辑之前预填充POJO。

从自定义反序列化程序中调用反序列化时，无论我如何构造序列化程序类，该方法似乎都是从当前上下文中调用的。因为我的POJO中的注释。这会导致堆栈溢出异常，原因显而易见。

我已经尝试过初始化，但过程非常复杂，我还没有找到正确的方法来做到这一点。我也尝试过重载无济于事，认为它可能会帮助我忽略 .最后，我可能已经取得了一些成功，尽管这需要我做一些神奇的事情来掌握Spring的应用程序上下文。我将不胜感激任何可以引导我找到更清晰的解决方案的东西，例如，如何在不阅读注释的情况下构建反序列化上下文。BeanDeserializerAnnotationIntrospectorDeserializerContextJsonDeserializerBuildersJsonDeserializer

答案 1

正如 StaxMan 已经建议的那样，您可以通过编写 a 并通过注册来执行此操作。以下示例应该有效：BeanDeserializerModifierSimpleModule

public class UserEventDeserializer extends StdDeserializer<User> implements ResolvableDeserializer
{
  private static final long serialVersionUID = 7923585097068641765L;

  private final JsonDeserializer<?> defaultDeserializer;

  public UserEventDeserializer(JsonDeserializer<?> defaultDeserializer)
  {
    super(User.class);
    this.defaultDeserializer = defaultDeserializer;
  }

  @Override public User deserialize(JsonParser jp, DeserializationContext ctxt)
      throws IOException, JsonProcessingException
  {
    User deserializedUser = (User) defaultDeserializer.deserialize(jp, ctxt);

    // Special logic

    return deserializedUser;
  }

  // for some reason you have to implement ResolvableDeserializer when modifying BeanDeserializer
  // otherwise deserializing throws JsonMappingException??
  @Override public void resolve(DeserializationContext ctxt) throws JsonMappingException
  {
    ((ResolvableDeserializer) defaultDeserializer).resolve(ctxt);
  }


  public static void main(String[] args) throws JsonParseException, JsonMappingException, IOException
  {
    SimpleModule module = new SimpleModule();
    module.setDeserializerModifier(new BeanDeserializerModifier()
    {
      @Override public JsonDeserializer<?> modifyDeserializer(DeserializationConfig config, BeanDescription beanDesc, JsonDeserializer<?> deserializer)
      {
        if (beanDesc.getBeanClass() == User.class)
          return new UserEventDeserializer(deserializer);
        return deserializer;
      }
    });


    ObjectMapper mapper = new ObjectMapper();
    mapper.registerModule(module);
    User user = mapper.readValue(new File("test.json"), User.class);
  }
}

答案 2

有一个你可以使用的方法。这应该适用于默认的反序列化程序和您拥有的任何自定义反序列化程序。DeserializationContextreadValue()

只需确保调用要读取的级别以检索要传递到的。traverse()JsonNodeJsonParserreadValue()

public class FooDeserializer extends StdDeserializer<FooBean> {

    private static final long serialVersionUID = 1L;

    public FooDeserializer() {
        this(null);
    }

    public FooDeserializer(Class<FooBean> t) {
        super(t);
    }

    @Override
    public FooBean deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
        JsonNode node = jp.getCodec().readTree(jp);
        FooBean foo = new FooBean();
        foo.setBar(ctxt.readValue(node.get("bar").traverse(), BarBean.class));
        return foo;
    }

}