Как вызвать десериализатор по умолчанию из настраиваемого десериализатора в Джексоне

У меня проблема с моим пользовательским десериализатором в Джексоне. Я хочу получить доступ к сериализатору по умолчанию, чтобы заполнить объект, в который я десериализуюсь. После пополнения я сделаю некоторые пользовательские вещи, но сначала я хочу десериализовать объект с поведением Джексона по умолчанию.

Это код, который у меня есть на данный момент.

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. Это вызывает исключение Stack Overflow по очевидным причинам.

Я попытался инициализировать a, BeanDeserializerно процесс чрезвычайно сложен, и мне не удалось найти правильный способ сделать это. Я также безуспешно пытался перегрузить AnnotationIntrospectorфайл, думая, что это может помочь мне игнорировать аннотацию в DeserializerContext. Наконец, похоже, что я мог бы добиться успеха, JsonDeserializerBuildersхотя для этого мне потребовалось кое-что волшебное, чтобы получить контекст приложения из Spring. Я был бы признателен за любую вещь, которая могла бы привести меня к более чистому решению, например, как я могу создать контекст десериализации, не читая JsonDeserializerаннотацию.

Как уже предлагал StaxMan, вы можете сделать это, написав BeanDeserializerModifierи зарегистрировав его через SimpleModule. Следующий пример должен работать:

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

Я нашел ответ на ans, который намного читабельнее, чем принятый ответ.

    public User deserialize(JsonParser jp, DeserializationContext ctxt)
        throws IOException, JsonProcessingException {
            User user = jp.readValueAs(User.class);
             // some code
             return user;
          }

На самом деле нет ничего проще.

У DeserializationContextнего есть readValue()метод, который вы можете использовать. Это должно работать как для десериализатора по умолчанию, так и для любых пользовательских десериализаторов, которые у вас есть.

Просто не забудьте вызвать traverse()на JsonNodeуровне вы хотите прочитать , чтобы получить , JsonParserчтобы перейти к readValue().

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

}

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

Итак, что вы, скорее всего, можете использовать, так это создать BeanDeserializerModifier, зарегистрировать его через Moduleинтерфейс (использовать SimpleModule). Вам нужно определить / переопределить modifyDeserializer, а в конкретном случае, когда вы хотите добавить свою собственную логику (где тип совпадает), создать свой собственный десериализатор, передать десериализатор по умолчанию, который вам предоставлен. А затем в deserialize()методе вы можете просто делегировать вызов, взять объект результата.

В качестве альтернативы, если вы действительно должны создать и заполнить объект, вы можете сделать это и вызвать перегруженную версию, deserialize()которая принимает третий аргумент; объект для десериализации.

Другой способ, который может сработать (но не на 100% уверен), - это указать Converterobject ( @JsonDeserialize(converter=MyConverter.class)). Это новая функция Jackson 2.2. В вашем случае Converter на самом деле не будет преобразовывать тип, а упрощает изменение объекта: но я не знаю, позволит ли это вам делать именно то, что вы хотите, поскольку сначала будет вызываться десериализатор по умолчанию, а только затем ваш Converter.

Если вы можете объявить дополнительный класс User, вы можете реализовать его, просто используя аннотации

// your class
@JsonDeserialize(using = UserEventDeserializer.class)
public class User {
...
}

// extra user class
// reset deserializer attribute to default
@JsonDeserialize
public class UserPOJO extends User {
}

public class UserEventDeserializer extends StdDeserializer<User> {

  ...
  @Override
  public User deserialize(JsonParser jp, DeserializationContext ctxt)
      throws IOException, JsonProcessingException {
    // specify UserPOJO.class to invoke default deserializer
    User deserializedUser = jp.ReadValueAs(UserPOJO.class);
    return deserializedUser;

    // or if you need to walk the JSON tree

    ObjectMapper mapper = (ObjectMapper) jp.getCodec();
    JsonNode node = oc.readTree(jp);
    // specify UserPOJO.class to invoke default deserializer
    User deserializedUser = mapper.treeToValue(node, UserPOJO.class);

    return deserializedUser;
  }

}

В соответствии с тем, что предложил Томаш Залуски , в случаях, когда использование BeanDeserializerModifierнежелательно, вы можете самостоятельно сконструировать десериализатор по умолчанию BeanDeserializerFactory, хотя для этого потребуется дополнительная настройка. В контексте это решение могло бы выглядеть так:

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

    ObjectCodec oc = jp.getCodec();
    JsonNode node = oc.readTree(jp);
    User deserializedUser = null;

    DeserializationConfig config = ctxt.getConfig();
    JavaType type = TypeFactory.defaultInstance().constructType(User.class);
    JsonDeserializer<Object> defaultDeserializer = BeanDeserializerFactory.instance.buildBeanDeserializer(ctxt, type, config.introspect(type));

    if (defaultDeserializer instanceof ResolvableDeserializer) {
        ((ResolvableDeserializer) defaultDeserializer).resolve(ctxt);
    }

    JsonParser treeParser = oc.treeAsTokens(node);
    config.initialize(treeParser);

    if (treeParser.getCurrentToken() == null) {
        treeParser.nextToken();
    }

    deserializedUser = (User) defaultDeserializer.deserialize(treeParser, context);

    return deserializedUser;
}

Вот один лайнер с использованием ObjectMapper

public MyObject deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    OMyObject object = new ObjectMapper().readValue(p, MyObject.class);
    // do whatever you want 
    return object;
}

И пожалуйста: действительно нет необходимости использовать какое-либо значение String или что-то еще. Вся необходимая информация предоставляется JsonParser, поэтому используйте ее.

Я был не в порядке с использованием, BeanSerializerModifierпоскольку он заставляет объявлять некоторые поведенческие изменения в центральном, ObjectMapperа не в самом настраиваемом десериализаторе, и на самом деле это параллельное решение для аннотирования класса сущности с помощью JsonSerialize. Если вы чувствуете это так же, вы можете оценить мой ответ здесь: https://stackoverflow.com/a/43213463/653539

Более простым решением для меня было просто добавить еще один bean-компонент ObjectMapperи использовать его для десериализации объекта (благодаря комментарию https://stackoverflow.com/users/1032167/varren ) - в моем случае мне было интересно либо десериализовать его по идентификатору (int) или весь объект https://stackoverflow.com/a/46618193/986160

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
import org.springframework.context.annotation.Bean;

import java.io.IOException;

public class IdWrapperDeserializer<T> extends StdDeserializer<T> {

    private Class<T> clazz;

    public IdWrapperDeserializer(Class<T> clazz) {
        super(clazz);
        this.clazz = clazz;
    }

    @Bean
    public ObjectMapper objectMapper() {
        ObjectMapper mapper = new ObjectMapper();
        mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        mapper.configure(MapperFeature.DEFAULT_VIEW_INCLUSION, true);
        mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.NONE);
        mapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);
        return mapper;
    }

    @Override
    public T deserialize(JsonParser jp, DeserializationContext dc) throws IOException, JsonProcessingException {
        String json = jp.readValueAsTree().toString();
          // do your custom deserialization here using json
          // and decide when to use default deserialization using local objectMapper:
          T obj = objectMapper().readValue(json, clazz);

          return obj;
     }
}

для каждого объекта, который должен проходить через настраиваемый десериализатор, нам нужно настроить его в глобальном ObjectMapperbean-компоненте приложения Spring Boot в моем случае (например, для Category):

@Bean
public ObjectMapper objectMapper() {
    ObjectMapper mapper = new ObjectMapper();
                mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
            mapper.configure(MapperFeature.DEFAULT_VIEW_INCLUSION, true);
            mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
            mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.NONE);
            mapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);
    SimpleModule testModule = new SimpleModule("MyModule")
            .addDeserializer(Category.class, new IdWrapperDeserializer(Category.class))

    mapper.registerModule(testModule);

    return mapper;
}

Вы обречены на провал, если попытаетесь создать собственный десериализатор с нуля.

Вместо этого вам нужно получить (полностью настроенный) экземпляр десериализатора по умолчанию с помощью настраиваемого BeanDeserializerModifier, а затем передать этот экземпляр в свой собственный класс десериализатора:

public ObjectMapper getMapperWithCustomDeserializer() {
    ObjectMapper objectMapper = new ObjectMapper();

    SimpleModule module = new SimpleModule();
    module.setDeserializerModifier(new BeanDeserializerModifier() {
        @Override
        public JsonDeserializer<?> modifyDeserializer(DeserializationConfig config,
                    BeanDescription beanDesc, JsonDeserializer<?> defaultDeserializer) 
            if (beanDesc.getBeanClass() == User.class) {
                return new UserEventDeserializer(defaultDeserializer);
            } else {
                return defaultDeserializer;
            }
        }
    });
    objectMapper.registerModule(module);

    return objectMapper;
}

Примечание. Эта регистрация модуля заменяет @JsonDeserializeаннотацию, т. Е. UserКласс или Userполя больше не должны быть аннотированы этой аннотацией.

Пользовательский десериализатор должен быть основан на, DelegatingDeserializerчтобы все методы делегировали, если вы не предоставили явную реализацию:

public class UserEventDeserializer extends DelegatingDeserializer {

    public UserEventDeserializer(JsonDeserializer<?> delegate) {
        super(delegate);
    }

    @Override
    protected JsonDeserializer<?> newDelegatingInstance(JsonDeserializer<?> newDelegate) {
        return new UserEventDeserializer(newDelegate);
    }

    @Override
    public User deserialize(JsonParser p, DeserializationContext ctxt)
            throws IOException {
        User result = (User) super.deserialize(p, ctxt);

        // add special logic here

        return result;
    }
}

Использование BeanDeserializerModifierработает хорошо, но если вам нужно использовать, JsonDeserializeесть способ сделать это AnnotationIntrospector следующим образом:

ObjectMapper originalMapper = new ObjectMapper();
ObjectMapper copy = originalMapper.copy();//to keep original configuration
copy.setAnnotationIntrospector(new JacksonAnnotationIntrospector() {

            @Override
            public Object findDeserializer(Annotated a) {
                Object deserializer = super.findDeserializer(a);
                if (deserializer == null) {
                    return null;
                }
                if (deserializer.equals(MyDeserializer.class)) {
                    return null;
                }
                return deserializer;
            }
});

Теперь скопированный маппер будет игнорировать ваш пользовательский десериализатор (MyDeserializer.class) и будет использовать реализацию по умолчанию. Вы можете использовать его внутри deserializeметода вашего настраиваемого десериализатора, чтобы избежать рекурсии, сделав скопированный сопоставитель статическим или подключив его при использовании Spring.