下面列出了com.fasterxml.jackson.databind.node.JsonNodeFactory#objectNode ( ) 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
protected void afterProducer(Exchange exchange) throws IOException {
Message in = exchange.getIn();
JsonNodeFactory factory = JsonNodeFactory.instance;
ObjectNode statusNode = factory.objectNode();
int response = 400;
String info = "No Information";
HttpStatusCode code = in.getBody(HttpStatusCode.class);
if (code != null) {
response = code.getStatusCode();
info = code.getInfo();
}
statusNode.put("Response", response);
statusNode.put("Information", info);
String json = OBJECT_MAPPER.writeValueAsString(statusNode);
in.setBody(json);
}
private EventEntity mockEvent(EventType eventType) throws Exception {
final JsonNodeFactory factory = JsonNodeFactory.instance;
ObjectNode node = factory.objectNode();
node.set("id", factory.textNode(API_ID));
Map<String, String> properties = new HashMap<String, String>();
properties.put(Event.EventProperties.API_ID.getValue(), API_ID);
properties.put(Event.EventProperties.USER.getValue(), USER_NAME);
Api api = new Api();
api.setId(API_ID);
EventEntity event = new EventEntity();
event.setType(eventType);
event.setId(UUID.randomUUID().toString());
event.setPayload(objectMapper.writeValueAsString(api));
event.setCreatedAt(new Date());
event.setUpdatedAt(event.getCreatedAt());
event.setProperties(properties);
return event;
}
private EventEntity mockEvent(EventType eventType) throws Exception {
final JsonNodeFactory factory = JsonNodeFactory.instance;
ObjectNode node = factory.objectNode();
node.set("id", factory.textNode(API_ID));
Map<String, String> properties = new HashMap<>();
properties.put(Event.EventProperties.API_ID.getValue(), API_ID);
properties.put(Event.EventProperties.USER.getValue(), USER_NAME);
Api api = new Api();
api.setId(API_ID);
EventEntity event = new EventEntity();
event.setType(eventType);
event.setId(UUID.randomUUID().toString());
event.setPayload(objectMapper.writeValueAsString(api));
event.setCreatedAt(new Date());
event.setUpdatedAt(event.getCreatedAt());
event.setProperties(properties);
return event;
}
private static PluginResult getResult(String action, JsonNode data, JsonNode error) {
JsonNodeFactory factory = JsonNodeFactory.instance;
ObjectNode resultObject = factory.objectNode();
if (action != null) {
resultObject.set(JsParams.General.ACTION, factory.textNode(action));
}
if (data != null) {
resultObject.set(JsParams.General.DATA, data);
}
if (error != null) {
resultObject.set(JsParams.General.ERROR, error);
}
return new PluginResult(PluginResult.Status.OK, resultObject.toString());
}
@Override
public void setData(ObjectNode mainNode, ArrayNode arrayNode)
throws AxelorException, JSONException {
mainNode.put("status", 0);
mainNode.set("data", arrayNode);
Optional<Address> optionalAddress = Beans.get(UserService.class).getUserActiveCompanyAddress();
if (optionalAddress.isPresent()) {
Optional<Pair<BigDecimal, BigDecimal>> latLong =
Beans.get(AddressService.class).getOrUpdateLatLong(optionalAddress.get());
if (latLong.isPresent()) {
JsonNodeFactory factory = JsonNodeFactory.instance;
ObjectNode objectNode = factory.objectNode();
objectNode.put("lat", latLong.get().getLeft());
objectNode.put("lng", latLong.get().getRight());
mainNode.set("company", objectNode);
}
}
}
private ObjectNode deserializeRomeEntry(SyndEntry entry) {
JsonNodeFactory factory = JsonNodeFactory.instance;
ObjectNode root = factory.objectNode();
serializeString(entry.getAuthor(), "author", root);
serializeListOfStrings(entry.getAuthors(), "authors", root, factory);
serializeCategories(root, factory, entry.getCategories());
serializeContents(root, factory, entry.getContents());
serializeListOfStrings(entry.getContributors(), "contributors", root, factory);
serializeDescription(root, factory, entry.getDescription());
serializeEnclosures(root, factory, entry.getEnclosures());
serializeForeignMarkUp(root, factory, entry.getForeignMarkup());
serializeString(entry.getLink(), "link", root);
serializeLinks(root, factory, entry.getLinks());
serializeModules(root, factory, entry.getModules());
serializeDate(root, entry.getPublishedDate(), "publishedDate");
serializeSource(root, factory, entry.getSource());
serializeString(entry.getTitle(), "title", root);
serializeDate(root, entry.getUpdatedDate(), "updateDate");
serializeString(entry.getUri(), "uri", root);
return root;
}
private void serializeContents(ObjectNode root, JsonNodeFactory factory, List contents) {
if (contents == null || contents.size() == 0) {
return;
}
ArrayNode contentsArray = factory.arrayNode();
for (Object obj : contents) {
ObjectNode content = factory.objectNode();
if (obj instanceof com.rometools.rome.feed.rss.Content) {
com.rometools.rome.feed.rss.Content rssContent = (com.rometools.rome.feed.rss.Content) obj;
content.put("type", rssContent.getType());
content.put("value", rssContent.getValue());
}
if (obj instanceof com.rometools.rome.feed.atom.Content) {
com.rometools.rome.feed.atom.Content atomContent = (com.rometools.rome.feed.atom.Content) obj;
content.put("type", atomContent.getType());
content.put("value", atomContent.getValue());
content.put("mode", atomContent.getMode());
content.put("src", atomContent.getSrc());
}
contentsArray.add(content);
}
root.put("contents", contentsArray);
}
private void serializeDescription(ObjectNode root, JsonNodeFactory factory, SyndContent synd) {
if (synd == null) {
return;
}
ObjectNode content = factory.objectNode();
if (synd.getValue() != null) {
content.put("value", synd.getValue());
}
if (synd.getMode() != null) {
content.put("mode", synd.getMode());
}
if (synd.getType() != null) {
content.put("type", synd.getType());
}
root.put("description", content);
}
@Override
public String convertToDatabaseColumn(final ReadOnlyStringMap contextData) {
if (contextData == null) {
return null;
}
try {
final JsonNodeFactory factory = OBJECT_MAPPER.getNodeFactory();
final ObjectNode root = factory.objectNode();
contextData.forEach(new BiConsumer<String, Object>() {
@Override
public void accept(final String key, final Object value) {
// we will cheat here and write the toString of the Object... meh, but ok.
root.put(key, String.valueOf(value));
}
});
return OBJECT_MAPPER.writeValueAsString(root);
} catch (final Exception e) {
throw new PersistenceException("Failed to convert contextData to JSON string.", e);
}
}
private void serializeSource(ObjectNode root, JsonNodeFactory factory, SyndFeed source) {
if (source == null) {
return;
}
ObjectNode sourceNode = factory.objectNode();
serializeString(source.getAuthor(), "author", sourceNode);
serializeListOfStrings(source.getAuthors(), "authors", sourceNode, factory);
serializeCategories(sourceNode, factory, source.getCategories());
serializeString(source.getCopyright(), "copyright", sourceNode);
serializeListOfStrings(source.getContributors(), "contributors", sourceNode, factory);
serializeString(source.getDescription(), "description", sourceNode);
serializeDescription(sourceNode, factory, source.getDescriptionEx());
// source.getEntries(); wtf?
serializeString(source.getFeedType(), "feedType", sourceNode);
serializeImage(sourceNode, factory, source.getImage());
serializeForeignMarkUp(sourceNode, factory, source.getForeignMarkup());
serializeString(source.getLanguage(), "language", sourceNode);
serializeString(source.getLink(), "link", sourceNode);
serializeListOfStrings(source.getLinks(), "links", sourceNode, factory);
serializeModules(sourceNode, factory, source.getModules());
serializeDate(sourceNode, source.getPublishedDate(), "publishedDate");
serializeString(source.getTitle(), "title", sourceNode);
serializeString(source.getUri(), "uri", sourceNode);
root.put("source", sourceNode);
}
/**
* Renders a {@link Patch} as a {@link JsonNode}.
* @param patch the patch
* @return a {@link JsonNode} containing JSON Patch.
*/
public JsonNode convert(Patch patch) {
List<PatchOperation> operations = patch.getOperations();
JsonNodeFactory nodeFactory = JsonNodeFactory.instance;
ArrayNode patchNode = nodeFactory.arrayNode();
for (PatchOperation operation : operations) {
ObjectNode opNode = nodeFactory.objectNode();
opNode.set("op", nodeFactory.textNode(operation.getOp()));
opNode.set("path", nodeFactory.textNode(operation.getPath()));
if (operation instanceof FromOperation) {
FromOperation fromOp = (FromOperation) operation;
opNode.set("from", nodeFactory.textNode(fromOp.getFrom()));
}
Object value = operation.getValue();
if (value != null) {
opNode.set("value", MAPPER.valueToTree(value));
}
patchNode.add(opNode);
}
return patchNode;
}
@Test
public void shouldTryToLookupInJson() {
final JsonNodeFactory factory = JsonNodeFactory.instance;
final ObjectNode obj = factory.objectNode();
obj.set("a", factory.arrayNode().add("b").add("c"));
obj.set("x", factory.objectNode().set("y", factory.objectNode().put("z", "!")));
assertThat(ErrorMap.tryLookingUp(obj, "a")).contains("b");
assertThat(ErrorMap.tryLookingUp(obj, "a", "b")).isEmpty();
assertThat(ErrorMap.tryLookingUp(obj, "x", "y")).contains("{\"z\":\"!\"}");
assertThat(ErrorMap.tryLookingUp(obj, "x", "y", "z")).contains("!");
}
/** Converts a {@link ReadableMap} into an Json {@link ObjectNode} */
static ObjectNode toJsonObject(ReadableMap readableMap) {
JsonNodeFactory nodeFactory = JsonNodeFactory.instance;
ObjectNode result = nodeFactory.objectNode();
ReadableMapKeySetIterator iterator = readableMap.keySetIterator();
while (iterator.hasNextKey()) {
String key = iterator.nextKey();
ReadableType type = readableMap.getType(key);
switch (type) {
case Null:
result.putNull(key);
break;
case Boolean:
result.put(key, readableMap.getBoolean(key));
break;
case Number:
result.put(key, readableMap.getDouble(key));
break;
case String:
result.put(key, readableMap.getString(key));
break;
case Map:
result.set(key, toJsonObject(readableMap.getMap(key)));
break;
case Array:
result.set(key, toJsonArray(readableMap.getArray(key)));
break;
default:
Log.e(TAG, "Could not convert object with key: " + key + ".");
}
}
return result;
}
/**
* Tests the multi point to single point intent decoding with JSON codec.
*
* @throws IOException if JSON processing fails
*/
@Test
public void decodeMultiPointToSinglePointIntent() throws IOException {
final JsonNodeFactory nodeFactory = JsonNodeFactory.instance;
ObjectNode json = nodeFactory.objectNode();
json.put("type", "MultiPointToSinglePointIntent");
json.put("id", "0x0");
json.put("appId", "foo");
json.put("priority", 100);
ArrayNode ingress = nodeFactory.arrayNode();
ObjectNode ingressPoint = nodeFactory.objectNode();
ingressPoint.put("port", "3");
ingressPoint.put("device", "333");
ingress.add(ingressPoint);
ObjectNode ingressPoint2 = nodeFactory.objectNode();
ingressPoint2.put("port", "1");
ingressPoint2.put("device", "111");
ingress.add(ingressPoint2);
json.set("ingressPoint", ingress);
ObjectNode egressPoint = nodeFactory.objectNode();
egressPoint.put("port", "2");
egressPoint.put("device", "222");
json.set("egressPoint", egressPoint);
assertThat(json, notNullValue());
JsonCodec<MultiPointToSinglePointIntent> intentCodec = context.codec(MultiPointToSinglePointIntent.class);
assertThat(intentCodec, notNullValue());
final MultiPointToSinglePointIntent intent = intentCodec.decode(json, context);
assertThat(intent.toString(), notNullValue());
assertThat(intent, instanceOf(MultiPointToSinglePointIntent.class));
assertThat(intent.priority(), is(100));
assertThat(intent.ingressPoints().toString(), is("[333/3, 111/1]"));
assertThat(intent.egressPoint().toString(), is("222/2"));
}
private static JsonNode createErrorNode(int errorCode, String errorDescription) {
JsonNodeFactory factory = JsonNodeFactory.instance;
ObjectNode errorData = factory.objectNode();
errorData.set(JsParams.Error.CODE, factory.numberNode(errorCode));
errorData.set(JsParams.Error.DESCRIPTION, factory.textNode(errorDescription));
return errorData;
}
private String generateJson() {
final JsonNodeFactory nodeFactory = JsonNodeFactory.instance;
ArrayNode filesListNode = nodeFactory.arrayNode();
for (ManifestFile fileEntry : files) {
ObjectNode fileNode = nodeFactory.objectNode();
fileNode.set(JsonKeys.FILE_PATH, nodeFactory.textNode(fileEntry.name));
fileNode.set(JsonKeys.FILE_HASH, nodeFactory.textNode(fileEntry.hash));
filesListNode.add(fileNode);
}
return filesListNode.toString();
}
/**
* Convert object into JSON string
*
* @return JSON string
*/
@Override
public String toString() {
JsonNodeFactory nodeFactory = JsonNodeFactory.instance;
ObjectNode object = nodeFactory.objectNode();
object.set(APPLICATION_BUILD_VERSION, nodeFactory.numberNode(appBuildVersion));
object.set(WWW_FOLDER_INSTALLED_FLAG, nodeFactory.booleanNode(wwwFolderInstalled));
object.set(CURRENT_RELEASE_VERSION_NAME, nodeFactory.textNode(currentReleaseVersionName));
object.set(PREVIOUS_RELEASE_VERSION_NAME, nodeFactory.textNode(previousReleaseVersionName));
object.set(READY_FOR_INSTALLATION_RELEASE_VERSION_NAME, nodeFactory.textNode(readyForInstallationReleaseVersionName));
return object.toString();
}
private JsonNode generateJson() {
JsonNodeFactory nodeFactory = JsonNodeFactory.instance;
ObjectNode node = nodeFactory.objectNode();
node.set(JsonKeys.CONTENT_URL, nodeFactory.textNode(contentUrl));
node.set(JsonKeys.MINIMUM_NATIVE_VERSION, nodeFactory.numberNode(minimumNativeVersion));
node.set(JsonKeys.VERSION, nodeFactory.textNode(releaseVersion));
node.set(JsonKeys.UPDATE, nodeFactory.textNode(updateTime.toString()));
return node;
}
private Pair<JsonNode, JsonNode> constructJsonTree(String... properties) {
JsonNodeFactory factory = new JsonNodeFactory(true);
final ObjectNode parent = factory.objectNode();
ObjectNode current = parent;
for (String property : properties) {
current = current.putObject(property);
}
current.put("key", "value");
return Pair.of((JsonNode) parent, (JsonNode) current);
}
private static ObjectNode getJsonNode(JsonNodeFactory FACTORY, Diff diff, EnumSet<DiffFlags> flags) {
ObjectNode jsonNode = FACTORY.objectNode();
jsonNode.put(Constants.OP, diff.getOperation().rfcName());
switch (diff.getOperation()) {
case MOVE:
case COPY:
jsonNode.put(Constants.FROM, diff.getPath().toString()); // required {from} only in case of Move Operation
jsonNode.put(Constants.PATH, diff.getToPath().toString()); // destination Path
break;
case REMOVE:
jsonNode.put(Constants.PATH, diff.getPath().toString());
if (!flags.contains(DiffFlags.OMIT_VALUE_ON_REMOVE))
jsonNode.set(Constants.VALUE, diff.getValue());
break;
case REPLACE:
if (flags.contains(DiffFlags.ADD_ORIGINAL_VALUE_ON_REPLACE)) {
jsonNode.set(Constants.FROM_VALUE, diff.getSrcValue());
}
case ADD:
case TEST:
jsonNode.put(Constants.PATH, diff.getPath().toString());
jsonNode.set(Constants.VALUE, diff.getValue());
break;
default:
// Safety net
throw new IllegalArgumentException("Unknown operation specified:" + diff.getOperation());
}
return jsonNode;
}