下面列出了com.fasterxml.jackson.databind.ObjectMapper#readTree ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
public static void main(String[] args) throws Exception {
if (args.length != 2) {
System.out.println("Usage: java com.schibsted.spt.data.jslt.cli.JSLT <jslt file> <json input file>");
System.exit(1);
}
Expression expr = Parser.compile(new File(args[0]));
// if (expr instanceof ExpressionImpl)
// ((ExpressionImpl) expr).dump();
ObjectMapper mapper = new ObjectMapper();
JsonNode input = mapper.readTree(new File(args[1]));
JsonNode output = expr.apply(input);
if (output == null)
System.out.println("WARN: returned Java null!");
System.out.println(mapper.writerWithDefaultPrettyPrinter()
.writeValueAsString(output));
}
@Override
public void decode(String msg) {
Preconditions.checkNotNull(msg);
ObjectMapper mapper = new ObjectMapper();
try {
JsonNode root = mapper.readTree(msg);
// header
this.setVersion(root.get("header").get("version").asText());
this.setTopicName(root.get("header").get("topicName").asText());
// body
this.setPurseId(root.get("body").get("purseId").asText());
this.setMerchantName(root.get("body").get("merchantName").asText());
this.setChargeMoney(root.get("body").get("chargeMoney").asText());
this.setOrderId(root.get("body").get("orderId").asText());
this.setEventType(root.get("body").get("eventType").asText());
} catch (IOException e) {
throw new RuntimeException("OrderStatusUpdateProtocol消息反序列化异常", e);
}
}
@Test
void testOutputWithBaseOnly() throws IOException
{
String baseValue = "bin/Base.air";
ObjectMapper mapper = new ObjectMapper();
JsonNode baseConfigData = mapper.readTree(
"{" +
"\"airOptions\": {" +
"\"output\": \"" + baseValue + "\"" +
"}" +
"}"
);
JsonNode configData = mapper.readTree("{}");
JsonNode result = ConfigUtils.mergeConfigs(configData, baseConfigData);
Assertions.assertTrue(result.has(TopLevelFields.AIR_OPTIONS));
JsonNode airOptions = result.get(TopLevelFields.AIR_OPTIONS);
Assertions.assertTrue(airOptions.isObject());
Assertions.assertTrue(airOptions.has(AIROptions.OUTPUT));
String resultValue = airOptions.get(AIROptions.OUTPUT).asText();
Assertions.assertEquals(baseValue, resultValue);
}
@Test
public void simple() throws IOException {
encoder.start();
final LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
final Logger logger = lc.getLogger(LOGGER_NAME);
final String logMsg = encodeToStr(simpleLoggingEvent(logger, null));
final ObjectMapper om = new ObjectMapper();
final JsonNode jsonNode = om.readTree(logMsg);
basicValidation(jsonNode);
final LineReader msg =
new LineReader(new StringReader(jsonNode.get("full_message").textValue()));
assertEquals("message 1", msg.readLine());
}
@Test
public void customThreadNameKey() throws IOException {
encoder.setThreadNameKey("Thread");
encoder.start();
final LoggerContext lc = (LoggerContext) LoggerFactory.getILoggerFactory();
final Logger logger = lc.getLogger(LOGGER_NAME);
final LoggingEvent event = simpleLoggingEvent(logger, null);
final String logMsg = encodeToStr(event);
final ObjectMapper om = new ObjectMapper();
final JsonNode jsonNode = om.readTree(logMsg);
coreValidation(jsonNode);
assertNotNull(jsonNode.get("_Thread").textValue());
assertEquals(LOGGER_NAME, jsonNode.get("_logger_name").textValue());
assertNull(jsonNode.get("_exception"));
}
@Test(dataProviderClass = ObjectIdTestDataProvider.class, dataProvider = "createObjectId")
public void testMarshaller(String className, long longId) throws Exception {
JsonNodeMarshaller jsonNodeMarshaller = new JsonNodeMarshaller();
ObjectId objectId1 = new ObjectId(className, new Id(longId));
ObjectMapper mapper = new ObjectMapper();
String json = mapper.writeValueAsString(objectId1);
JsonNode jsonNode = mapper.readTree(json);
// JsonNode node = objectMapper.valueToTree(map);
// JsonNode node = mapper.convertValue(object, JsonNode.class);
byte[] bytes = jsonNodeMarshaller.toBytes(jsonNode);
JsonNode jsonNode1 = jsonNodeMarshaller.fromBytes(bytes);
ObjectId objectId2 = mapper.convertValue(jsonNode1, ObjectId.class);
System.out.println("before JsonNodeMarshaller: objectId=" + objectId1.toStringForm());
System.out.println("after JsonNodeMarshaller : objectId=" + objectId2.toStringForm());
Assert.assertTrue(objectId1.equals(objectId2), " marshalled object should be equal to the original");
}
@Test
public void shouldListErrors() throws Exception {
// when
final String errors = when().get("/preparations/errors").asString();
final ObjectMapper mapper = new ObjectMapper();
final JsonNode actualErrorCodes = mapper.readTree(errors);
// then
assertTrue(actualErrorCodes.isArray());
assertTrue(actualErrorCodes.size() > 0);
for (final JsonNode currentCode : actualErrorCodes) {
assertTrue(currentCode.has("code"));
assertTrue(currentCode.has("http-status-code"));
}
}
public static void compareJson(String expected, String actual) throws IOException {
if(ElasticsearchCluster.USE_EXTERNAL_ES5){
// ignore json comparison for now
return;
}
ObjectMapper m = new ObjectMapper();
JsonNode expectedRootNode = m.readTree(expected);
JsonNode actualRootNode = m.readTree(actual);
if (!expectedRootNode.equals(actualRootNode)) {
ObjectWriter writer = m.writerWithDefaultPrettyPrinter();
String message = String.format("Comparison between JSON values failed.\nExpected:\n%s\nActual:\n%s", expected, actual);
// assertEquals gives a better diff
assertEquals(message, writer.writeValueAsString(expectedRootNode), writer.writeValueAsString(actualRootNode));
throw new RuntimeException(message);
}
}
@SuppressWarnings("unused")
private static void prettyPrint(String json) throws IOException {
ObjectMapper mapper = new ObjectMapper();
JsonNode node = mapper.readTree(json);
CustomPrettyPrinter prettyPrinter = new CustomPrettyPrinter();
prettyPrinter.indentArraysWith(DefaultIndenter.SYSTEM_LINEFEED_INSTANCE);
StringBuilder sb = new StringBuilder();
JsonGenerator jg = mapper.getFactory().createGenerator(CharStreams.asWriter(sb))
.setPrettyPrinter(prettyPrinter);
jg.writeTree(node);
jg.close();
System.out.println(sb.toString().replace("\"", "\\\"").replace(DefaultIndenter.SYS_LF,
"\"" + DefaultIndenter.SYS_LF + " + \""));
}
public static CatalogResponse readCatalogResponse(String msg) {
ObjectMapper objectMapper = new ObjectMapper();
try {
JsonNode node = objectMapper.readTree(msg);
return objectMapper.treeToValue(node, CatalogResponse.class);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
@Test
public void callMethodWithVarArgParameters() throws Exception {
Map<String, Object> paramsMap = new HashMap<>();
paramsMap.put("argOne", "one");
paramsMap.put("argTwo", 2);
paramsMap.put("argThree", "three");
paramsMap.put("argFour", 4);
paramsMap.put("argFive", (Object) "five");
paramsMap.put("argSix", 6.0f);
paramsMap.put("argSeven", 7d);
Object[] callParams = new Object[paramsMap.size() * 2];
int i = 0;
for (Map.Entry<String, Object> entry : paramsMap.entrySet()) {
callParams[i++] = entry.getKey();
callParams[i++] = entry.getValue();
}
jsonRpcServerAnnotatedMethod.handleRequest(
messageWithMapParamsStream("varargObjectMethod", callParams),
byteArrayOutputStream
);
JsonNode res = result();
ObjectMapper mapper = new ObjectMapper();
JsonNode resultNode = mapper.readTree(res.asText());
// params order saved during call, but order not guaranteed
ObjectNode expectedResult = mapper.valueToTree(paramsMap);
expectedResult.set("argTwo", mapper.valueToTree(2));
expectedResult.set("argFour", mapper.valueToTree(4));
Assert.assertEquals(expectedResult.toString(), resultNode.toString());
}
@Test
public void T_create_json_withNullParser() throws IOException {
ObjectMapper mapper = new ObjectMapper();
JacksonMessageWriter writer = new JacksonMessageWriter();
IParser parser = null;
byte[] result = writer.create( parser );
JsonNode node = mapper.readTree( result );
assertTrue( ( node instanceof NullNode ) );
}
@Test
public void testInvalidConfig() throws IOException {
ObjectMapper om = new ObjectMapper();
JsonNode json = om.readTree(Resources.getResource(INVALID_CONFIG_FILE_PATH));
DefaultDhcpRelayConfig config = new DefaultDhcpRelayConfig();
json = json.path("apps").path(DHCP_RELAY_APP).path(DefaultDhcpRelayConfig.KEY);
config.init(APP_ID, DefaultDhcpRelayConfig.KEY, json, om, null);
assertFalse(config.isValid());
}
@Before
public void setUp() throws Exception {
InputStream jsonStream = RouteConfigTest.class
.getResourceAsStream("/route-config.json");
ApplicationId subject = new TestApplicationId(KEY);
ObjectMapper mapper = new ObjectMapper();
JsonNode jsonNode = mapper.readTree(jsonStream);
ConfigApplyDelegate delegate = new MockDelegate();
config = new RouteConfig();
config.init(subject, KEY, jsonNode, mapper, delegate);
}
public static List<String> parseStringList(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 mapper.convertValue(leaf, new TypeReference<List<String>>() {
});
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
public static Optional<JsonNode> retrieveCommandResult(DriverHandler handler, List<String> cmds) {
RestSBController controller = checkNotNull(handler.get(RestSBController.class));
DeviceId deviceId = checkNotNull(handler.data()).deviceId();
String request = generate(cmds);
log.debug("request :{}", request);
String response = controller.post(deviceId, API_ENDPOINT, new ByteArrayInputStream(request.getBytes()),
MediaType.APPLICATION_JSON_TYPE, String.class);
log.debug("response :{}", response);
try {
ObjectMapper mapper = new ObjectMapper();
ObjectNode node = (ObjectNode) mapper.readTree(response);
if (node.has(ERROR)) {
log.error("Error {}", node.get(ERROR));
return Optional.empty();
} else {
return Optional.ofNullable(node.get(RESULT));
}
} catch (IOException e) {
log.warn("IO exception occurred because of ", e);
}
return Optional.empty();
}
private JsonNode toJsonNode(JsonObject jsonObject) throws IOException {
ObjectMapper objectMapper = new ObjectMapper();
return objectMapper.readTree(jsonObject.toString());
}
private void assertToken(String accessToken, boolean expectActive) throws IOException {
String introspectionResponse = oauth.introspectAccessTokenWithClientCredential("customer-portal", "password", accessToken);
ObjectMapper objectMapper = new ObjectMapper();
JsonNode jsonNode = objectMapper.readTree(introspectionResponse);
Assert.assertEquals(expectActive, jsonNode.get("active").asBoolean());
}
@Test
public void givenTwoSameNestedJsonDataObjects_whenCompared_thenEqual() throws IOException {
ObjectMapper mapper = new ObjectMapper();
String s1 = "{\"employee\": {\"id\": \"1212\",\"fullName\": \"John Miles\",\"age\": 34, \"contact\":{\"email\": \"[email protected]\",\"phone\": \"9999999999\"} }}";
String s2 = "{\"employee\": {\"id\": \"1212\",\"fullName\": \"John Miles\",\"age\": 34, \"contact\":{\"email\": \"[email protected]\",\"phone\": \"9999999999\"} }}";
JsonNode actualObj1 = mapper.readTree(s1);
JsonNode actualObj2 = mapper.readTree(s2);
assertEquals(actualObj1, actualObj2);
}
/**
* Get response code from the response string.
*
* @param response
* @return
* @throws Exception
*/
public int getResponseCode(String response) throws Exception {
ObjectMapper mapper = new ObjectMapper();
JsonNode node = mapper.readTree(response);
return mapper.treeToValue(node.get("responseCode"), Integer.class);
}