Comment appeler le désérialiseur par défaut à partir d'un désérialiseur personnalisé dans Jackson

J'ai un problème dans mon désérialiseur personnalisé à Jackson. Je souhaite accéder au sérialiseur par défaut pour remplir l'objet dans lequel je désérialise. Après la population, je vais faire des choses personnalisées mais je veux d'abord désérialiser l'objet avec le comportement par défaut de Jackson.

C'est le code que j'ai en ce moment.

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

}

Ce dont j'ai besoin, c'est d'un moyen d'initialiser le désérialiseur par défaut afin que je puisse pré-remplir mon POJO avant de démarrer ma logique spéciale.

Lors de l'appel de désérialisation depuis le désérialiseur personnalisé Il semble que la méthode soit appelée à partir du contexte actuel, quelle que soit la manière dont je construis la classe de sérialiseur. À cause de l'annotation dans mon POJO. Cela provoque une exception de débordement de pile pour des raisons évidentes.

J'ai essayé d'initialiser un BeanDeserializermais le processus est extrêmement complexe et je n'ai pas réussi à trouver la bonne façon de le faire. J'ai également essayé de surcharger le AnnotationIntrospectoren vain, pensant que cela pourrait m'aider à ignorer l'annotation dans le DeserializerContext. Enfin, il semble que j'aie eu un certain succès en utilisant, JsonDeserializerBuildersbien que cela m'oblige à faire des choses magiques pour obtenir le contexte de l'application de Spring. J'apprécierais toute chose qui pourrait me conduire à une solution plus propre, par exemple comment puis-je construire un contexte de désérialisation sans lire l' JsonDeserializerannotation.

Comme StaxMan l'a déjà suggéré, vous pouvez le faire en écrivant un BeanDeserializerModifier et en l'enregistrant via SimpleModule. L'exemple suivant devrait fonctionner:

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

J'ai trouvé une réponse à ans qui est beaucoup plus lisible que la réponse acceptée.

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

Ce n'est vraiment pas plus facile que ça.

Le DeserializationContexta une readValue()méthode que vous pouvez utiliser. Cela devrait fonctionner à la fois pour le désérialiseur par défaut et pour tous les désérialiseurs personnalisés que vous avez.

Assurez-vous simplement d'appeler traverse()au JsonNodeniveau que vous souhaitez lire pour récupérer le JsonParserà passer 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;
    }

}

Il existe plusieurs façons de le faire, mais le faire correctement implique un peu plus de travail. Fondamentalement, vous ne pouvez pas utiliser de sous-classification, car les informations dont les désérialiseurs par défaut ont besoin sont construites à partir de définitions de classe.

Donc, ce que vous pouvez probablement utiliser est de construire un BeanDeserializerModifier, enregistrez-le via l' Moduleinterface (use SimpleModule). Vous devez définir / remplacermodifyDeserializer , et pour le cas spécifique où vous souhaitez ajouter votre propre logique (où le type correspond), construisez votre propre désérialiseur, passez le désérialiseur par défaut qui vous est donné. Et puis dansdeserialize() méthode, vous pouvez simplement déléguer l'appel, prendre le résultat Object.

Sinon, si vous devez réellement créer et remplir l'objet, vous pouvez le faire et appeler la version surchargée de deserialize() qui prend le troisième argument; objet dans lequel désérialiser.

Une autre façon de fonctionner (mais pas sûre à 100%) serait de spécifier Converterobject ( @JsonDeserialize(converter=MyConverter.class)). Il s'agit d'une nouvelle fonctionnalité de Jackson 2.2. Dans votre cas, Converter ne convertirait pas réellement le type, mais simplifierait la modification de l'objet: mais je ne sais pas si cela vous permettrait de faire exactement ce que vous voulez, car le désérialiseur par défaut serait appelé en premier, et seulement ensuite votre Converter.

S'il vous est possible de déclarer une classe utilisateur supplémentaire, vous pouvez l'implémenter simplement en utilisant des annotations

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

}

Dans le sens de ce que Tomáš Záluský a suggéré , dans les cas où l'utilisation BeanDeserializerModifiern'est pas souhaitable, vous pouvez construire vous-même un désérialiseur par défaut BeanDeserializerFactory, bien qu'une configuration supplémentaire soit nécessaire. Dans le contexte, cette solution ressemblerait à ceci:

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

Voici un oneliner utilisant 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;
}

Et s'il vous plaît: Il n'est vraiment pas nécessaire d'utiliser une valeur de chaîne ou autre chose. Toutes les informations nécessaires sont fournies par JsonParser, alors utilisez-le.

Je n'étais pas d'accord avec l'utilisation BeanSerializerModifiercar cela oblige à déclarer des changements de comportement dans le ObjectMapperdésérialiseur central plutôt que dans le désérialiseur personnalisé lui-même et en fait, c'est une solution parallèle pour annoter la classe d'entité avec JsonSerialize. Si vous le ressentez de la même manière, vous apprécierez peut-être ma réponse ici: https://stackoverflow.com/a/43213463/653539

Une solution plus simple pour moi était simplement d'ajouter un autre bean de ObjectMapperet de l'utiliser pour désérialiser l'objet (grâce à https://stackoverflow.com/users/1032167/varren comment) - dans mon cas, j'étais intéressé soit à désérialiser son identifiant (un int) ou l'objet entier 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;
     }
}

pour chaque entité qui doit passer par un désérialiseur personnalisé, nous devons le configurer dans le ObjectMapperbean global de l'application Spring Boot dans mon cas (par exemple pour 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;
}

Vous êtes voué à l'échec si vous essayez de créer votre désérialiseur personnalisé à partir de zéro.

Au lieu de cela, vous devez obtenir l'instance de désérialiseur par défaut (entièrement configurée) via une instance personnalisée BeanDeserializerModifier, puis transmettre cette instance à votre classe de désérialiseur personnalisée:

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

Remarque: Cet enregistrement de module remplace l' @JsonDeserializeannotation, c'est-à-dire la Userclasse ouUser champs ne doivent plus être annotés avec cette annotation.

Le désérialiseur personnalisé doit alors être basé sur un DelegatingDeserializerafin que toutes les méthodes soient déléguées, sauf si vous fournissez une implémentation explicite:

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

L'utilisation BeanDeserializerModifierfonctionne bien, mais si vous avez besoin d'utiliser, JsonDeserializeil existe un moyen de le faire AnnotationIntrospector comme ceci:

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

Maintenant, le mappeur copié ignorera votre désérialiseur personnalisé (MyDeserializer.class) et utilisera l'implémentation par défaut. Vous pouvez l'utiliser dans la deserializeméthode de votre désérialiseur personnalisé pour éviter la récursivité en rendant le mappeur copié statique ou en le câblant si vous utilisez Spring.