/** * Serialize a list of objects to a JSON String. * * @param list The list of objects to serialize. */ public String serialize(List<T> list) throws IOException { StringWriter sw = new StringWriter(); JsonGenerator jsonGenerator = LoganSquare.JSON_FACTORY.createGenerator(sw); serialize(list, jsonGenerator); jsonGenerator.close(); return sw.toString(); }
/** * Example to writeJson using StreamingAPI */ private static void writeJson() throws IOException { JsonFactory jsonFactory = new JsonFactory(); OutputStream outputStream = new ByteArrayOutputStream(); JsonGenerator jsonGenerator = jsonFactory.createGenerator(outputStream, JsonEncoding.UTF8); // or Stream, Reader jsonGenerator.writeStartObject(); jsonGenerator.writeStringField("message", "Hi"); jsonGenerator.writeFieldName("place"); jsonGenerator.writeStartObject(); jsonGenerator.writeStringField("name", "World!"); jsonGenerator.writeEndObject(); jsonGenerator.writeEndObject(); jsonGenerator.close(); System.out.println(outputStream.toString()); // print "{"message":"Hi","place":{"name":"World!"}}" } }
private void init() { try { if (inputStream == null) { throw new UnsupportedOperationException(); } else { jp = objectMapper.getFactory().createParser(inputStream); } final JsonToken nextToken = jp.nextToken(); if (nextToken != JsonToken.START_ARRAY) { throw new IAE("First token should be START_ARRAY", jp.getCurrentToken()); } else { jp.nextToken(); objectCodec = jp.getCodec(); } } catch (IOException e) { throw new RuntimeException(e); } }
public JsonBenchmarkResultWriter(OutputStream outputStream) { requireNonNull(outputStream, "outputStream is null"); try { jsonGenerator = new JsonFactory().createGenerator(outputStream, JsonEncoding.UTF8); jsonGenerator.writeStartObject(); jsonGenerator.writeArrayFieldStart("samples"); } catch (IOException e) { throw new UncheckedIOException(e); } }
public JsonParserImpl(ReadStream<Buffer> stream) { this.stream = stream; JsonFactory factory = new JsonFactory(); try { parser = (NonBlockingJsonParser) factory.createNonBlockingByteArrayParser(); } catch (Exception e) { throw new VertxException(e); } }
public OdsBenchmarkResultWriter(String entity, OutputStream outputStream) { requireNonNull(entity, "entity is null"); requireNonNull(outputStream, "outputStream is null"); this.entity = entity; try { jsonGenerator = new JsonFactory().createGenerator(outputStream, JsonEncoding.UTF8); jsonGenerator.writeStartArray(); } catch (IOException e) { throw new UncheckedIOException(e); } }
private <T> byte[] toByteArray(final Iterable<T> results) throws IOException { final ByteArrayOutputStream bytes = new ByteArrayOutputStream(); try (JsonGenerator gen = objectMapper.getFactory().createGenerator(bytes)) { for (T result : results) { gen.writeObject(result); } } return bytes.toByteArray(); }
private JsonNode serialiseDashRow(BeakerDashboard.dashRow row) throws Exception{ ObjectMapper mapper = new ObjectMapper(); StringWriter sw = new StringWriter(); JsonGenerator jgen = mapper.getFactory().createGenerator(sw); row.serialize(jgen, new BasicObjectSerializer()); jgen.flush(); return mapper.readTree(sw.toString()); }
private byte[] toByteArray(JsonFactory factory, JsonPayload payload) { try { ByteArrayOutputStream baos = new ByteArrayOutputStream(); JsonGenerator gen = factory.createGenerator(baos, JsonEncoding.UTF8); payload.toJson(gen); gen.close(); baos.close(); return baos.toByteArray(); } catch (IOException e) { throw Throwables.propagate(e); } }
@Override public byte[] serialize(final RedisStateMap stateMap) throws IOException { if (stateMap == null) { return null; } try (final ByteArrayOutputStream out = new ByteArrayOutputStream()) { final JsonGenerator jsonGenerator = jsonFactory.createGenerator(out); jsonGenerator.writeStartObject(); jsonGenerator.writeNumberField(FIELD_VERSION, stateMap.getVersion()); jsonGenerator.writeNumberField(FIELD_ENCODING, stateMap.getEncodingVersion()); jsonGenerator.writeObjectFieldStart(FIELD_STATE_VALUES); for (Map.Entry<String,String> entry : stateMap.toMap().entrySet()) { jsonGenerator.writeStringField(entry.getKey(), entry.getValue()); } jsonGenerator.writeEndObject(); jsonGenerator.writeEndObject(); jsonGenerator.flush(); return out.toByteArray(); } }
/** * @see <a href="https://github.com/logstash-plugins/logstash-input-beats/blob/master/PROTOCOL.md#data-frame-type">'data' frame type</a> */ private Collection<ByteBuf> parseDataFrame(Channel channel, ByteBuf channelBuffer) throws IOException { sequenceNum = channelBuffer.readUnsignedInt(); LOG.trace("Received sequence number {}", sequenceNum); final int pairs = Ints.saturatedCast(channelBuffer.readUnsignedInt()); final JsonFactory jsonFactory = new JsonFactory(); final ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); try (final JsonGenerator jg = jsonFactory.createGenerator(outputStream)) { jg.writeStartObject(); for (int i = 0; i < pairs; i++) { final String key = parseDataItem(channelBuffer); final String value = parseDataItem(channelBuffer); jg.writeStringField(key, value); } jg.writeEndObject(); } final ByteBuf buffer = Unpooled.wrappedBuffer(outputStream.toByteArray()); sendACK(channel); return Collections.singleton(buffer); }
private static byte[] rewriteResponse(byte[] input, Function<String, String> uriRewriter) JsonParser parser = JSON_FACTORY.createParser(input); ByteArrayOutputStream out = new ByteArrayOutputStream(input.length * 2); JsonGenerator generator = JSON_FACTORY.createGenerator(out); JsonToken token = parser.nextToken(); if (token != START_OBJECT) { throw invalidJson("bad start token: " + token); generator.copyCurrentEvent(parser); token = parser.nextToken(); if (token == null) { throw invalidJson("unexpected end of stream"); generator.copyCurrentEvent(parser); break; String name = parser.getValueAsString(); if (!"nextUri".equals(name) && !"partialCancelUri".equals(name)) { generator.copyCurrentStructure(parser); continue; generator.close(); return out.toByteArray();
public Tests(int bufferSize, int depth, String input) throws IOException { this.depth = depth; byte[] in = input.getBytes("UTF-8"); JsonFactory f = new JsonFactory(); JsonParser p = f.createJsonParser( new ByteArrayInputStream(input.getBytes("UTF-8"))); ByteArrayOutputStream os = new ByteArrayOutputStream(); EncoderFactory factory = new EncoderFactory() .configureBlockSize(bufferSize); Encoder cos = factory.blockingBinaryEncoder(os, null); serialize(cos, p, os); cos.flush(); byte[] bb = os.toByteArray(); // dump(bb); this.input = DecoderFactory.get().binaryDecoder(bb, null); this.parser = f.createJsonParser(new ByteArrayInputStream(in)); }
@Before public void initTestStubData() throws IOException { sw = new StringWriter(); jgen = mapper.getJsonFactory().createJsonGenerator(sw); }
@Override public ByteBuffer write(List<Object> data, ByteBuffer buffer) { Preconditions.checkArgument(data != null && data.size() == fieldNames.size(), "Invalid schema"); StringWriter sw = new StringWriter(); try (JsonGenerator jg = jsonFactory.createGenerator(sw)) { jg.writeStartObject(); for (int i = 0; i < fieldNames.size(); ++i) { jg.writeFieldName(fieldNames.get(i)); jg.writeObject(data.get(i)); } jg.writeEndObject(); } catch (IOException e) { throw new RuntimeException(e); } return ByteBuffer.wrap(sw.toString().getBytes(StandardCharsets.UTF_8)); } }
@Test public void testFormatting() throws IOException, ParseException { Date now = new Date(); ByteArrayOutputStream bos = new ByteArrayOutputStream(); JsonGenerator gen = new JsonFactory().createGenerator(bos); new JsonDateSerializer().serialize(now, gen, null); gen.close(); Assert.assertEquals(String.format("\"%s\"", new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").format(now)), bos.toString()); }
private MaxwellJson() throws IOException { buffer = new ByteArrayOutputStream(); jsonGenerator = jsonFactory.createGenerator(buffer); jsonGenerator.setRootValueSeparator(null); plaintextGenerator = new PlaintextJsonGenerator(jsonGenerator); encryptingGenerator = new EncryptingJsonGenerator(jsonGenerator, jsonFactory); }
@Override public String toJson(Object obj) { StringWriter writer = new StringWriter(); try { JsonGenerator generator = objectMapper.getFactory().createGenerator(writer); objectMapper.writeValue(generator, obj); writer.flush(); writer.close(); generator.close(); return writer.getBuffer().toString(); } catch (IOException e) { throw new InvalidJsonException(e); } }
@Before public void setUp() throws Exception { writer = new StringWriter(); serializer = new PayloadSerializer(); jsonGenerator = new JsonFactory().createGenerator(writer); ObjectMapper mapper = new ObjectMapper(); jsonGenerator.setCodec(mapper); serializerProvider = mapper.getSerializerProvider(); }
private ObjectNode parseJsonTree(final InputStream stream) throws IOException, DeserializerException { ObjectMapper objectMapper = new ObjectMapper(); objectMapper.configure(DeserializationFeature.FAIL_ON_READING_DUP_TREE_KEY, true); JsonParser parser = new JsonFactory(objectMapper).createParser(stream); final JsonNode tree = parser.getCodec().readTree(parser); if (tree == null || !tree.isObject()) { throw new DeserializerException("Invalid JSON syntax.", DeserializerException.MessageKeys.JSON_SYNTAX_EXCEPTION); } return (ObjectNode) tree; }