下面列出了怎么用com.fasterxml.jackson.databind.node.LongNode的API类实例代码及写法,或者点击链接到github查看源代码。
/**
* Judge Java objects and create JsonNode.
*/
public static JsonNode get( final Object obj ) throws IOException {
if ( obj instanceof PrimitiveObject ) {
return PrimitiveObjectToJsonNode.get( (PrimitiveObject)obj );
} else if ( obj instanceof String ) {
return new TextNode( (String)obj );
} else if ( obj instanceof Boolean ) {
return BooleanNode.valueOf( (Boolean)obj );
} else if ( obj instanceof Short ) {
return IntNode.valueOf( ( (Short)obj ).intValue() );
} else if ( obj instanceof Integer ) {
return IntNode.valueOf( (Integer)obj );
} else if ( obj instanceof Long ) {
return new LongNode( (Long)obj );
} else if ( obj instanceof Float ) {
return new DoubleNode( ( (Float)obj ).doubleValue() );
} else if ( obj instanceof Double ) {
return new DoubleNode( (Double)obj );
} else if ( obj instanceof byte[] ) {
return new BinaryNode( (byte[])obj );
} else if ( obj == null ) {
return NullNode.getInstance();
} else {
return new TextNode( obj.toString() );
}
}
public JsonNode call(JsonNode input, JsonNode[] arguments) {
JsonNode array = arguments[0];
if (array.isNull())
return NullNode.instance;
else if (!array.isArray())
throw new JsltException("sum(): argument must be array, was " + array);
double sum = 0.0;
boolean integral = true;
for (int ix = 0; ix < array.size(); ix++) {
JsonNode value = array.get(ix);
if (!value.isNumber())
throw new JsltException("sum(): array must contain numbers, found " + value);
integral &= value.isIntegralNumber();
sum += value.doubleValue();
}
if (integral)
return new LongNode((long) sum);
else
return new DoubleNode(sum);
}
public JsonNode perform(JsonNode v1, JsonNode v2) {
if (v1.isNull() || v2.isNull())
return NullNode.instance;
// we only support the numeric operation and nothing else
v1 = NodeUtils.number(v1, true, location);
v2 = NodeUtils.number(v2, true, location);
if (v1.isIntegralNumber() && v2.isIntegralNumber()) {
long l1 = v1.longValue();
long l2 = v2.longValue();
if (l1 % l2 == 0)
return new LongNode(l1 / l2);
else
return new DoubleNode((double) l1 / (double) l2);
} else
return new DoubleNode(perform(v1.doubleValue(), v2.doubleValue()));
}
@Override
public Points deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
TreeNode n = jp.getCodec().readTree(jp);
Map<String, Object> points = new HashMap<>();
Iterator<String> namesIter = n.fieldNames();
while(namesIter.hasNext()) {
String field = namesIter.next();
TreeNode child = n.get(field);
Object o;
if (child instanceof DoubleNode || child instanceof FloatNode) {
o = ((NumericNode) child).doubleValue();
} else if (child instanceof IntNode || child instanceof LongNode) {
o = ((NumericNode) child).longValue();
} else {
throw new MergeException("Unsupported Type, " + child.getClass());
}
points.put(field, o);
}
return new Points(points);
}
@Activate
public void activate() {
KryoNamespace.Builder kryoBuilder = new KryoNamespace.Builder()
.register(KryoNamespaces.API)
.register(ConfigKey.class, ObjectNode.class, ArrayNode.class,
JsonNodeFactory.class, LinkedHashMap.class,
TextNode.class, BooleanNode.class,
LongNode.class, DoubleNode.class, ShortNode.class, IntNode.class,
NullNode.class);
configs = storageService.<ConfigKey, JsonNode>consistentMapBuilder()
.withSerializer(Serializer.using(kryoBuilder.build()))
.withName("onos-network-configs")
.withRelaxedReadConsistency()
.build();
configs.addListener(listener);
log.info("Started");
}
@Override
public JsonNode sample() {
synchronized (this) {
if (dist == null) {
int r = power >= 0 ? Integer.MAX_VALUE : Integer.MIN_VALUE;
if (power >= 0) {
for (int i = 0; i <= power; i++) {
r = Math.min(r, min + base.nextInt(max - min));
}
} else {
int n = -power;
for (int i = 0; i <= n; i++) {
r = Math.max(r, min + base.nextInt(max - min));
}
}
if (format == null) {
return new IntNode(r);
} else {
return new TextNode(String.format(format, r));
}
} else {
return new LongNode(dist.sample());
}
}
}
@SuppressWarnings("BooleanMethodIsAlwaysInverted")
private boolean addTimeFields(ObjectNode x) {
Event e = null;
while (e != Event.ACTION) {
e = step();
// System.out.printf("%8s/%-9s %11s %s %8.2f %8.2f %8.2f %8.2f\n",
// Util.isDaytime(Util.timeOfDay(now), sunriseTime, sunsetTime) ? "day" : "night",
// isActive ? "active" : "inactive",
// e, df.format((long) now),
// (nextQuery - now) / TimeUnit.HOURS.toMillis(1),
// (nextTransition - now) / TimeUnit.HOURS.toMillis(1),
// 24 * Util.fractionalPart((sunriseTime - Util.timeOfDay(now)) / TimeUnit.HOURS.toMillis(24)),
// 24 * Util.fractionalPart((sunsetTime - Util.timeOfDay(now)) / TimeUnit.HOURS.toMillis(24))
// );
if (e == Event.END) {
return false;
}
}
x.set("time", new TextNode(df.format((long) now)));
x.set("timestamp_ms", new LongNode((long) now));
x.set("timestamp_s", new LongNode((long) (now / 1000)));
return true;
}
/**
* Converts JsonNode to PrimitiveObject.
*/
public static PrimitiveObject get( final JsonNode jsonNode ) throws IOException {
if ( jsonNode instanceof TextNode ) {
return new StringObj( ( (TextNode)jsonNode ).textValue() );
} else if ( jsonNode instanceof BooleanNode ) {
return new BooleanObj( ( (BooleanNode)jsonNode ).booleanValue() );
} else if ( jsonNode instanceof IntNode ) {
return new IntegerObj( ( (IntNode)jsonNode ).intValue() );
} else if ( jsonNode instanceof LongNode ) {
return new LongObj( ( (LongNode)jsonNode ).longValue() );
} else if ( jsonNode instanceof DoubleNode ) {
return new DoubleObj( ( (DoubleNode)jsonNode ).doubleValue() );
} else if ( jsonNode instanceof BigIntegerNode ) {
return new StringObj( ( (BigIntegerNode)jsonNode ).bigIntegerValue().toString() );
} else if ( jsonNode instanceof DecimalNode ) {
return new StringObj( ( (DecimalNode)jsonNode ).decimalValue().toString() );
} else if ( jsonNode instanceof BinaryNode ) {
return new BytesObj( ( (BinaryNode)jsonNode ).binaryValue() );
} else if ( jsonNode instanceof POJONode ) {
return new BytesObj( ( (POJONode)jsonNode ).binaryValue() );
} else if ( jsonNode instanceof NullNode ) {
return NullObj.getInstance();
} else if ( jsonNode instanceof MissingNode ) {
return NullObj.getInstance();
} else {
return new StringObj( jsonNode.toString() );
}
}
/**
* Convert PrimitiveObject to JsonNode.
*/
public static JsonNode get( final PrimitiveObject obj ) throws IOException {
if ( obj == null ) {
return NullNode.getInstance();
}
switch ( obj.getPrimitiveType() ) {
case BOOLEAN:
return BooleanNode.valueOf( obj.getBoolean() );
case BYTE:
return IntNode.valueOf( obj.getInt() );
case SHORT:
return IntNode.valueOf( obj.getInt() );
case INTEGER:
return IntNode.valueOf( obj.getInt() );
case LONG:
return new LongNode( obj.getLong() );
case FLOAT:
return new DoubleNode( obj.getDouble() );
case DOUBLE:
return new DoubleNode( obj.getDouble() );
case STRING:
return new TextNode( obj.getString() );
case BYTES:
return new BinaryNode( obj.getBytes() );
default:
return NullNode.getInstance();
}
}
public static Optional<String> processTimeStrToLong(JsonNode data, ObjectNode detail) {
try {
Map<String, String> nameTypeMapping = Maps.newHashMap();
Map<String, ObjectNode> nameDetailMapping = Maps.newHashMap();
getMapping(detail, nameTypeMapping, nameDetailMapping);
Iterator<JsonNode> elements = data.elements();
boolean edit = false;
while (elements.hasNext()) {
JsonNode row = elements.next();
Iterator<Map.Entry<String, JsonNode>> fields = row.get(Constants.COLUMNS).fields();
while (fields.hasNext()) {
Map.Entry<String, JsonNode> field = fields.next();
String type = nameTypeMapping.get(field.getKey());
JsonNode value = field.getValue();
String valueStr = value.asText();
if (!Strings.isNullOrEmpty(valueStr) && (isTimeType(type) || isDateType(type))) {
edit = true;
if (isTimeType(type)) {
field.setValue(new LongNode(parseDataTime(TemplateContants.TIME_FORMATTER, valueStr)));
} else if (isDateType(type)) {
field.setValue(new LongNode(parseDataTime(TemplateContants.DATE_FORMATTER, valueStr)));
}
}
}
}
if (edit) {
return Optional.of(mapper.writeValueAsString(data));
} else {
return Optional.empty();
}
} catch (Exception e) {
throw new IllegalStateException("解析模版与文件时失败");
}
}
public JsonNode call(JsonNode input, JsonNode[] arguments) {
JsonNode number = arguments[0];
if (number.isNull())
return NullNode.instance;
else if (!number.isNumber())
throw new JsltException("round() cannot round a non-number: " + number);
return new LongNode(Math.round(number.doubleValue()));
}
public JsonNode call(JsonNode input, JsonNode[] arguments) {
JsonNode number = arguments[0];
if (number.isNull())
return NullNode.instance;
else if (!number.isNumber())
throw new JsltException("floor() cannot round a non-number: " + number);
return new LongNode((long) Math.floor(number.doubleValue()));
}
public JsonNode call(JsonNode input, JsonNode[] arguments) {
JsonNode number = arguments[0];
if (number.isNull())
return NullNode.instance;
else if (!number.isNumber())
throw new JsltException("ceiling() cannot round a non-number: " + number);
return new LongNode((long) Math.ceil(number.doubleValue()));
}
public JsonNode call(JsonNode input, JsonNode[] arguments) {
JsonNode dividend = arguments[0];
if (dividend.isNull())
return NullNode.instance;
else if (!dividend.isNumber())
throw new JsltException("mod(): dividend cannot be a non-number: " + dividend);
JsonNode divisor = arguments[1];
if (divisor.isNull())
return NullNode.instance;
else if (!divisor.isNumber())
throw new JsltException("mod(): divisor cannot be a non-number: " + divisor);
if (!dividend.isIntegralNumber() || !divisor.isIntegralNumber()) {
throw new JsltException("mod(): operands must be integral types");
} else {
long D = dividend.longValue();
long d = divisor.longValue();
if (d == 0)
throw new JsltException("mod(): cannot divide by zero");
long r = D % d;
if (r < 0) {
if (d > 0)
r += d;
else
r -= d;
}
return new LongNode(r);
}
}
public JsonNode perform(JsonNode v1, JsonNode v2) {
if (v1.isNull() || v2.isNull())
return NullNode.instance;
v1 = NodeUtils.number(v1, true, location);
v2 = NodeUtils.number(v2, true, location);
if (v1.isIntegralNumber() && v2.isIntegralNumber())
return new LongNode(perform(v1.longValue(), v2.longValue()));
else
return new DoubleNode(perform(v1.doubleValue(), v2.doubleValue()));
}
private <P> PaginatedList<T> pagedQueryView(String viewName, P startKey, P endKey, PaginationOffset<P> pagination, boolean descending, Function<P, ValueNode> startToNode) {
int limit = pagination.getLimit() != null ? pagination.getLimit() : DEFAULT_LIMIT;
int page = pagination.getPage() != null ? pagination.getPage() : 0;
String startDocId = pagination.getStartDocumentId();
ViewQuery viewQuery = createQuery(viewName)
.startKey(startKey)
.includeDocs(true)
.startDocId(startDocId)
.limit(limit)
.descending(descending);
if (endKey != null) {
viewQuery = viewQuery.endKey(endKey);
}
PageRequest.Builder builder = new PageRequest.Builder().pageSize(limit).page(page);
if (startKey !=null || startDocId != null) {
builder.nextKey(new PageRequest.KeyIdPair(pagination.getStartKey() == null ? null : startToNode.apply(pagination.getStartKey()), startDocId)).page(Math.max(page,1));
}
PageRequest pr = builder.build();
Page<T> ts = db.queryForPage(viewQuery, pr, type);
Object sk = ts.getTotalSize() > ts.getPageSize() && ts.getNextPageRequest() != null ? ts.getNextPageRequest().getStartKey() : null;
return new PaginatedList<>(
ts.getPageSize(),
ts.getTotalSize(),
ts.getRows(),
sk != null ?
new PaginatedDocumentKeyIdPair((sk instanceof NullNode) ? null : (sk instanceof LongNode) ? Collections.singletonList(""+((LongNode) sk).longValue()) : Collections.singletonList(((TextNode) sk).textValue()), ts.getNextPageRequest().getStartKeyDocId())
: null
);
}
@Test
public void testDateTime() {
String actual;
CLDR cldr = CLDR.get("en");
MessageFormats formats = new MessageFormats(cldr);
formats.setTimeZone("America/New_York");
String message = "{0 datetime date:long time:medium}";
long epoch = 1582129775000L;
actual = formats.formatter().format(message, args().add(new LongNode(epoch)));
assertEquals(actual, "February 19, 2020 at 11:29:35 AM");
}
@Test
public void testInterval() {
String actual;
CLDR cldr = CLDR.get("en");
MessageFormats formats = new MessageFormats(cldr);
formats.setTimeZone("America/New_York");
String message = "{0;1 datetime-interval}";
long epoch = 1582129775000L;
long extra = 86400000 + 3600000;
MessageArgs args = args().add(new LongNode(epoch)).add(new LongNode(epoch + extra));
actual = formats.formatter().format(message, args);
assertEquals(actual, "Feb 19 – 20, 2020");
}
private Example createExample(JsonNode node) {
if (node instanceof ObjectNode) {
ObjectExample obj = new ObjectExample();
ObjectNode on = (ObjectNode) node;
for (Iterator<Entry<String, JsonNode>> x = on.fields(); x.hasNext(); ) {
Entry<String, JsonNode> i = x.next();
String key = i.getKey();
JsonNode value = i.getValue();
obj.put(key, createExample(value));
}
return obj;
} else if (node instanceof ArrayNode) {
ArrayExample arr = new ArrayExample();
ArrayNode an = (ArrayNode) node;
for (JsonNode childNode : an) {
arr.add(createExample(childNode));
}
return arr;
} else if (node instanceof DoubleNode) {
return new DoubleExample(node.doubleValue());
} else if (node instanceof IntNode || node instanceof ShortNode) {
return new IntegerExample(node.intValue());
} else if (node instanceof FloatNode) {
return new FloatExample(node.floatValue());
} else if (node instanceof BigIntegerNode) {
return new BigIntegerExample(node.bigIntegerValue());
} else if (node instanceof DecimalNode) {
return new DecimalExample(node.decimalValue());
} else if (node instanceof LongNode) {
return new LongExample(node.longValue());
} else if (node instanceof BooleanNode) {
return new BooleanExample(node.booleanValue());
} else {
return new StringExample(node.asText());
}
}
@Override
public Date deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
JsonNode node = jp.getCodec().readTree(jp);
// 针对时间戳做优化
if(node instanceof LongNode || node instanceof IntNode) {
long timestamp = node.asLong();
if(timestamp < 4200000000L) { // 小于42亿认为是秒
return new Date(timestamp * 1000L);
} else {
return new Date(timestamp);
}
}
String date = node.asText();
if(date == null) {
return null;
}
date = date.trim();
if(date.isEmpty()) {
return null;
}
try {
return NimbleOrmDateUtils.parseThrowException(date);
} catch (ParseException e) {
throw new JsonParseException(jp,
"Unparseable date: \"" + date + "\". Supported formats: "
+ NimbleOrmDateUtils.DATE_FORMAT_REGEXPS.values());
}
}
@Override
public Optional<Long> deserialize(JsonNode json) {
if (json instanceof LongNode) {
return Optional.of(json.asLong());
} else if (json instanceof IntNode) {
return Optional.of(Long.valueOf(json.asInt()));
} else {
return Optional.empty();
}
}
/**
* Add datapoint of long type value.
*
* @param time datapoint's timestamp
* @param value datapoint's value
* @return Datapoint
*/
public Datapoint addLongValue(long time, long value) {
initialValues();
checkType(TsdbConstants.TYPE_LONG);
values.add(Lists.<JsonNode> newArrayList(new LongNode(time), new LongNode(value)));
return this;
}
/**
* Add datapoint of double type value.
*
* @param time datapoint's timestamp
* @param value datapoint's value
* @return Datapoint
*/
public Datapoint addDoubleValue(long time, double value) {
initialValues();
checkType(TsdbConstants.TYPE_DOUBLE);
values.add(Lists.<JsonNode> newArrayList(new LongNode(time), new DoubleNode(value)));
return this;
}
/**
* Add datapoint of String type value.
*
* @param time datapoint's timestamp
* @param value datapoint's value
* @return Datapoint
*/
public Datapoint addStringValue(long time, String value) {
initialValues();
checkType(TsdbConstants.TYPE_STRING);
values.add(Lists.<JsonNode> newArrayList(new LongNode(time), new TextNode(value)));
return this;
}
public Datapoint addBytesValue(long time, byte[] value) {
initialValues();
if (values != null && !values.isEmpty() && (type == null || !type.equals(TsdbConstants.TYPE_BYTES))) {
throw new IllegalStateException("There is already another type in datapoint, "
+ "could not add byte array type again");
}
type = TsdbConstants.TYPE_BYTES;
values.add(Lists.<JsonNode> newArrayList(new LongNode(time), new BinaryNode(value)));
return this;
}
@Activate
public void activate() {
Serializer serializer = Serializer.using(KryoNamespaces.API,
ObjectNode.class, ArrayNode.class,
JsonNodeFactory.class, LinkedHashMap.class,
TextNode.class, BooleanNode.class,
LongNode.class, DoubleNode.class, ShortNode.class,
IntNode.class, NullNode.class, UiSessionToken.class);
prefsConsistentMap = storageService.<String, ObjectNode>consistentMapBuilder()
.withName(ONOS_USER_PREFERENCES)
.withSerializer(serializer)
.withRelaxedReadConsistency()
.build();
prefsConsistentMap.addListener(prefsListener);
prefs = prefsConsistentMap.asJavaMap();
tokensConsistentMap = storageService.<UiSessionToken, String>consistentMapBuilder()
.withName(ONOS_SESSION_TOKENS)
.withSerializer(serializer)
.withRelaxedReadConsistency()
.build();
tokens = tokensConsistentMap.asJavaMap();
register(core);
log.info("Started");
}
@Test
public void longNode() throws Exception {
JsonNode jsonNode = underTest.apply(LongNode.valueOf(0L));
assertThat(jsonNode.isLong(), is(true));
assertThat(jsonNode.longValue(), is(0L));
}
@Test
public void T_get_long() throws IOException {
JsonNode node = PrimitiveObjectToJsonNode.get( new LongObj( 1L ) );
assertTrue( ( node instanceof LongNode ) );
}
@Test
public void T_get_longObject() throws IOException {
PrimitiveObject obj = JsonNodeToPrimitiveObject.get( LongNode.valueOf( 1L ) );
assertTrue( ( obj instanceof LongObj ) );
}
public static Optional<String> processTimeLongToStr(String dataId, JsonNode data, ObjectNode detail) {
if (!FileChecker.isTemplateFile(dataId)) {
return Optional.empty();
}
try {
Map<String, String> nameTypeMapping = Maps.newHashMap();
Map<String, ObjectNode> nameDetailMapping = Maps.newHashMap();
getMapping(detail, nameTypeMapping, nameDetailMapping);
Iterator<JsonNode> elements = data.elements();
boolean edit = false;
while (elements.hasNext()) {
JsonNode row = elements.next();
Iterator<Map.Entry<String, JsonNode>> fields = row.get(Constants.COLUMNS).fields();
while (fields.hasNext()) {
Map.Entry<String, JsonNode> field = fields.next();
String type = nameTypeMapping.get(field.getKey());
JsonNode value = field.getValue();
String valueStr = value.asText();
if (!Strings.isNullOrEmpty(valueStr) && (isTimeType(type) || isDateType(type))) {
edit = true;
Preconditions.checkArgument(value instanceof LongNode, "解析模版与文件时失败");
if (isTimeType(type)) {
field.setValue(new TextNode(TemplateContants.TIME_FORMATTER.print(value.longValue())));
} else if (isDateType(type)) {
field.setValue(new TextNode(TemplateContants.DATE_FORMATTER.print(value.longValue())));
}
}
}
}
if (edit) {
return Optional.of(mapper.writeValueAsString(data));
} else {
return Optional.empty();
}
} catch (Exception e) {
throw new IllegalStateException("解析模版与文件时失败");
}
}