Ignorar nuevos campos en objetos JSON usando Jackson

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

// 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 usa en ausencia de anotaciones, y puede ser una alternativa conveniente.

Respuesta actualizada y completa con Jackson 2

Usando Anotación

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

@JsonIgnoreProperties(ignoreUnknown = true)
public class MyMappingClass {

}

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

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

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

Se puede lograr de 2 maneras:

1. Marque el POJO para ignorar propiedades desconocidas

   @JsonIgnoreProperties(ignoreUnknown = true)
   

2. Configure ObjectMapper que serializa / De-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) 
   

Si se utiliza una clase pojo basada en la respuesta JSON. Si hay posibilidades de que los cambios json se declaren con frecuencia a 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);

Para que ese código no se rompa.

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

A partir de Jackson versión 2.4 y superior ha habido algunos cambios. Así es como 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 @anotación sigue siendo la misma, por lo que si desea usar eso, vea las otras respuestas.

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

Como se indicó anteriormente, las anotaciones solo funcionan si esto se especifica en la clase padre POJO y no en la clase donde se realiza la conversión de JSON a Java Object.

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

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

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

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

Estoy usando jackson-xxx 2.8.5.Maven Dependencia 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 propiedades desconocidas globalmente.puede configurar ObjectMapper.
Como abajo:

ObjectMapper objectMapper = new ObjectMapper();

objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

Si desea ignorar alguna clase, puede agregar una 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;
    }
}

Para quienes usan Spring Boot, puede configurar el comportamiento predeterminado de Jackson usando Jackson2ObjectMapperBuilder.

Por ejemplo:

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

Entonces 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).

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