/** * Create a DeserializationProblemHandler that may be added to an * ObjectMapper, and will handle unknown properties by forwarding * the error information to the given consumer, if it is not * <code>null</code> * * @param jsonErrorConsumer The consumer for {@link JsonError}s * @return The problem handler */ private static DeserializationProblemHandler createDeserializationProblemHandler( Consumer<? super JsonError> jsonErrorConsumer) { return new DeserializationProblemHandler() { @Override public boolean handleUnknownProperty( DeserializationContext ctxt, JsonParser jp, JsonDeserializer<?> deserializer, Object beanOrClass, String propertyName) throws IOException, JsonProcessingException { if (jsonErrorConsumer != null) { jsonErrorConsumer.accept(new JsonError( "Unknown property: " + propertyName, jp.getParsingContext(), null)); } return super.handleUnknownProperty( ctxt, jp, deserializer, beanOrClass, propertyName); } }; }
protected XmlMapper getXmlMapper() { final XmlMapper xmlMapper = new XmlMapper( new XmlFactory(new InputFactoryImpl(), new OutputFactoryImpl()), new JacksonXmlModule()); xmlMapper.setInjectableValues(new InjectableValues.Std().addValue(ODataClient.class, client)); xmlMapper.addHandler(new DeserializationProblemHandler() { @Override public boolean handleUnknownProperty(final DeserializationContext ctxt, final JsonParser jp, final JsonDeserializer<?> deserializer, final Object beanOrClass, final String propertyName) throws IOException, JsonProcessingException { // skip any unknown property LOG.warn("Skipping unknown property {}", propertyName); ctxt.getParser().skipChildren(); return true; } }); return xmlMapper; }
protected XmlMapper getXmlMapper() { final XmlMapper xmlMapper = new XmlMapper( new XmlFactory(new InputFactoryImpl(), new OutputFactoryImpl()), new JacksonXmlModule()); xmlMapper.setInjectableValues(new InjectableValues.Std().addValue(Boolean.class, Boolean.FALSE)); xmlMapper.addHandler(new DeserializationProblemHandler() { @Override public boolean handleUnknownProperty(final DeserializationContext ctxt, final JsonParser jp, final com.fasterxml.jackson.databind.JsonDeserializer<?> deserializer, final Object beanOrClass, final String propertyName) throws IOException, JsonProcessingException { // skip any unknown property ctxt.getParser().skipChildren(); return true; } }); return xmlMapper; }
private static void setupMapper(ObjectMapper mapper) { // Serialize dates using ISO8601 format // Jackson uses timestamps by default, so use StdDateFormat to get ISO8601 mapper.getSerializationConfig().with(new StdDateFormat()); // Deserialize dates using ISO8601 format mapper.getDeserializationConfig().with(new StdDateFormat()); // Prevent exceptions from being thrown for unknown properties // mapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, // false); mapper.addHandler(new DeserializationProblemHandler() { @Override public boolean handleUnknownProperty(DeserializationContext ctxt, JsonParser jp, JsonDeserializer<?> deserializer, Object beanOrClass, String propertyName) throws IOException, JsonProcessingException { return true; } }); // ignore fields with null values mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL); }
public static Edmx toMetadata(final InputStream input) { try { final XmlMapper xmlMapper = new XmlMapper( new XmlFactory(new InputFactoryImpl(), new OutputFactoryImpl()), new JacksonXmlModule()); xmlMapper.addHandler(new DeserializationProblemHandler() { @Override public boolean handleUnknownProperty(final DeserializationContext ctxt, final JsonParser jp, final JsonDeserializer<?> deserializer, final Object beanOrClass, final String propertyName) throws IOException, JsonProcessingException { // 1. special handling of AbstractAnnotatedEdm's fields if (beanOrClass instanceof AbstractAnnotatedEdm && AbstractAnnotatedEdmUtils.isAbstractAnnotatedProperty(propertyName)) { AbstractAnnotatedEdmUtils.parseAnnotatedEdm((AbstractAnnotatedEdm) beanOrClass, jp); } // 2. skip any other unknown property else { ctxt.getParser().skipChildren(); } return true; } }); return xmlMapper.readValue(input, Edmx.class); } catch (Exception e) { throw new IllegalArgumentException("Could not parse as Edmx document", e); } }
private DeserializationProblemHandler alwaysRepondWith(final boolean value) { return new DeserializationProblemHandler() { @Override public boolean handleUnknownProperty(final DeserializationContext context, final JsonParser parser, final JsonDeserializer<?> deserializer, final Object beanOrClass, final String propertyName) { return value; } }; }
private DeserializationConfig(DeserializationConfig paramDeserializationConfig, LinkedNode<DeserializationProblemHandler> paramLinkedNode) { super(paramDeserializationConfig); this._deserFeatures = paramDeserializationConfig._deserFeatures; this._problemHandlers = paramLinkedNode; this._nodeFactory = paramDeserializationConfig._nodeFactory; }
public boolean handleUnknownProperty(JsonParser paramJsonParser, JsonDeserializer<?> paramJsonDeserializer, Object paramObject, String paramString) { LinkedNode localLinkedNode1 = this._config.getProblemHandlers(); LinkedNode localLinkedNode2 = localLinkedNode1; if (localLinkedNode1 != null) while (localLinkedNode2 != null) { if (((DeserializationProblemHandler)localLinkedNode2.value()).handleUnknownProperty(this, paramJsonParser, paramJsonDeserializer, paramObject, paramString)) return true; localLinkedNode2 = localLinkedNode2.next(); } return false; }
private DeserializationConfig(DeserializationConfig src, LinkedNode<DeserializationProblemHandler> problemHandlers) { super(src); _deserFeatures = src._deserFeatures; _problemHandlers = problemHandlers; _nodeFactory = src._nodeFactory; }
/** * Method that can be used to add a handler that can (try to) * resolve non-fatal deserialization problems. */ public DeserializationConfig withHandler(DeserializationProblemHandler h) { // Sanity check: let's prevent adding same handler multiple times if (LinkedNode.contains(_problemHandlers, h)) { return this; } return new DeserializationConfig(this, new LinkedNode<DeserializationProblemHandler>(h, _problemHandlers)); }
/** * Method for removing all configured problem handlers; usually done to replace * existing handler(s) with different one(s) */ public DeserializationConfig withNoProblemHandlers() { if (_problemHandlers == null) { return this; } return new DeserializationConfig(this, (LinkedNode<DeserializationProblemHandler>) null); }
public ObjectReader withHandler(DeserializationProblemHandler paramDeserializationProblemHandler) { return _with(this._config.withHandler(paramDeserializationProblemHandler)); }
public final LinkedNode<DeserializationProblemHandler> getProblemHandlers() { return this._problemHandlers; }
public final DeserializationConfig withHandler(DeserializationProblemHandler paramDeserializationProblemHandler) { if (LinkedNode.contains(this._problemHandlers, paramDeserializationProblemHandler)) return this; return new DeserializationConfig(this, new LinkedNode(paramDeserializationProblemHandler, this._problemHandlers)); }
public ObjectReader withHandler(DeserializationProblemHandler h) { return _with(_config.withHandler(h)); }
/** * Method for getting head of the problem handler chain. May be null, * if no handlers have been added. */ public LinkedNode<DeserializationProblemHandler> getProblemHandlers() { return _problemHandlers; }
/** * Add a deserialization problem handler * * @param handler The deserialization problem handler */ public void addDeserializationProblemHandler(DeserializationProblemHandler handler);
public abstract void addDeserializationProblemHandler(DeserializationProblemHandler paramDeserializationProblemHandler);