web-dev-qa-db-fra.com

Ignorer de nouveaux champs sur des objets JSON à l'aide de Jackson

J'utilise la bibliothèque Jackson JSON pour convertir certains objets JSON en classes POJO sur une application Android. Le problème est que les objets JSON peuvent changer et que de nouveaux champs sont ajoutés lors de la publication de l'application, mais actuellement, ils se briseront même lorsqu'un simple champ Chaîne est ajouté, ce qui peut être ignoré en toute sécurité.

Y a-t-il un moyen de dire à Jackson d'ignorer les champs récemment ajoutés? (par exemple, non existant sur les objets POJO)? Un ignorant global serait génial.

javajsonjackson
572
Hadi Eskandari

Jackson fournit une annotation qui peut être utilisée au niveau de la classe ( JsonIgnoreProperties ).

Ajoutez les éléments suivants en haut de votre classe ( et non à des méthodes individuelles):

@JsonIgnoreProperties(ignoreUnknown = true)
public class Foo {
    ...
}

En fonction de la version jackson que vous utilisez, vous devrez utiliser une importation différente dans la version actuelle:

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

dans les anciennes versions, il a été:

import org.codehaus.jackson.annotate.JsonIgnoreProperties;
814
Hadi Eskandari

Outre les 2 mécanismes déjà mentionnés, une fonctionnalité globale peut également être utilisée pour supprimer toutes les défaillances causées par des propriétés inconnues (non mappées):

// jackson 1.9 and before
objectMapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
// or jackson 2.0
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

Ceci est la valeur par défaut utilisée en l'absence d'annotations et peut constituer une solution de secours pratique.

421
StaxMan

Réponse à jour et complète avec Jackson 2

Utiliser l'annotation

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

@JsonIgnoreProperties(ignoreUnknown = true)
public class MyMappingClass {

}

Voir JsonIgnoreProperties sur la documentation en ligne de Jackson.

Utilisation de la configuration

Moins intrusif que l'annotation.

import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ObjectReader;

ObjectMapper objectMapper = new ObjectMapper();
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

ObjectReader objectReader = objectMapper.reader(MyMappingClass.class);
MyMappingClass myMappingClass = objectReader.readValue(json);

Voir FAIL_ON_UNKNOWN_PROPERTIES sur la documentation en ligne de Jackson.

109
Yves M.

il peut être réalisé de 2 manières:

  1. Marquer le POJO pour ignorer les propriétés inconnues

    @JsonIgnoreProperties(ignoreUnknown = true)

  2. Configurez ObjectMapper qui sérialise/désérialise le POJO/json comme ci-dessous:

    ObjectMapper mapper =new ObjectMapper();            
// for Jackson version 1.X        
mapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
// for Jackson version 2.X
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
78
Anamika

Si vous utilisez une classe pojo basée sur une réponse JSON. S'il y a des chances que les changements de json déclarent fréquemment au niveau de la classe pojo:

@JsonIgnoreProperties(ignoreUnknown = true)

et à l'objectMapper, ajoutez ceci si vous convertissez:

objectMapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);

Donc, ce code ne cassera pas.

26
user5636084

@JsonIgnoreProperties(ignoreUnknown = true) a bien fonctionné pour moi. J'ai une application Java qui s'exécute sur Tomcat avec jdk 1.7.

22
Parul

Assurez-vous de placer l'annotation @JsonIgnoreProperties(ignoreUnknown = true) dans la classe POJO parente que vous souhaitez renseigner à la suite de l'analyse de la réponse JSON et non dans la classe dans laquelle la conversion de JSON vers Java est en cours. endroit.

17
Rushi Shah

À partir de Jackson versions 2.4 et supérieures, certains changements ont eu lieu. Voici comment vous le faites maintenant:

import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;

.................................................. ........................

 ObjectMapper mapper = new ObjectMapper();
    // to prevent exception when encountering unknown property:
 mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);

Remarque: La solution basée sur @annotation reste la même. Si vous souhaitez l'utiliser, reportez-vous aux autres réponses.

For more information see the 10 minutes Configuration tutorial at:https://github.com/FasterXML/jackson-databind

17
Alboz

Comme indiqué ci-dessus, les annotations ne fonctionnent que si cela est spécifié dans la classe POJO parent et non dans la classe dans laquelle la conversion de JSON en objet Java a lieu.

L'autre alternative sans toucher à la classe parent et causer des perturbations est d'implémenter votre propre configuration de mappeur uniquement pour les méthodes de mappeur dont vous avez besoin pour cela.

Le package de la fonctionnalité de désérialisation a également été déplacé. DeserializationConfig.FAIL_ON_UNKNOWN_PROPERTIES à DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES

import org.codehaus.jackson.map.DeserializationConfig;
...
objectMapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
11
mekdev

Pour ceux qui utilisent Spring Boot, vous pouvez configurer le comportement par défaut de Jackson à l'aide de Jackson2ObjectMapperBuilder.

Par exemple :

@Bean
public Jackson2ObjectMapperBuilder configureObjectMapper() {
    Jackson2ObjectMapperBuilder oMapper = new Jackson2ObjectMapperBuilder();
    oMapper.failOnUnknownProperties(false);
    return oMapper;
}

Vous pouvez ensuite autoriser automatiquement le ObjectMapper partout où vous en avez besoin (par défaut, ce mappeur d’objets sera également utilisé pour la conversion de contenu http).

8
Thoomas

J'utilise jackson-xxx 2.8.5.Maven Dependency comme:

<dependencies>
    <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-core</artifactId>
        <version>2.8.5</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-annotations -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-annotations</artifactId>
        <version>2.8.5</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.8.5</version>
    </dependency>

</dependencies>

Tout d'abord, si vous souhaitez ignorer globalement les propriétés inconnues, vous pouvez configurer ObjectMapper.
Comme ci-dessous:

ObjectMapper objectMapper = new ObjectMapper();

objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

Si vous voulez ignorer une classe, vous pouvez ajouter une annotation @JsonIgnoreProperties(ignoreUnknown = true) sur votre classe comme:

@JsonIgnoreProperties(ignoreUnknown = true)
public class E1 {

    private String t1;

    public String getT1() {
        return t1;
    }

    public void setT1(String t1) {
        this.t1 = t1;
    }
}
7
inOut