unknown - java objectmapper ignore unrecognized field



Ignorando nuevos campos en objetos JSON usando Jackson (8)

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

https://src-bin.com

Esta pregunta ya tiene una respuesta aquí:

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

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

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

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

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

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

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

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





jackson