@Override public YoBitOrderBooksReturn deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { JsonNode node = p.readValueAsTree(); Map<String, YoBitOrderBook> 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(YoBitOrderBook.class); YoBitOrderBook orderBook = jsonObjectReader.readValue(jsonNode); String ccy = priceEntryNode.getKey(); tickers.put(ccy, orderBook); } } return new YoBitOrderBooksReturn(tickers); } }
@Override @Nullable protected Object convertFromInternal(Message<?> message, Class<?> targetClass, @Nullable Object conversionHint) { JavaType javaType = getJavaType(targetClass, conversionHint); Object payload = message.getPayload(); Class<?> view = getSerializationView(conversionHint); // Note: in the view case, calling withType instead of forType for compatibility with Jackson <2.5 try { if (payload instanceof byte[]) { if (view != null) { return this.objectMapper.readerWithView(view).forType(javaType).readValue((byte[]) payload); } else { return this.objectMapper.readValue((byte[]) payload, javaType); } } else { if (view != null) { return this.objectMapper.readerWithView(view).forType(javaType).readValue(payload.toString()); } else { return this.objectMapper.readValue(payload.toString(), javaType); } } } catch (IOException ex) { throw new MessageConversionException(message, "Could not read JSON: " + ex.getMessage(), ex); } }
@Override public List<LogResult> deserialize( JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException { List<LogResult> logResults = new ArrayList<>(); JsonToken nextToken = jsonParser.nextToken(); if (nextToken == JsonToken.START_OBJECT) { Iterator<LogObject> logObjectIterator = objectReader.readValues(jsonParser, LogObject.class); while (logObjectIterator.hasNext()) { logResults.add(logObjectIterator.next()); } } else if (nextToken == JsonToken.VALUE_STRING) { jsonParser.getValueAsString(); Iterator<Hash> transactionHashIterator = objectReader.readValues(jsonParser, Hash.class); while (transactionHashIterator.hasNext()) { logResults.add(transactionHashIterator.next()); } } return logResults; } }
/** * Type-safe overloaded method, basically alias for {@link #readValue(JsonParser, ResolvedType)}. *<p> * NOTE: this method never tries to auto-detect format, since actual * (data-format specific) parser is given. */ @SuppressWarnings("unchecked") public <T> T readValue(JsonParser p, JavaType valueType) throws IOException { return (T) forType(valueType).readValue(p); }
/** * Convenience method that is equivalent to: *<pre> * withType(valueType).readValues(p); *</pre> *<p> * Method reads a sequence of Objects from parser stream. * Sequence can be either root-level "unwrapped" sequence (without surrounding * JSON array), or a sequence contained in a JSON Array. * In either case {@link JsonParser} <b>MUST</b> point to the first token of * the first element, OR not point to any token (in which case it is advanced * to the next token). This means, specifically, that for wrapped sequences, * parser MUST NOT point to the surrounding <code>START_ARRAY</code> (one that * contains values to read) but rather to the token following it which is the first * token of the first value to read. *<p> * NOTE: this method never tries to auto-detect format, since actual * (data-format specific) parser is given. */ public <T> Iterator<T> readValues(JsonParser p, JavaType valueType) throws IOException { return forType(valueType).readValues(p); }
private void initialize() throws IOException { this.parser = new JsonFactory().createParser(new InputStreamReader(inputStream, "utf-8")); //$NON-NLS-1$ initializer.execute(this.parser); this.iterator = new ObjectMapper().readerFor(clazz).readValues(this.parser); } };
@Test public void testSerialization() throws Exception { ObjectMapper objectMapper = new ObjectMapper(); BingTile tile = fromCoordinates(1, 2, 3); String json = objectMapper.writeValueAsString(tile); assertEquals("{\"x\":1,\"y\":2,\"zoom\":3}", json); assertEquals(tile, objectMapper.readerFor(BingTile.class).readValue(json)); }
private Map<String, Object> getJwks() throws SigningKeyNotFoundException { try { final URLConnection c = this.url.openConnection(); if (connectTimeout != null) { c.setConnectTimeout(connectTimeout); } if (readTimeout != null) { c.setReadTimeout(readTimeout); } final InputStream inputStream = c.getInputStream(); final JsonFactory factory = new JsonFactory(); final JsonParser parser = factory.createParser(inputStream); final TypeReference<Map<String, Object>> typeReference = new TypeReference<Map<String, Object>>() { }; return new ObjectMapper().reader().readValue(parser, typeReference); } catch (IOException e) { throw new SigningKeyNotFoundException("Cannot obtain jwks from url " + url.toString(), e); } }
public static <T extends Message> T decodeProtoYamlFile(Path path, T prototype) throws IOException { ObjectMapper yamlMapper = new ObjectMapper(new YAMLFactory()); ObjectMap map = yamlMapper.readerFor(ObjectMap.class).readValue(path.toFile()); ObjectMapper jsonMapper = new ObjectMapper(new JsonFactory()); String json = jsonMapper.writerFor(ObjectMap.class).writeValueAsString(map); return decodeProtoJson(json, prototype); }
@Test public void testSerDeserMapLookupExtractorFactory() throws IOException { ObjectMapper mapper = new DefaultObjectMapper(); mapper.registerSubtypes(MapLookupExtractorFactory.class); LookupExtractorFactory lookupExtractorFactory = new MapLookupExtractorFactory(ImmutableMap.of("key", "value"), true); Assert.assertEquals(lookupExtractorFactory, mapper.readerFor(LookupExtractorFactory.class).readValue(mapper.writeValueAsString(lookupExtractorFactory))); } }
@Override public TransformerConfig deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException { JsonNode node = p.getCodec().readTree(p); if (node.isObject()) { List<TransformerConfig> configs = new ArrayList<>(); for (Iterator<Map.Entry<String, JsonNode>> it = node.fields(); it.hasNext(); ) { Map.Entry<String, JsonNode> field = it.next(); TransformerConfig config = getById(p, ctxt, field.getKey()); // todo is there a better way to do this other than making a new ObjectMapper? ObjectMapper mapper = new ObjectMapper(new JsonFactory()); configs.add(mapper.readerForUpdating(config).readValue(field.getValue())); } if (configs.size() == 0) { throw new IllegalArgumentException("didn't see that coming " + node); } else if (configs.size() == 1) { return configs.get(0); } else { DelegatingTransformer.Config config = new DelegatingTransformer.Config(); config.setConfigs(configs); return config; } } else if (node.isTextual()) { return getById(p, ctxt, node.asText()); } else { throw ctxt.wrongTokenException(p, String.class, JsonToken.VALUE_STRING, null); } }
@Test public void testSerDesBoundFilter() throws IOException { Injector defaultInjector = GuiceInjectors.makeStartupInjector(); ObjectMapper mapper = defaultInjector.getInstance(Key.get(ObjectMapper.class, Json.class)); String serBetweenDimFilter = mapper.writeValueAsString(boundDimFilter); BoundDimFilter actualBoundDimFilter = mapper.readerFor(DimFilter.class).readValue(serBetweenDimFilter); Assert.assertEquals(boundDimFilter, actualBoundDimFilter); }
return jsonMapper.readValue(url, EventList.class); } else if (query.type == CSV) { CsvSchema.Builder builder = CsvSchema.builder(); return csvMapper.readerFor(EventList.class) .with(ContextAttributes.getEmpty() .withSharedAttribute("project", project) .withSharedAttribute("useHeader", useHeader) .withSharedAttribute("collection", query.collection) .withSharedAttribute("apiKey", masterKey)) .with(builder.build()).readValue(url); } else if (query.type == AVRO) { URLConnection conn = url.openConnection();
InstanceInfo.Builder builder = InstanceInfo.Builder.newBuilder(self); JsonToken jsonToken; while ((jsonToken = jp.nextToken()) != JsonToken.END_OBJECT) { InstanceInfoField instanceInfoField = InstanceInfoField.lookup.find(jp); jsonToken = jp.nextToken(); if (instanceInfoField != null && jsonToken != JsonToken.VALUE_NULL) { switch(instanceInfoField) { ()->{ try { return jp.getText().toUpperCase(); } catch (IOException e) { throw new RuntimeJsonMappingException(e.getMessage()); break; case DATACENTER: builder.setDataCenterInfo(DeserializerStringCache.init(mapper.readerFor(DataCenterInfo.class), context).readValue(jp)); break; case LEASE: builder.setLeaseInfo(mapper.readerFor(LeaseInfo.class).readValue(jp)); break; case HEALTHCHECKURL:
while((jsonToken = jp.nextToken()) != JsonToken.END_OBJECT){ String fieldName = jp.getCurrentName(); jsonToken = jp.nextToken(); ObjectReader applicationReader = DeserializerStringCache.init(mapper.readerFor(Application.class), context); if (jsonToken == JsonToken.START_ARRAY) { while (jp.nextToken() != JsonToken.END_ARRAY) { apps.addApplication(applicationReader.readValue(jp)); apps.addApplication(applicationReader.readValue(jp));
final JsonFactory f = new JsonFactory(); try (final JsonParser parser = f.createParser(stream)) { final ObjectReader reader = this.mapper.readerFor(this.clazz).with(injectableValues); final JsonToken token = parser.nextToken(); if (token != JsonToken.START_ARRAY) { final T value = reader.readValue(parser); return Arrays.asList(value); while (parser.nextToken() == JsonToken.START_OBJECT) { final T value = reader.readValue(parser); results.add(value);
JsonToken jsonToken; try { while((jsonToken = jp.nextToken()) != JsonToken.END_OBJECT){ if(JsonToken.FIELD_NAME == jsonToken){ ApplicationField field = ApplicationField.lookup.find(jp); jsonToken = jp.nextToken(); if (field != null) { switch(field) { case NAME: application.setName(jp.getText()); break; case INSTANCE: ObjectReader instanceInfoReader = DeserializerStringCache.init(mapper.readerFor(InstanceInfo.class), context); if (jsonToken == JsonToken.START_ARRAY) { while (jp.nextToken() != JsonToken.END_ARRAY) { application.addInstance(instanceInfoReader.readValue(jp)); application.addInstance(instanceInfoReader.readValue(jp));
return jsonMapper.readerFor(EventList.class).readValue(buff); } else if ("application/x-rawjson".equals(contentType) || "application/x-ndjson".equals(contentType)) { String apiKey; String collection = getParam(request.params(), "collection"); JsonParser parser = jsonMapper.getFactory().createParser(buff); ArrayList<Event> events = new ArrayList<>(); JsonToken t = parser.nextToken(); if (t == JsonToken.START_OBJECT) { while (t == JsonToken.START_OBJECT) { Map.Entry<List<SchemaField>, GenericData.Record> entry = jsonEventDeserializer.parseProperties(project, collection, parser, true); events.add(new Event(project, collection, null, entry.getKey(), entry.getValue())); t = parser.nextToken(); t = parser.nextToken(); for (; t == START_OBJECT; t = parser.nextToken()) { return csvMapper.readerFor(EventList.class) .with(ContextAttributes.getEmpty() .withSharedAttribute("project", project) .withSharedAttribute("useHeader", useHeader) .withSharedAttribute("collection", collection) .withSharedAttribute("apiKey", apiKey)) .with(builder.build()).readValue(buff);
/** * @deprecated since 2.5 Use {@link #forType(Class)} instead */ @Deprecated public ObjectReader withType(java.lang.reflect.Type valueType) { return forType(_config.getTypeFactory().constructType(valueType)); }