@Override public CoinbaseCurrency deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { ObjectCodec oc = jp.getCodec(); JsonNode node = oc.readTree(jp); String name = node.get("name").asText(); String id = node.get("id").asText(); return new CoinbaseCurrency(name, id); } }
private String getTypeName(JsonNode node) { if (node.has("type") && node.get("type").isArray() && node.get("type").size() > 0) { for (JsonNode jsonNode : node.get("type")) { String typeName = jsonNode.asText(); if (!typeName.equals("null")) { return typeName; } } } if (node.has("type") && node.get("type").isTextual()) { return node.get("type").asText(); } return DEFAULT_TYPE_NAME; }
String x = "{'candidateId':'k','candEducationId':1,'activitiesSocieties':'Activities for cand1'}"; ObjectMapper mapper = new ObjectMapper(); mapper.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true); JsonNode df = mapper.readValue(x, JsonNode.class); System.out.println(df.toString()); // output: {"candidateId":"k","candEducationId":1,"activitiesSocieties":"Activities for cand1"}
private static Object convert(JsonNode value) { if (value.isArray()) { List<String> retvalList = new ArrayList<>(); for (JsonNode arrayElement : value) retvalList.add(arrayElement.asText()); return retvalList; } return value.getNodeType() == JsonNodeType.NUMBER ? value.numberValue() : value.asText(); }
private void doInstanceInfoCompactEncodeDecode(AbstractEurekaJacksonCodec codec, boolean isJson) throws Exception { InstanceInfo instanceInfo = infoIterator.next(); String encodedString = codec.getObjectMapper(InstanceInfo.class).writeValueAsString(instanceInfo); if (isJson) { JsonNode metadataNode = new ObjectMapper().readTree(encodedString).get("instance").get("metadata"); assertThat(metadataNode, is(nullValue())); } InstanceInfo decodedValue = codec.getObjectMapper(InstanceInfo.class).readValue(encodedString, InstanceInfo.class); assertThat(decodedValue.getId(), is(equalTo(instanceInfo.getId()))); assertThat(decodedValue.getMetadata().isEmpty(), is(true)); }
throws IOException, JsonProcessingException { ObjectCodec oc = jp.getCodec(); JsonNode node = oc.readTree(jp); if (node.isObject()) { String id = node.get("id").asText(); String name = node.get("name").asText(); String symbol = node.get("symbol").asText(); String websiteSlug = node.get("website_slug").asText(); Date lastUpdated = new Date(node.get("last_updated").asLong() * 1000); BigDecimal rank = new BigDecimal(node.get("rank").asInt()); BigDecimal circulatingSupply = new BigDecimal(node.get("circulating_supply").asDouble()); BigDecimal totalSupply = new BigDecimal(node.get("total_supply").asDouble()); BigDecimal maxSupply = new BigDecimal(node.get("max_supply").asDouble()); ObjectMapper mapper = new ObjectMapper(); SimpleModule module = new SimpleModule(); module.addDeserializer( CoinMarketCapQuote.class, new CoinMarketCapQuote.CoinMarketCapQuoteDeserializer()); mapper.registerModule(module); Iterator<Map.Entry<String, JsonNode>> it = node.get("quotes").fields(); while (it.hasNext()) { Map.Entry<String, JsonNode> pair = it.next(); quotes.put(pair.getKey(), mapper.treeToValue(pair.getValue(), CoinMarketCapQuote.class));
@Override public CoinMarketCapArrayData<CoinMarketCapTicker> deserialize( JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { ObjectCodec oc = jp.getCodec(); JsonNode node = oc.readTree(jp); if (node.isObject()) { List<CoinMarketCapTicker> tickers = new LinkedList<>(); ObjectMapper mapper = new ObjectMapper(); SimpleModule module = new SimpleModule(); module.addDeserializer( CoinMarketCapTicker.class, new CoinMarketCapTicker.CoinMarketCapTickerDeserializer()); mapper.registerModule(module); for (JsonNode child : node.get("data")) { tickers.add(mapper.treeToValue(child, CoinMarketCapTicker.class)); } return new CoinMarketCapArrayData<>(tickers); } return null; } }
public static Integer parseInteger(String body, String field) { ObjectMapper mapper = new ObjectMapper(); JsonNode node = null; try { node = mapper.readTree(body); JsonNode leaf = node.get(field); if (leaf != null) return leaf.asInt(); } catch (IOException e) { e.printStackTrace(); } return null; }
@Override public LoadManagerReport deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException { ObjectMapper mapper = ObjectMapperFactory.getThreadLocal(); ObjectNode root = ObjectMapperFactory.getThreadLocal().readTree(jsonParser); if ((root.has("loadReportType") && root.get("loadReportType").asText().equals(LoadReport.loadReportType)) || (root.has("underLoaded"))) { return mapper.readValue(root.toString(), LoadReport.class); } else { return mapper.readValue(root.toString(), LocalBrokerData.class); } } }
@Test public void testHeartbeatStatsSerialization() throws Exception { ObjectMapper objectMapper = new ObjectMapperProvider().get(); Stats stats = new Stats(new URI("http://example.com")); String serialized = objectMapper.writeValueAsString(stats); JsonNode deserialized = objectMapper.readTree(serialized); assertFalse(deserialized.has("lastFailureInfo")); stats.recordFailure(new SocketTimeoutException("timeout")); serialized = objectMapper.writeValueAsString(stats); deserialized = objectMapper.readTree(serialized); assertFalse(deserialized.get("lastFailureInfo").isNull()); assertEquals(deserialized.get("lastFailureInfo").get("type").asText(), SocketTimeoutException.class.getName()); }
@Test public void serializeColorsBars_resultJsonHasColors() throws IOException { //when bars.setColor(Arrays.asList(Color.BLUE, Color.GREEN, Color.BLACK)); barsSerializer.serialize(bars, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); //then JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("colors")).isTrue(); ArrayNode arrayNode = (ArrayNode) actualObj.get("colors"); Assertions.assertThat(arrayNode.get(1).get("rgb").asInt()).isEqualTo(Color.GREEN.getRGB()); }
@Override public YoBitTrades deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException { Map<String, List<YoBitTrade>> trades = new HashMap<>(); ObjectCodec oc = p.getCodec(); JsonNode node = oc.readTree(p); if (node.isObject()) { Iterator<Entry<String, JsonNode>> priceEntryIter = node.fields(); while (priceEntryIter.hasNext()) { Entry<String, JsonNode> priceEntryNode = priceEntryIter.next(); JsonNode priceNode = priceEntryNode.getValue(); String ccyPair = priceEntryNode.getKey(); List<YoBitTrade> res = new ArrayList<>(); trades.put(ccyPair, res); if (priceNode.isArray()) { for (JsonNode jsonNode : priceNode) { ObjectMapper jsonObjectMapper = new ObjectMapper(); res.add(jsonObjectMapper.convertValue(jsonNode, YoBitTrade.class)); } } } } return new YoBitTrades(trades); } }
@Override public ClientTypeSignatureParameter deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException { JsonNode node = jp.getCodec().readTree(jp); ParameterKind kind = MAPPER.readValue(MAPPER.treeAsTokens(node.get("kind")), ParameterKind.class); JsonParser jsonValue = MAPPER.treeAsTokens(node.get("value")); Object value; switch (kind) { case TYPE: value = MAPPER.readValue(jsonValue, ClientTypeSignature.class); break; case NAMED_TYPE: value = MAPPER.readValue(jsonValue, NamedTypeSignature.class); break; case LONG: value = MAPPER.readValue(jsonValue, Long.class); break; default: throw new UnsupportedOperationException(format("Unsupported kind [%s]", kind)); } return new ClientTypeSignatureParameter(kind, value); } }
@Override public NamespaceBinding deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { ObjectMapper mapper = (ObjectMapper)jp.getCodec(); JsonNode node = mapper.readTree(jp); String name = node.get("name").asText(); String session = node.get("session").asText(); Boolean defined = node.get("defined").asBoolean(); JsonNode o = node.get("value"); Object obj = objectSerializerProvider.get().deserialize(o, mapper); return new NamespaceBinding(name,session,obj,defined); } }
@Override public YoBitTickersReturn deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { JsonNode node = p.readValueAsTree(); Map<String, YoBitTicker> tickers = new HashMap<>(); if (node.isObject()) { Iterator<Map.Entry<String, JsonNode>> priceEntryIter = node.fields(); while (priceEntryIter.hasNext()) { Map.Entry<String, JsonNode> priceEntryNode = priceEntryIter.next(); JsonNode jsonNode = priceEntryNode.getValue(); ObjectReader jsonObjectReader = new ObjectMapper().readerFor(YoBitTicker.class); YoBitTicker ticker = jsonObjectReader.readValue(jsonNode); String ccy = priceEntryNode.getKey(); tickers.put(ccy, ticker); } } return new YoBitTickersReturn(tickers); } }
private JsonNode merge(JsonNode source, JsonNode replacement) throws IOException { JsonNode replacementNodeEncoded = replacement.get(fieldName); if (replacementNodeEncoded != null) { ObjectNode decodedSource = tryDecode(source.get(fieldName), mapper.createObjectNode(), fieldName); decodedSource.setAll(tryDecode(replacement.get(fieldName), mapper.createObjectNode(), fieldName)); return TextNode.valueOf(mapper.writeValueAsString(decodedSource)); } else { return source.get(fieldName); } }
final String json = "{\"objects\" : [\"One\", \"Two\", \"Three\"]}"; final JsonNode arrNode = new ObjectMapper().readTree(json).get("objects"); if (arrNode.isArray()) { for (final JsonNode objNode : arrNode) { System.out.println(objNode); } }