/** Unit test to check for regression of [JACKSON-18]. */ public void testSmallNumbers() throws Exception { ObjectMapper mapper = new ObjectMapper(); ArrayNode root = mapper.createArrayNode(); for (int i = -20; i <= 20; ++i) { JsonNode n = root.numberNode(i); root.add(n); // Hmmh. Not sure why toString() won't be triggered otherwise... assertEquals(String.valueOf(i), n.toString()); } // Loop over 2 different serialization methods for (int type = 0; type < 2; ++type) { StringWriter sw = new StringWriter(); if (type == 0) { JsonGenerator gen = new JsonFactory().createGenerator(sw); root.serialize(gen, null); gen.close(); } else { mapper.writeValue(sw, root); } String doc = sw.toString(); JsonParser p = new JsonFactory().createParser(new StringReader(doc)); assertEquals(JsonToken.START_ARRAY, p.nextToken()); for (int i = -20; i <= 20; ++i) { assertEquals(JsonToken.VALUE_NUMBER_INT, p.nextToken()); assertEquals(i, p.getIntValue()); assertEquals("" + i, p.getText()); } assertEquals(JsonToken.END_ARRAY, p.nextToken()); p.close(); } }
/** Method called to configure the generator as necessary and then call write functionality */ protected final void _configAndWriteValue(JsonGenerator jgen, Object value) throws IOException, JsonGenerationException, JsonMappingException { _configureJsonGenerator(jgen); // [JACKSON-282]: consider Closeable if (_config.isEnabled(SerializationFeature.CLOSE_CLOSEABLE) && (value instanceof Closeable)) { _writeCloseable(jgen, value, _config); return; } boolean closed = false; try { if (_rootType == null) { _serializerProvider(_config).serializeValue(jgen, value); } else { _serializerProvider(_config).serializeValue(jgen, value, _rootType, _rootSerializer); } closed = true; jgen.close(); } finally { /* won't try to close twice; also, must catch exception (so it * will not mask exception that is pending) */ if (!closed) { try { jgen.close(); } catch (IOException ioe) { } } } }
/** * Helper method used when value to serialize is {@link Closeable} and its <code>close()</code> * method is to be called right after serialization has been called */ private final void _writeCloseable(JsonGenerator jgen, Object value, SerializationConfig cfg) throws IOException, JsonGenerationException, JsonMappingException { Closeable toClose = (Closeable) value; try { if (_rootType == null) { _serializerProvider(cfg).serializeValue(jgen, value); } else { _serializerProvider(cfg).serializeValue(jgen, value, _rootType, _rootSerializer); } JsonGenerator tmpJgen = jgen; jgen = null; tmpJgen.close(); Closeable tmpToClose = toClose; toClose = null; tmpToClose.close(); } finally { /* Need to close both generator and value, as long as they haven't yet * been closed */ if (jgen != null) { try { jgen.close(); } catch (IOException ioe) { } } if (toClose != null) { try { toClose.close(); } catch (IOException ioe) { } } } }
public void testEmptyArrayWrite() throws Exception { StringWriter sw = new StringWriter(); JsonGenerator gen = new JsonFactory().createGenerator(sw); JsonStreamContext ctxt = gen.getOutputContext(); assertTrue(ctxt.inRoot()); assertFalse(ctxt.inArray()); assertFalse(ctxt.inObject()); assertEquals(0, ctxt.getEntryCount()); assertEquals(0, ctxt.getCurrentIndex()); gen.writeStartArray(); ctxt = gen.getOutputContext(); assertFalse(ctxt.inRoot()); assertTrue(ctxt.inArray()); assertFalse(ctxt.inObject()); assertEquals(0, ctxt.getEntryCount()); assertEquals(0, ctxt.getCurrentIndex()); gen.writeEndArray(); ctxt = gen.getOutputContext(); assertTrue("Should be in root, was " + ctxt.getTypeDesc(), ctxt.inRoot()); assertFalse(ctxt.inArray()); assertFalse(ctxt.inObject()); assertEquals(1, ctxt.getEntryCount()); // Index won't yet move assertEquals(0, ctxt.getCurrentIndex()); gen.close(); String docStr = sw.toString(); JsonParser jp = createParserUsingReader(docStr); assertEquals(JsonToken.START_ARRAY, jp.nextToken()); assertEquals(JsonToken.END_ARRAY, jp.nextToken()); jp.close(); // Ok, then array with nested empty array sw = new StringWriter(); gen = new JsonFactory().createGenerator(sw); gen.writeStartArray(); gen.writeStartArray(); gen.writeEndArray(); gen.writeEndArray(); gen.close(); docStr = sw.toString(); jp = createParserUsingReader(docStr); assertEquals(JsonToken.START_ARRAY, jp.nextToken()); assertEquals(JsonToken.START_ARRAY, jp.nextToken()); assertEquals(JsonToken.END_ARRAY, jp.nextToken()); assertEquals(JsonToken.END_ARRAY, jp.nextToken()); assertEquals(null, jp.nextToken()); jp.close(); }
@GET("/backend/aggregate/points") String getPoints(String content) throws IOException { logger.debug("getPoints(): content={}", content); PointsRequest request = ObjectMappers.readRequiredValue(mapper, content, PointsRequest.class); List<AggregatePoint> points = aggregateDao.readAggregates(request.getFrom(), request.getTo()); StringBuilder sb = new StringBuilder(); JsonGenerator jg = mapper.getFactory().createGenerator(CharStreams.asWriter(sb)); jg.writeStartObject(); jg.writeArrayFieldStart("points"); for (AggregatePoint point : points) { jg.writeStartArray(); jg.writeNumber(point.getCaptureTime()); long durationAverage; if (point.getTraceCount() == 0) { durationAverage = 0; } else { durationAverage = point.getDurationTotal() / point.getTraceCount(); } jg.writeNumber(durationAverage / 1000000000.0); jg.writeNumber(point.getTraceCount()); jg.writeEndArray(); } jg.writeEndArray(); jg.writeNumberField("fixedAggregateIntervalSeconds", fixedAggregateIntervalSeconds); jg.writeEndObject(); jg.close(); return sb.toString(); }
public static String objectToJson(Object object) { JsonGenerator jsonGenerator = null; ObjectMapper objectMapper = new ObjectMapper(); ByteArrayOutputStream out = null; String json = null; try { try { String jsonStr = ""; out = new ByteArrayOutputStream(); jsonGenerator = objectMapper.getFactory().createGenerator(out, JsonEncoding.UTF8); jsonGenerator.writeObject(object); json = new String(out.toByteArray(), Charset.forName("UTF-8")); out.toString(); System.out.println(json); } finally { if (jsonGenerator != null) { jsonGenerator.flush(); } if (!jsonGenerator.isClosed()) { jsonGenerator.close(); } if (out != null) { out.close(); } jsonGenerator = null; objectMapper = null; } } catch (Exception e) { } return json; }
public void testFromMap() throws Exception { ObjectMapper mapper = new ObjectMapper(); ObjectNode root = mapper.createObjectNode(); root.put(FIELD4, TEXT2); root.put(FIELD3, -1); root.putArray(FIELD2); root.put(FIELD1, DOUBLE_VALUE); /* Let's serialize using one of two alternate methods: * first preferred (using generator) * (there are 2 variants here too) */ for (int i = 0; i < 2; ++i) { StringWriter sw = new StringWriter(); if (i == 0) { JsonGenerator gen = new JsonFactory().createGenerator(sw); root.serialize(gen, null); gen.close(); } else { mapper.writeValue(sw, root); } verifyFromMap(sw.toString()); } // And then convenient but less efficient alternative: verifyFromMap(root.toString()); }
public void testFromArray() throws Exception { ObjectMapper mapper = new ObjectMapper(); ArrayNode root = mapper.createArrayNode(); root.add(TEXT1); root.add(3); ObjectNode obj = root.addObject(); obj.put(FIELD1, true); obj.putArray(FIELD2); root.add(false); /* Ok, ready... let's serialize using one of two alternate * methods: first preferred (using generator) * (there are 2 variants here too) */ for (int i = 0; i < 2; ++i) { StringWriter sw = new StringWriter(); if (i == 0) { JsonGenerator gen = new JsonFactory().createGenerator(sw); root.serialize(gen, null); gen.close(); } else { mapper.writeValue(sw, root); } verifyFromArray(sw.toString()); } // And then convenient but less efficient alternative: verifyFromArray(root.toString()); }
protected String writeTree(TreeCodec treeCodec, TreeNode treeNode) throws IOException { StringWriter writer = new StringWriter(); JsonGenerator g = _factory.createGenerator(writer); treeCodec.writeTree(g, treeNode); g.close(); return writer.toString(); }
@Test public void testCreateGenerator() throws Exception { EbeanServer server = Ebean.getDefaultServer(); StringWriter writer = new StringWriter(); JsonContext json = server.json(); JsonGenerator generator = json.createGenerator(writer); Customer customer = new Customer(); customer.setId(1); customer.setName("Jim"); // we can use the generator before and after our json.toJson() call // ... confirming we are not closing the generator generator.writeStartArray(); json.toJson(customer, generator, PathProperties.parse("id,name")); generator.writeEndArray(); generator.close(); String jsonString = writer.toString(); assertTrue(jsonString, jsonString.startsWith("[")); assertTrue(jsonString, jsonString.endsWith("]")); assertTrue(jsonString, jsonString.contains("{\"id\":1,\"name\":\"Jim\"}")); }
public void jsonSerializeTree(final ObjectMapper mapper, final OutputStream output) throws IOException { final JsonGenerator generator = mapper.getFactory().createJsonGenerator(output); generator.configure(JsonGenerator.Feature.AUTO_CLOSE_TARGET, false); walkTree( new WalkCallback() { private int curDepth = 0; @Override public void onCurrentNode( final int depth, final NodeInterval curNode, final NodeInterval parent) { final ItemsNodeInterval node = (ItemsNodeInterval) curNode; if (node.isRoot()) { return; } try { if (curDepth < depth) { generator.writeStartArray(); curDepth = depth; } else if (curDepth > depth) { generator.writeEndArray(); curDepth = depth; } generator.writeObject(node); } catch (IOException e) { throw new RuntimeException("Failed to deserialize tree", e); } } }); generator.close(); }
public void testUtf8Issue462() throws Exception { ByteArrayOutputStream bytes = new ByteArrayOutputStream(); IOContext ioc = new IOContext(new BufferRecycler(), bytes, true); JsonGenerator gen = new UTF8JsonGenerator(ioc, 0, null, bytes); String str = "Natuurlijk is alles gelukt en weer een tevreden klant\uD83D\uDE04"; int length = 4000 - 38; for (int i = 1; i <= length; ++i) { gen.writeNumber(1); } gen.writeString(str); gen.flush(); gen.close(); // Also verify it's parsable? JsonFactory f = new JsonFactory(); JsonParser p = f.createParser(bytes.toByteArray()); for (int i = 1; i <= length; ++i) { assertToken(JsonToken.VALUE_NUMBER_INT, p.nextToken()); assertEquals(1, p.getIntValue()); } assertToken(JsonToken.VALUE_STRING, p.nextToken()); assertEquals(str, p.getText()); assertNull(p.nextToken()); p.close(); }
@Test public void test1() throws IOException { MapData ld0 = new MapData(); ld0.put("Copyright", "\u00A9 2014, David R. Smith. All Rights Reserved"); ld0.put("License", "http://www.apache.org/licenses/LICENSE-2.0.txt"); MapData ld1 = new MapData(); ld1.put("some key", "some data"); ld1.put("another key", "more data"); MapDataFormatter format = new MapDataFormatter(); format.add(ld0); format.add(ld1); StringWriter writer = new StringWriter(); JsonFactory f = new JsonFactory(); JsonGenerator g = null; try { g = f.createGenerator(writer); g.useDefaultPrettyPrinter(); g.writeStartObject(); format.format(g, writer); g.writeEndObject(); } finally { g.close(); } System.err.println(writer.toString()); MapIterator iter3 = new MapDataContentsIterator(ld0); while (iter3.hasNext()) { String label = iter3.next(); Assert.assertNotNull(iter3.get(label)); } }
public byte[] toJSONBytes() { try { ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); JsonFactory jsonFactory = new JsonFactory(); JsonGenerator jsonGenerator = jsonFactory.createJsonGenerator(outputStream, JsonEncoding.UTF8); jsonGenerator.useDefaultPrettyPrinter(); jsonGenerator.writeStartObject(); jsonGenerator.writeStringField("type", ContentType); jsonGenerator.writeStringField("version", Version); jsonGenerator.writeStringField("uuid", workspaceUUID); jsonGenerator.writeStringField("name", workspaceName); jsonGenerator.writeStringField("description", workspaceDescription); // TODO: More details about who is making the change when and from what previous version? // jsonGenerator.writeStringField("timestamp", timestamp); // jsonGenerator.writeStringField("user", user); // jsonGenerator.writeStringField("previous", previous); jsonGenerator.writeEndObject(); jsonGenerator.close(); return outputStream.toByteArray(); } catch (IOException e) { e.printStackTrace(); return null; } }
private static FullHttpResponse newHttpResponseWithStackTrace( Exception e, HttpResponseStatus status, @Nullable String simplifiedMessage) { StringWriter sw = new StringWriter(); e.printStackTrace(new PrintWriter(sw)); StringBuilder sb = new StringBuilder(); try { JsonGenerator jg = jsonFactory.createGenerator(CharStreams.asWriter(sb)); jg.writeStartObject(); String message; if (simplifiedMessage == null) { Throwable cause = e; Throwable childCause = cause.getCause(); while (childCause != null) { cause = childCause; childCause = cause.getCause(); } message = cause.getMessage(); } else { message = simplifiedMessage; } jg.writeStringField("message", message); jg.writeStringField("stackTrace", sw.toString()); jg.writeEndObject(); jg.close(); return HttpServices.createJsonResponse(sb.toString(), status); } catch (IOException f) { logger.error(f.getMessage(), f); return new DefaultFullHttpResponse(HTTP_1_1, INTERNAL_SERVER_ERROR); } }
public static String dumpConfigurationAsJson() { ImmutableCollection<String> keys = CONFIGURATION_SECTIONS.keySet(); ObjectMapper mapper = new ObjectMapper(); JsonFactory jfactory = mapper.getJsonFactory(); StringWriter sw = new StringWriter(); try { JsonGenerator gen = jfactory.createJsonGenerator(sw); gen.writeStartArray(); for (String v : keys) { String st = dumpConfigurationAsJson(v); ObjectMapper op = new ObjectMapper(); JsonNode p = op.readTree(st); Logger.debug("OBJECT:" + p.toString()); Logger.debug("STRING:" + st); // JsonParser jp = jfactory.createJsonParser(st); gen.writeTree(p); } gen.writeEndArray(); gen.close(); return sw.toString(); } catch (Exception e) { Logger.error("Cannot generate a json for the configuration", e); } return "[]"; } // dumpConfigurationAsJson()
public String serializeMap(Map<String, T> translator) throws IOException { StringWriter stringWriter = new StringWriter(); JsonGenerator generator = Acela.JSON_FACTORY.createGenerator(stringWriter); serializeMap(generator, translator); generator.close(); return stringWriter.toString(); }
@Override public void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException { String sid = req.getParameter("sid"); String gameId = req.getParameter("game"); String action = req.getParameter("action"); HanabiUser user = s.getUserBySession(sid); HanabiGame game = s.getGame(gameId); try { String message; if (action.equals("play_card")) { int slot = Integer.parseInt(req.getParameter("handSlot")); HanabiGame.PlayCardResult rv = game.playCard(slot); message = "It was a " + rv.card + "; " + (rv.success ? "Success!" : "Oops!"); } else if (action.equals("discard_card")) { int slot = Integer.parseInt(req.getParameter("handSlot")); HanabiGame.Card c = game.discardCard(slot); message = "It was a " + c; } else if (action.equals("give_hint")) { doGiveHint(game, req, resp); return; } else { message = "don't know how to " + action; } JsonGenerator out = new JsonFactory().createJsonGenerator(resp.getOutputStream()); out.writeStartObject(); out.writeStringField("message", message); out.writeEndObject(); out.close(); } catch (HanabiException e) { resp.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR); JsonGenerator out = new JsonFactory().createJsonGenerator(resp.getOutputStream()); out.writeStartObject(); out.writeStringField("status", "error"); out.writeStringField("message", e.toString()); out.writeEndObject(); out.close(); } }
@Override public final byte[] serialize(MediaContent content) throws IOException { ByteArrayOutputStream baos = outputStream(content); JsonGenerator generator = constructGenerator(baos); writeMediaContent(generator, content); generator.close(); return baos.toByteArray(); }
private static String getModuleDescriptions(JavaScriptModulesConfig jsModulesConfig) throws IOException { JsonFactory jsonFactory = new JsonFactory(); StringWriter writer = new StringWriter(); JsonGenerator jg = jsonFactory.createGenerator(writer); jsModulesConfig.writeModuleDescriptions(jg); jg.close(); return writer.getBuffer().toString(); }
@Override public final void serializeItems(MediaContent[] items, OutputStream out) throws IOException { JsonGenerator generator = constructGenerator(out); // JSON allows simple sequences, so: for (int i = 0, len = items.length; i < len; ++i) { writeMediaContent(generator, items[i]); } generator.close(); }
public InputStream verifyDatatype2(Profile p, Profile baseP, String id, String type) { String result = ""; // Datatype dt = p.getDatatypeLibrary().findOne(id); try { // Create temporary file File tmpJsonFile = File.createTempFile("resultTmp", ".json"); // Generate json file JsonFactory factory = new JsonFactory(); JsonGenerator generator = factory.createGenerator(new FileWriter(tmpJsonFile)); generator.setPrettyPrinter(new DefaultPrettyPrinter()); generator.writeStartObject(); generator.writeStringField("id", id); generator.writeStringField("type", type); generator.writeArrayFieldStart("eltVerification"); // for (Component c : dt.getComponents()){ // generator.writeStartObject(); // generator.writeStringField("eltName", "usage"); // generator.writeStringField("eltAtt", c.getUsage().value()); // result = this.validateChangeUsage(p.getMetaData().getHl7Version(), // baseP.getDatatypeLibrary().findOneComponent(c.getId()).getUsage(), // p.getDatatypeLibrary().findOneComponent(c.getId()).getUsage()); // generator.writeStringField("result", result); // generator.writeEndObject(); // // generator.writeStartObject(); // generator.writeStringField("eltName", "minLength"); // generator.writeStringField("eltAtt", String.valueOf(c.getMinLength())); // result = this.validateChangeLength(String.valueOf(c.getMinLength()), c.getMaxLength()); // generator.writeStringField("result", result); // generator.writeEndObject(); // // generator.writeStartObject(); // generator.writeStringField("eltName", "maxLength"); // generator.writeStringField("eltAtt", String.valueOf(c.getMaxLength())); // result = this.validateChangeLength(String.valueOf(c.getMinLength()), c.getMaxLength()); // generator.writeStringField("result", result); // generator.writeEndObject(); // // } generator.writeEndArray(); generator.writeEndObject(); generator.close(); return FileUtils.openInputStream(tmpJsonFile); } catch (IOException e) { return new NullInputStream(1L); } }
protected void writeDataTemplate( Object data, DataSchema schema, JsonGenerator generator, boolean order) throws IOException { if (order) { JsonTraverseCallback callback = new SchemaOrderTraverseCallback(schema, generator); Data.traverse(data, callback); generator.flush(); generator.close(); } else { writeObject(data, generator); } }
@Override public String toJson(JsonFactory jsonFactory) throws IOException { try (StringWriter sw = new StringWriter(); JsonGenerator jg = jsonFactory.createGenerator(sw)) { jg.writeStartArray(); jg.writeNumber(getTypeId()); jg.writeString(getTopicURI()); jg.writeEndArray(); jg.close(); return sw.toString(); } }
void doGiveHint(HanabiGame game, HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException, HanabiException { String target = req.getParameter("target"); String hint = req.getParameter("hint"); game.giveHint(target, hint); JsonGenerator out = new JsonFactory().createJsonGenerator(resp.getOutputStream()); out.writeStartObject(); out.writeStringField("message", "hint given; " + game.hintsLeft + " hints left"); out.writeEndObject(); out.close(); }
public void testInvalidArrayWrite() throws Exception { StringWriter sw = new StringWriter(); JsonGenerator gen = new JsonFactory().createGenerator(sw); gen.writeStartArray(); // Mismatch: try { gen.writeEndObject(); fail("Expected an exception for mismatched array/object write"); } catch (JsonGenerationException e) { verifyException(e, "Current context not an object"); } gen.close(); }
/** * 把对象转成json格式 * * @param obj 需要转的对象 * @return String */ @SuppressWarnings("rawtypes") public String jsonObject(List list) { StringWriter sw = new StringWriter(); JsonGenerator gen; try { gen = new JsonFactory().createGenerator(sw); getMapper().writeValue(gen, list); gen.close(); } catch (Exception e) { } return sw.toString(); }
public void setSource(TreeNode tree) throws IOException { JsonFactory jsonFactory = new JsonFactory(); if (buffer == null) { buffer = Unpooled.buffer(); } else { buffer.clear(); } type = QueueMessageType.JSON; try (ByteBufOutputStream outputStream = new ByteBufOutputStream(buffer)) { JsonGenerator generator = jsonFactory.createGenerator(outputStream); generator.setCodec(new ObjectMapper()); generator.writeTree(tree); generator.close(); } }
public static String Object2Json(Object o) { try { ObjectMapper mapper = new ObjectMapper(); StringWriter writer = new StringWriter(); JsonFactory factory = mapper.getFactory(); JsonGenerator gen = factory.createGenerator(writer); mapper.writeValue(gen, o); gen.close(); String json = writer.toString(); writer.close(); return json; } catch (Exception e) { e.printStackTrace(); return null; } }
private static FullHttpResponse newHttpResponseWithMessage( HttpResponseStatus status, @Nullable String message) { // this is an "expected" exception, no need to send back stack trace StringBuilder sb = new StringBuilder(); try { JsonGenerator jg = jsonFactory.createGenerator(CharStreams.asWriter(sb)); jg.writeStartObject(); jg.writeStringField("message", message); jg.writeEndObject(); jg.close(); return HttpServices.createJsonResponse(sb.toString(), status); } catch (IOException f) { logger.error(f.getMessage(), f); return new DefaultFullHttpResponse(HTTP_1_1, INTERNAL_SERVER_ERROR); } }