Java JsonObject.getJsonObject方法代码示例

import io.vertx.core.json.JsonObject; //导入方法依赖的package包/类
protected void processOneResult(final JsonObject dataChange) {

		final JsonObject data = dataChange.getJsonObject("data");
		final JsonObject payload = data.getJsonObject("payload");
		// We send it off to the eventbus and in any case have the
		// final destination header set - just in case
		final EventBus eb = this.getVertx().eventBus();
		final DeliveryOptions opts = new DeliveryOptions();
		this.getListenerConfig().getEventBusAddresses().forEach(destination -> {
			opts.addHeader(Constants.BUS_FINAL_DESTINATION, destination);
		});

		// Intermediate step for deduplication of messages
		if (this.useDedupService()) {
			eb.publish(this.getListenerConfig().getEventBusDedupAddress(), payload, opts);
		} else {
			this.getListenerConfig().getEventBusAddresses().forEach(destination -> {
				try {
					eb.publish(destination, payload, opts);
					this.logger.info("Sending to [" + destination + "]:" + payload.toString());
				} catch (final Throwable t) {
					this.logger.error(t.getMessage(), t);
				}
			});
		}
	}
 

import io.vertx.core.json.JsonObject; //导入方法依赖的package包/类
public static Message createFromJSON (JsonObject json) {
    Message message = new Message();

    //get header information
    message.event = json.getString("event");
    String messageID = json.getString("messageID");
    int statusCode = json.getInteger("statusCode");
    message.type = ResponseType.getByString(json.getString("status"));
    message.data = json.getJsonObject("data");
    message.ssid = json.getString("ssid");

    if (!messageID.isEmpty() && !messageID.equals("none")) {
        //get UUID
        message.uuid = UUID.fromString(messageID);
    }

    return message;
}
 

import io.vertx.core.json.JsonObject; //导入方法依赖的package包/类
/**
 * @see net.wissel.salesforce.vertx.listener.CometD#processOneResult(io.vertx.core.json.JsonObject)
 */
@Override
protected void processOneResult(JsonObject dataChange) {
	final JsonObject data = dataChange.getJsonObject("data");
	final JsonObject payload = data.getJsonObject("payload");
	final String objectType = payload.getString("ObjectType__c");
	// We send it off to the eventbus
	final EventBus eb = this.getVertx().eventBus();
	this.getListenerConfig().getEventBusAddresses().forEach(destination -> {
		try {
			eb.publish(destination+objectType, payload);
			this.logger.info("Sending to [" + destination+objectType + "]:" + payload.toString());
		} catch (final Throwable t) {
			this.logger.error(t.getMessage(), t);
		}
	});
}
 

import io.vertx.core.json.JsonObject; //导入方法依赖的package包/类
private BridgeOptions configureBridgeOptions(JsonObject config) {
    BridgeOptions bridgeOptions = new BridgeOptions();
    JsonObject addresses=config.getJsonObject(ADDRESSES);

    JsonArray outbounds=addresses.getJsonArray(OUTBOUND);
    JsonArray inbounds=addresses.getJsonArray(INBOUND);

    outbounds.forEach(o-> addOutboundPermitted(bridgeOptions, (JsonObject) o));
    inbounds.forEach(i-> addInboundPermitted(bridgeOptions, (JsonObject) i));
    return bridgeOptions;
}
 

import io.vertx.core.json.JsonObject; //导入方法依赖的package包/类
private Resolver<T> getResolver(final RoutingContext context,
                                final Epsilon<T> income) {
    /** 1.Read the resolver first **/
    final Annotation annotation = income.getAnnotation();
    final Class<?> resolverCls = Instance.invoke(annotation, "resolver");
    /** 2.Check configured in default **/
    if (null == resolverCls) {
        /** 3. Old path **/
        final JsonObject content = NODE.read();
        final String header = context.request().getHeader(HttpHeaders.CONTENT_TYPE);
        final String resolver;
        if (null == header) {
            resolver = content.getString("default");
        } else {
            final MediaType type = MediaType.valueOf(header);
            final JsonObject resolverMap = content.getJsonObject(type.getType());
            resolver = resolverMap.getString(type.getSubtype());
        }
        LOGGER.info(Info.RESOLVER, resolver, header, context.request().absoluteURI());
        return Instance.singleton(resolver);
    } else {
        LOGGER.info(Info.RESOLVER_CONFIG, resolverCls);
        return Instance.singleton(resolverCls);
    }
}
 

import io.vertx.core.json.JsonObject; //导入方法依赖的package包/类
@Override
public ConcurrentMap<String, VertxOptions> visit(final String... keys)
        throws ZeroException {
    // 1. Must be the first line, fixed position.
    Ensurer.eqLength(getClass(), 0, (Object[]) keys);
    // 2. Visit the node for vertx
    final JsonObject data = this.NODE.read();
    // 3. Vertx node validation.
    final JsonObject vertxData = data.getJsonObject(KEY);
    LOGGER.info(Info.INF_B_VERIFY, KEY, getClass().getSimpleName(), vertxData);
    Fn.shuntZero(() -> Ruler.verify(KEY, vertxData), vertxData);
    // 4. Set cluster options
    this.clusterOptions = this.clusterTransformer.transform(data.getJsonObject(YKEY_CLUSTERED));
    // 5. Transfer Data
    return visit(vertxData.getJsonArray(YKEY_INSTANCE));
}
 

import io.vertx.core.json.JsonObject; //导入方法依赖的package包/类
/**
 * Searches for annotation in the given time range
 *
 * @param msg
 */
private void searchAnnotations(final Message<JsonObject> msg) {

    final JsonObject annotation = msg.body();
    LOG.debug("{}\n{}",address, annotation.encodePrettily());

    //get the parameter from the request
    final String from = annotation.getJsonObject("range").getString("from");
    final String to = annotation.getJsonObject("range").getString("to");
    final Range range = rangeParser.parse(from, to);
    final JsonObject an = annotation.getJsonObject("annotation");

    //build the query and find options
    final JsonObject annotationQuery = $and(obj(an.getString("query")),
                                            obj("n.begin", $gte(range.getStart())),
                                            obj("n.begin", $lte(range.getEnd())));
    final FindOptions findOptions = new FindOptions().setSort(obj("n.begin", 1)).setLimit(1);

    //query for annotations and map the result
    client.findWithOptions(collectionName, annotationQuery, findOptions, result -> {
        if (result.succeeded()) {
            msg.reply(result.result()
                            .stream()
                            .map(a -> obj().put("annotation", an)
                                           .put("time", a.getJsonObject("n").getLong("begin"))
                                           .put("title", a.getJsonObject("t").getString("name"))
                                           .put("tags", arr()))
                            .collect(toJsonArray()));
        } else {
            LOG.error("Annotation query failed", result.cause());
            msg.reply(arr());
        }
    });
}
 

import io.vertx.core.json.JsonObject; //导入方法依赖的package包/类
/**
 * 解析支付宝授权后的响应对象，获取对应简洁的JSON
 *
 * @param res 支付宝授权后的响应对象
 * @return 简洁的JSON，不包含签名及重复的一些字段
 *
 * @author Leibniz.Hu
 */
private JsonObject getClearJson(AlipayResponse res) {
    JsonObject bodyJson = new JsonObject(res.getBody());
    if (bodyJson.containsKey("alipay_user_info_share_response")) {
        return bodyJson.getJsonObject("alipay_user_info_share_response");
    } else if (bodyJson.containsKey("alipay_system_oauth_token_response")) {
        return bodyJson.getJsonObject("alipay_system_oauth_token_response");
    } else {
        return bodyJson;
    }
}
 

import io.vertx.core.json.JsonObject; //导入方法依赖的package包/类
private static Envelop build(final JsonObject json) {
    Envelop envelop = Envelop.ok();
    // 1. Headers
    if (null != json) {
        // 2.Rebuild
        if (json.containsKey("data")) {
            envelop = Envelop.success(json.getValue("data"));
        }
        // 3.Header
        if (null != json.getValue("header")) {
            final MultiMap headers = MultiMap.caseInsensitiveMultiMap();
            final JsonObject headerData = json.getJsonObject("header");
            for (final String key : headerData.fieldNames()) {
                final Object value = headerData.getValue(key);
                if (null != value) {
                    headers.set(key, value.toString());
                }
            }
            envelop.setHeaders(headers);
        }
        // 4.User
        if (null != json.getValue("user")) {
            envelop.setUser(new VirtualUser(json.getJsonObject("user")));
        }
    }
    return envelop;
}
 

import io.vertx.core.json.JsonObject; //导入方法依赖的package包/类
/**
 * @param wallClses
 * @param keysRef
 * @return
 */
private JsonObject verify(final Set<Class<?>> wallClses,
                          final ConcurrentMap<String, Class<?>> keysRef) {
    /** Wall duplicated **/
    final Set<String> hashs = new HashSet<>();
    Observable.fromIterable(wallClses)
            .filter(Objects::nonNull)
            .map(item -> {
                final Annotation annotation = item.getAnnotation(Wall.class);
                // Add configuration key into keys;
                keysRef.put(Instance.invoke(annotation, "value"), item);
                return this.hashPath(annotation);
            }).subscribe(hashs::add);
    
    // Duplicated adding.
    Fn.flingUp(hashs.size() != wallClses.size(), LOGGER,
            WallDuplicatedException.class, getClass(),
            wallClses.stream().map(Class::getName).collect(Collectors.toSet()));

    /** Shared key does not existing **/
    final JsonObject config = NODE.read();
    Fn.flingUp(!config.containsKey(KEY), LOGGER,
            DynamicKeyMissingException.class, getClass(),
            KEY, config);

    /** Wall key missing **/
    final JsonObject hitted = config.getJsonObject(KEY);
    for (final String key : keysRef.keySet()) {
        Fn.flingUp(null == hitted || !hitted.containsKey(key), LOGGER,
                WallKeyMissingException.class, getClass(),
                key, keysRef.get(key));
    }
    return hitted;
}
 

import io.vertx.core.json.JsonObject; //导入方法依赖的package包/类
private Record createRecord(final JsonObject item) {
    final String name = item.getString(NAME);
    final String host = item.getString(HOST);
    final Integer port = item.getInteger(PORT);
    final JsonObject meta = item.getJsonObject(META);
    return HttpEndpoint.createRecord(
            name, host, port, "/*", meta
    );
}
 

import io.vertx.core.json.JsonObject; //导入方法依赖的package包/类
private void init(final JsonObject raw) {
    // Options
    initOpts(raw);
    // Config
    this.endpoint = raw.getString("endpoint");
    if (raw.containsKey("config")) {
        this.config = raw.getJsonObject("config");
    } else {
        this.config = new JsonObject();
    }
}
 

import io.vertx.core.json.JsonObject; //导入方法依赖的package包/类
static <R> R init(final String key,
                  final Function<JsonObject, R> executor,
                  final Class<?> clazz) {
    final Node<JsonObject> node = Instance.instance(ZeroUniform.class);
    final JsonObject options = node.read();
    final Annal logger = Annal.get(clazz);
    Fn.flingUp(null == options || !options.containsKey(key)
            , logger, ConfigKeyMissingException.class,
            clazz, key);
    final JsonObject config = options.getJsonObject(key);
    Fn.flingUp(() -> Ruler.verify(key, config), logger);
    return executor.apply(config);
}
 

import io.vertx.core.json.JsonObject; //导入方法依赖的package包/类
@Override
public HttpServerOptions transform(final JsonObject input) {
    final JsonObject config = input.getJsonObject(ServerVisitor.YKEY_CONFIG, null);
    return Fn.getSemi(null == config, LOGGER,
            HttpServerOptions::new,
            () -> new HttpServerOptions(config));
}
 

import io.vertx.core.json.JsonObject; //导入方法依赖的package包/类
@Override
public VertxOptions transform(final JsonObject input) {
    final JsonObject config = input.getJsonObject(NodeVisitor.YKEY_OPTIONS, null);
    return Fn.getSemi(null == config, LOGGER,
            VertxOptions::new,
            () -> new VertxOptions(config));
}