com.fasterxml.jackson.databind.DeserializationContext Java Examples

@Override
public ColumnPartitionMetadata deserialize(JsonParser p, DeserializationContext ctxt)
    throws IOException {
  JsonNode jsonMetadata = p.getCodec().readTree(p);
  Set<Integer> partitions = new HashSet<>();
  JsonNode jsonPartitions = jsonMetadata.get(PARTITIONS_KEY);
  if (jsonPartitions != null) {
    // Integer format: "partitions":[0,1,5]
    for (JsonNode jsonPartition : jsonPartitions) {
      partitions.add(jsonPartition.asInt());
    }
  } else {
    // Legacy format: "partitionRanges":"[0 1],[5 5]"
    String partitionRanges = jsonMetadata.get(LEGACY_PARTITIONS_KEY).asText();
    for (String partitionRange : StringUtils.split(partitionRanges, LEGACY_PARTITION_DELIMITER)) {
      addRangeToPartitions(partitionRange, partitions);
    }
  }
  return new ColumnPartitionMetadata(jsonMetadata.get(FUNCTION_NAME_KEY).asText(),
      jsonMetadata.get(NUM_PARTITIONS_KEY).asInt(), partitions);
}
 

@SuppressWarnings("unchecked")
@Override
public Object deserialize(JsonParser p, DeserializationContext ctxt)
    throws IOException {
  if (_delegateDeserializer != null) {
    return (Collection<Object>) _valueInstantiator.createUsingDelegate(ctxt,
        _delegateDeserializer.deserialize(p, ctxt));
  }
  // Empty String may be ok; bit tricky to check, however, since
  // there is also possibility of "auto-wrapping" of single-element arrays.
  // Hence we only accept empty String here.
  if (p.hasToken(JsonToken.VALUE_STRING)) {
    String str = p.getText();
    if (str.length() == 0) {
      return (Collection<Object>) _valueInstantiator.createFromString(ctxt, str);
    }
  }
  return deserialize(p, ctxt, createDefaultInstance(ctxt));
}
 

@Override
public TargetWrapperDescriptor deserialize( JsonParser parser, DeserializationContext context ) throws IOException {

	ObjectCodec oc = parser.getCodec();
	JsonNode node = oc.readTree( parser );
	TargetWrapperDescriptor twd = new TargetWrapperDescriptor();

	JsonNode n;
	if(( n = node.get( DESC )) != null )
		twd.setDescription( n.textValue());

	if(( n = node.get( TARGET_HANDLER )) != null )
		twd.setHandler( n.textValue());

	if(( n = node.get( ID )) != null )
		twd.setId( n.textValue());

	if(( n = node.get( NAME )) != null )
		twd.setName( n.textValue());

	return twd;
}
 

@Override
    public StringMap deserialize(final JsonParser jp, final DeserializationContext ctxt) throws IOException,
            JsonProcessingException {

        // Sanity check: verify that we got "Json Object":
//        JsonToken tok = jp.nextToken();
//        if (tok != JsonToken.START_OBJECT) {
//            throw new IOException("Expected data to start with an Object");
//        }
        final StringMap contextData = ContextDataFactory.createContextData();
        // Iterate over object fields:
        while (jp.nextToken() != JsonToken.END_OBJECT) {
            final String fieldName = jp.getCurrentName();

            // move to value
            jp.nextToken();
            contextData.putValue(fieldName, jp.getText());
        }
        return contextData;
    }
 

@Override
public DeviceRenderTypeMap deserialize( JsonParser jsonParser, DeserializationContext deserializationContext )
    throws IOException
{
    DeviceRenderTypeMap<T>  deviceRenderTypeMap = new DeviceRenderTypeMap<>();
    LinkedHashMap<String, LinkedHashMap<String,String>> map = jsonParser
        .readValueAs( new TypeReference<LinkedHashMap<String, LinkedHashMap<String,String>>>() {} );

    for( String renderDevice : map.keySet() )
    {
        LinkedHashMap<String,String> renderObjectMap = map.get( renderDevice );
        T renderingObject = serializeObject.get();
        renderingObject.setType( Enum.valueOf( renderingObject.getRenderTypeClass(), renderObjectMap.get( RenderingObject._TYPE ) ) );
        deviceRenderTypeMap.put( RenderDevice.valueOf( renderDevice ), renderingObject );
    }

    return deviceRenderTypeMap;
}
 

@Override
public SourceForgeSearchResult deserialize(JsonParser parser,
        DeserializationContext context) throws IOException,
        JsonProcessingException {
    ObjectCodec oc = parser.getCodec();
    JsonNode node = oc.readTree(parser);

    SourceForgeSearchResult result = new SourceForgeSearchResult();

    result.setCount(node.get("count").asInt());

    Iterator<JsonNode> tickets = node.path("tickets").iterator();
    while (tickets.hasNext()) {
        JsonNode ticket = tickets.next();
        result.addTicketId(ticket.get("ticket_num").asInt());
    }

    return result;
}
 

protected ObjectNode deserializeObjectNode(JsonParser p, DeserializationContext context, JsonLocation startLocation)
        throws IllegalArgumentException, IOException {

    final Model model = (Model) context.getAttribute(ATTRIBUTE_MODEL);
    final AbstractNode parent = (AbstractNode) context.getAttribute(ATTRIBUTE_PARENT);
    final JsonPointer ptr = (JsonPointer) context.getAttribute(ATTRIBUTE_POINTER);

    final ObjectNode node = model.objectNode(parent, ptr);
    node.setStartLocation(createLocation(startLocation));

    while (p.nextToken() != JsonToken.END_OBJECT) {
        String name = p.getCurrentName();

        JsonPointer pp = JsonPointer.compile(ptr.toString() + "/" + name.replaceAll("/", "~1"));
        context.setAttribute(ATTRIBUTE_PARENT, node);
        context.setAttribute(ATTRIBUTE_POINTER, pp);

        AbstractNode v = deserialize(p, context);
        v.setProperty(name);
        node.put(name, v);
    }

    node.setEndLocation(createLocation(p.getCurrentLocation()));
    return node;
}
 

public static JsonDeserializer<?> findForMap(DeserializationContext ctxt,
        JavaType type)
    throws JsonMappingException
{
    JavaUtilCollectionsConverter conv;

    // 10-Jan-2017, tatu: Some types from `java.util.Collections`/`java.util.Arrays` need bit of help...
    if (type.hasRawClass(CLASS_SINGLETON_MAP)) {
        conv = converter(TYPE_SINGLETON_MAP, type, Map.class);
    } else if (type.hasRawClass(CLASS_UNMODIFIABLE_MAP)) {
        conv = converter(TYPE_UNMODIFIABLE_MAP, type, Map.class);
    } else {
        return null;
    }
    return new StdDelegatingDeserializer<Object>(conv);
}
 

@Test
public void testNanDeserializer() throws IOException {
  ObjectMapper mapper = new ObjectMapper();
  String json = "{ \"theta\":  \"NAN\"}";

  try (InputStream stream = new ByteArrayInputStream(json.getBytes(StandardCharsets.UTF_8))){
    JsonParser parser = mapper.getFactory().createParser(stream);
    DeserializationContext ctxt = mapper.getDeserializationContext();
    BigDecimalNanDeserializer deserializer = new BigDecimalNanDeserializer();
    parser.nextToken();
    parser.nextToken();
    parser.nextToken();

    final BigDecimal deserialized = deserializer.deserialize(parser, ctxt);
    LOGGER.debug("NAN -> {}", deserialized);
    assertThat(deserialized).isEqualTo("0");
  }
}
 

@Override
protected MetadataRequest doRequestDeserialize(JsonParser jparser, DeserializationContext ctxt, FederatedIdentity identity, String queryId, String catalogName)
        throws IOException
{
    assertFieldName(jparser, TABLE_NAME_FIELD);
    TableName tableName = tableNameDeserializer.deserialize(jparser, ctxt);

    assertFieldName(jparser, CONSTRAINTS_FIELD);
    Constraints constraints = constraintsDeserializer.deserialize(jparser, ctxt);

    assertFieldName(jparser, SCHEMA_FIELD);
    Schema schema = schemaDeserializer.deserialize(jparser, ctxt);

    ImmutableSet.Builder<String> partitionColsSet = ImmutableSet.builder();
    partitionColsSet.addAll(getNextStringArray(jparser, PARTITION_COLS_FIELD));

    return new GetTableLayoutRequest(identity, queryId, catalogName, tableName, constraints, schema, partitionColsSet.build());
}
 

@Override
public Date deserialize(final JsonParser parser, final DeserializationContext context) throws IOException
{
    SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssX");

    final String date = parser.getText();
    try
    {
        return formatter.parse(date);
    }
    catch (final ParseException ex)
    {
        // Not worked, so let the default date serializer give it a try.
        return DateDeserializer.instance.deserialize(parser, context);
    }
}
 

@Override
public Artifact deserialize(JsonParser parser, DeserializationContext ctxt) 
  throws IOException, JsonProcessingException 
{
    JsonNode node = parser.readValueAsTree();
    ObjectMapper mapper = (ObjectMapper)parser.getCodec();
    ObjectReader reader = null; 
    Object target = null;
    String artifcatType = node.get("artifactType").asText();

    System.out.println(artifcatType);

    if(artifcatType.equalsIgnoreCase("reservedinstance"))
    {
        reader = mapper.readerFor(ReservedInstanceArtifact.class);
    }
    else 
    {
        reader = mapper.readerFor(Artifact.class);
    }

    target = reader.readValue(node);

    return (Artifact)target;
}
 

@Override
public Object findInjectableValue(Object valueId, DeserializationContext ctxt,
                                  BeanProperty forProperty, Object beanInstance) {
    if ("locales".equals(valueId)) {
        return locales;
    }
    if ("ip_address".equals(valueId)) {
        return ip;
    }
    if ("network".equals(valueId)) {
        return network;
    }
    if ("traits".equals(valueId)) {
        return new Traits(ip, network);
    }
    return null;
}
 

@Override
public Date deserialize(JsonParser paramJsonParser, DeserializationContext paramDeserializationContext)
        throws IOException {
    if (paramJsonParser == null || "".equals(paramJsonParser.getText()))
        return null;
    String date = paramJsonParser.getText();

    for (String format : DATE_FORMATS) {
        try {
            return new SimpleDateFormat(format, Locale.US).parse(date);
        } catch (ParseException e) {
            //This page was left blank intentionally
        }
    }
    throw new IOException("Could not parse date '" + date + "'");
}
 

/**
 * Demonstrates how to do recursive polymorphic JSON deserialization in Jackson 2.2.
 *
 * Aka specify a Deserializer and "catch" some input, determine what type of Class it
 *  should be parsed too, and then reuse the Jackson infrastructure to recursively do so.
 */
@Override
public QueryFilter deserialize(JsonParser jp, DeserializationContext ctxt)
        throws IOException {

    ObjectNode root = jp.readValueAsTree();

    JsonNode queryParam = root.get("queryParam");
    String value = queryParam.asText();

    // pass in our objectCodec so that the subJsonParser knows about our configured Modules and Annotations
    JsonParser subJsonParser = root.traverse( jp.getCodec() );

    // Determine the "type" of filter we are dealing with Real or Logical and specify type
    if ( "OR".equals( value ) || "AND".equals( value ) ) {
        return subJsonParser.readValueAs( LogicalFilter1.class );
    }
    else {
        return subJsonParser.readValueAs( RealFilter.class );
    }
}
 

@Override
public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException {
    final Class<?> classToDeserialize;
    if (property != null) {
        final JavaType type = property.getType();
        classToDeserialize = type.isContainerType() ? type.getContentType().getRawClass() : type.getRawClass();
    } else {
        classToDeserialize = ctxt.getContextualType().getRawClass();
    }

    return new ClassWithInterfaceFieldsDeserializer(classToDeserialize.getName());
}
 

/**
 * Because the GooglePlus Activity object {@link com.google.api.services.plus.model.Activity} contains complex objects
 * within its hierarchy, we have to use a custom deserializer
 *
 * @param jsonParser jsonParser
 * @param deserializationContext deserializationContext
 * @return The deserialized {@link com.google.api.services.plus.model.Activity} object
 * @throws IOException IOException
 * @throws JsonProcessingException JsonProcessingException
 */
@Override
public Activity deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException {

  JsonNode node = jsonParser.getCodec().readTree(jsonParser);
  Activity activity = new Activity();

  try {
    activity.setUrl(node.get("url").asText());
    activity.setEtag(node.get("etag").asText());
    if( node.has("title") ) {
      activity.setTitle(node.get("title").asText());
    }
    activity.setPublished(DateTime.parseRfc3339(node.get("published").asText()));
    activity.setUpdated(DateTime.parseRfc3339(node.get("updated").asText()));
    activity.setId(node.get("id").asText());
    activity.setVerb(node.get("verb").asText());

    activity.setActor(buildActor(node));

    activity.setObject(buildPlusObject(node));
  } catch (Exception ex) {
    LOGGER.error("Exception while trying to deserialize activity object: {}", ex);
  }

  return activity;
}
 

@Override
public Object deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
	JsonStreamContext jsonStreamContext = p.getParsingContext().getParent();
	InnerSearchHit hit = (InnerSearchHit) jsonStreamContext.getCurrentValue();
	ESClass refs = null;
	if(hit != null) {
		if (hit.getIndex() == null) {
			refs = getESInnerTypeReferences(hit.getType());
		} else {
			refs = getESInnerTypeReferences(getTypeName(p));
		}
	}
	if(refs == null){
		return ctxt.findRootValueDeserializer(ESSerialThreadLocal.getMapObjectType()).deserialize(p,ctxt);
	}
	else
	{
		if(refs instanceof ESTypeReferences)
			return ctxt.findRootValueDeserializer(ESSerialThreadLocal.getJavaType(((ESTypeReferences)refs).getHitType())).deserialize(p,ctxt);
		else
		{
			ESClassType classType = (ESClassType)refs;
			return ctxt.findRootValueDeserializer(ESSerialThreadLocal.getJavaType(classType.getHitClass())).deserialize(p,ctxt);

		}
	}


}
 

private Jackson2Tokenizer(
		JsonParser parser, DeserializationContext deserializationContext, boolean tokenizeArrayElements) {

	this.parser = parser;
	this.deserializationContext = deserializationContext;
	this.tokenizeArrayElements = tokenizeArrayElements;
	this.tokenBuffer = new TokenBuffer(parser, deserializationContext);
	this.inputFeeder = (ByteArrayFeeder) this.parser.getNonBlockingInputFeeder();
}
 

@Override
public OrgDetails deserialize(
        JsonParser jsonParser, DeserializationContext deserializationContext)
        throws IOException {
    if (jsonParser.getCurrentToken() != JsonToken.VALUE_NULL) {
        return om.readValue(jsonParser, OrgDetails.class);
    } else {
        return null;
    }
}
 

@Override
protected YearMonth deserialize(String key, DeserializationContext ctxt) throws IOException {
    try {
        return YearMonth.parse(key, FORMATTER);
    } catch (DateTimeException e) {
        return _handleDateTimeException(ctxt, YearMonth.class, e, key);
    }
}
 

private Object readEncoded(JsonParser p, DeserializationContext ctxt) throws IOException {
    if (!p.isExpectedStartArrayToken()) {
        throw new JsonParseException(p, "Expected array for encoded object got " + p.currentToken());
    }

    Object value = null;
    JsonToken next = p.nextToken();
    if (next != JsonToken.VALUE_STRING) {
        throw new JsonParseException(p, "Encoded Class value not present " + next);
    }
    String typeName = p.getText();
    p.nextToken(); // fwd to next
    ClassLoader loader = Thread.currentThread().getContextClassLoader();
    if (loader == null) {
        loader = getClass().getClassLoader();
    }
    try {
        Class<?> type = loader.loadClass(typeName);
        if (Collection.class.isAssignableFrom(type)) {
            value = readCollection(type, p, ctxt);
        } else if (Map.class.isAssignableFrom(type)) {
            value = readMap(type, p, ctxt);
        } else {
            JsonDeserializer<Object> deser = ctxt.findRootValueDeserializer(ctxt.constructType(type));
            value = deser.deserialize(p, ctxt);
        }
    } catch (ClassNotFoundException e) {
        throw new JsonParseException(p, "Type name encoded " + typeName + " could not be loaded", e);
    }
    if (p.nextToken() != JsonToken.END_ARRAY) {
        throw new JsonParseException(p, "Encoded expected end of ARRAY marker " + p.currentToken());
    }
    return value;
}
 

@Override
public HiveProxyingOrcScanFilter deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
  // TODO: Optimize performance as described in https://dremio.atlassian.net/browse/DX-17732
  final JsonNode node = jsonParser.getCodec().readTree(jsonParser);

  final String pluginName = node.get(HiveProxyingOrcScanFilter.JSON_PROP_PLUGINNAME).asText();
  final CatalogService catalogService = (CatalogService) deserializationContext
    .findInjectableValue(CatalogService.class.getName(), null, null);

  final StoragePluginCreator.PF4JStoragePlugin plugin = catalogService.getSource(pluginName);
  final Class<? extends HiveProxiedOrcScanFilter> scanClazz = plugin.getOrcScanFilterClass();

  final JavaType scanType = deserializationContext.getTypeFactory().constructType(scanClazz);
  final BasicBeanDescription description = deserializationContext.getConfig().introspect(scanType);
  final JsonDeserializer<Object> orcScanFilterDeserializer = deserializationContext.getFactory().createBeanDeserializer(
    deserializationContext, scanType, description);

  if (orcScanFilterDeserializer instanceof ResolvableDeserializer) {
    ((ResolvableDeserializer) orcScanFilterDeserializer).resolve(deserializationContext);
  }

  final JsonParser movedParser = jsonParser.getCodec().treeAsTokens(node.get(HiveProxyingOrcScanFilter.JSON_PROP_WRAPPEDHIVEORCSCANFILTER));
  deserializationContext.getConfig().initialize(movedParser);

  if (movedParser.getCurrentToken() == null) {
    movedParser.nextToken();
  }

  final HiveProxiedOrcScanFilter orcScanFilter = (HiveProxiedOrcScanFilter) orcScanFilterDeserializer.deserialize(movedParser, deserializationContext);
  return new HiveProxyingOrcScanFilter(pluginName, orcScanFilter);
}
 

@Override
public WritableAgent.ReportLocation deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException {
    int report = jsonParser.getIntValue();
    if (1 == report)
        return WritableAgent.ReportLocation.ONLY_IN_SESSION;
    else if (2 == report)
        return WritableAgent.ReportLocation.ALWAYS;
    else
        return WritableAgent.ReportLocation.NO;
}
 

/**
 * {@inheritDoc}
 */
@Override
public CertPath deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {

    ObjectCodec oc = p.getCodec();
    ArrayNode node = oc.readTree(p);
    List<Certificate> list = new ArrayList<>();
    for (JsonNode item : node) {
        X509Certificate certificate = oc.treeToValue(item, X509Certificate.class);
        list.add(certificate);
    }
    return CertificateUtil.generateCertPath(list);
}
 

@Override
public Filter deserialize(JsonParser p, DeserializationContext ctx) throws IOException {
    final String type = p.nextTextValue();

    if (p.nextToken() != JsonToken.END_ARRAY) {
        throw ctx.wrongTokenException(p, JsonToken.END_ARRAY, null);
    }

    return new TypeFilter(type);
}
 

@Override
public M deserialize(final JsonParser parser, final DeserializationContext context) throws IOException {
    BigDecimal amount = null;
    CurrencyUnit currency = null;

    while (parser.nextToken() != JsonToken.END_OBJECT) {
        final String field = parser.getCurrentName();

        parser.nextToken();

        if (field.equals(names.getAmount())) {
            amount = context.readValue(parser, BigDecimal.class);
        } else if (field.equals(names.getCurrency())) {
            currency = context.readValue(parser, CurrencyUnit.class);
        } else if (field.equals(names.getFormatted())) {
            //noinspection UnnecessaryContinue
            continue;
        } else if (context.isEnabled(FAIL_ON_UNKNOWN_PROPERTIES)) {
            throw UnrecognizedPropertyException.from(parser, MonetaryAmount.class, field,
                    Arrays.asList(names.getAmount(), names.getCurrency(), names.getFormatted()));
        } else {
            parser.skipChildren();
        }
    }

    checkPresent(parser, amount, names.getAmount());
    checkPresent(parser, currency, names.getCurrency());

    return factory.create(amount, currency);
}
 

@Override
public GroupDTO[] deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
  ObjectCodec oc = p.getCodec();
  ArrayNode node = oc.readTree(p);
  GroupDTO[] groups = new GroupDTO[node.size()];
  for (int i = 0; i < node.size(); i++) {
    JsonNode current = node.get(i);
    groups[i] = new GroupDTO();
    groups[i].setId(Long.parseLong(current.get("value").asText()));
    groups[i].setDisplay(current.get("display").asText());
  }
  return groups;
}
 

@Override
public BarExt deserializeAndUpdate(JsonParser jsonParser, DeserializationContext deserializationContext, BarExt parameters) throws IOException {
    ObjectMapper objectMapper = createMapper();
    ObjectReader objectReader = objectMapper.readerForUpdating(parameters);
    BarExt updatedParameters = objectReader.readValue(jsonParser, BarExt.class);
    return updatedParameters;
}
 

@Override
public Object deserializeKey(String className, DeserializationContext context) throws IOException {
    try {
        return Class.forName(className);
    } catch (ClassNotFoundException e) {
        throw new IOException(String.format("could not find class %s", className));
    }
}