Java 类com.fasterxml.jackson.databind.deser.DeserializationProblemHandler 实例源码

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