java - unrecognized - not marked as ignorable 0 known properties])

Ignorando nuevos campos en objetos JSON usando Jackson

Question

Esta pregunta ya tiene una respuesta aquí:

• Jackson con JSON: campo no reconocido, no marcado como ignorable 32 respuestas

Estoy utilizando la biblioteca Jackson JSON para convertir algunos objetos JSON en clases POJO en una aplicación de Android. El problema es que los objetos JSON pueden cambiar y agregar nuevos campos mientras se publica la aplicación, pero actualmente se romperá incluso cuando se agregue un campo String simple, que se puede ignorar de forma segura.

¿Hay alguna manera de decirle a Jackson que ignore los campos recién agregados? (por ejemplo, no existente en los objetos POJO)? Un ignorar global sería genial.

Answer 1

A partir de la versión 2.4 de Jackson y superior, ha habido algunos cambios. Aquí es cómo lo haces ahora:

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

Nota: La solución basada en @annotation sigue siendo la misma, así que si desea utilizarla, consulte las otras respuestas.

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

Answer 2

Actualizada y completa respuesta con Jackson 2.

Usando la anotación

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

@JsonIgnoreProperties(ignoreUnknown = true)
public class MyMappingClass {

}

Consulte JsonIgnoreProperties en la documentación en línea de Jackson.

Utilizando la configuración

Menos intrusivo que la anotación.

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

Consulte FAIL_ON_UNKNOWN_PROPERTIES en la documentación en línea de Jackson.

Answer 3

Además, dos mecanismos ya mencionados, también hay una característica global que se puede usar para suprimir todos los fallos causados ​​por propiedades desconocidas (no asignadas):

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

Este es el valor predeterminado que se utiliza en ausencia de anotaciones, y puede ser conveniente para el respaldo.

Answer 4

Asegúrese de colocar la @JsonIgnoreProperties(ignoreUnknown = true) en la clase POJO principal que desea rellenar como resultado del análisis de la respuesta JSON y no la clase en la que se realiza la conversión de JSON a Java Object.

Answer 5

Como se indicó anteriormente, las anotaciones solo funcionan si esto se especifica en la clase POJO principal y no en la clase en la que se lleva a cabo la conversión de JSON a Java Object.

La otra alternativa sin tocar la clase principal y causar interrupciones es implementar su propia configuración del asignador solo para los métodos del asignador que necesita para esto.

También se ha movido el paquete de la característica Deserialización. DeserializationConfig.FAIL_ON_UNKNOWN_PROPERTIES a DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES

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

Answer 6

Estoy usando jackson-xxx 2.8.5. Dependencia de Maven como:

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

Primero, si desea ignorar globalmente las propiedades desconocidas, puede configurar ObjectMapper .
Como abajo:

ObjectMapper objectMapper = new ObjectMapper();

objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

Si desea ignorar alguna clase, puede agregar la anotación @JsonIgnoreProperties(ignoreUnknown = true) en su clase como:

@JsonIgnoreProperties(ignoreUnknown = true)
public class E1 {

    private String t1;

    public String getT1() {
        return t1;
    }

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

Answer 7

Jackson proporciona una anotación que se puede usar en el nivel de clase ( JsonIgnoreProperties ).

Agregue lo siguiente a la parte superior de su clase ( no a métodos individuales):

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

Dependiendo de la versión de jackson que esté utilizando, tendría que usar una importación diferente en la versión actual:

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

en versiones anteriores ha sido:

import org.codehaus.jackson.annotate.JsonIgnoreProperties;

Answer 8

Para quienes utilizan Spring Boot, puede configurar el comportamiento predeterminado de Jackson utilizando Jackson2ObjectMapperBuilder .

Por ejemplo :

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

Luego, puede conectar automáticamente el ObjectMapper donde lo necesite (de forma predeterminada, este mapeador de objetos también se utilizará para la conversión de contenido http).

Answer 9

Puede anotar la propiedad específica en su POJO con @JsonIgnore.

Answer 10

Se puede lograr de 2 maneras:

1. Marque el POJO para ignorar propiedades desconocidas

   @JsonIgnoreProperties(ignoreUnknown = true)

2. Configure ObjectMapper que serializa / des-serializa el POJO / json de la siguiente manera:

   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) 

Answer 11

Si usa una clase pojo basada en la respuesta JSON. Si es probable que los cambios de json se declaren con frecuencia en el nivel de clase pojo:

@JsonIgnoreProperties(ignoreUnknown = true)

y en el objectMapper agregue esto si está convirtiendo:

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

Así que ese código no se romperá.

Answer 12

@JsonIgnoreProperties(ignoreUnknown = true) funcionó bien para mí. Tengo una aplicación java que se ejecuta en Tomcat con jdk 1.7.