Java JsonObject类代码示例

import io.vertx.core.json.JsonObject; //导入依赖的package包/类
public static void fromJson(JsonObject json, PgConnectOptions obj) {
  if (json.getValue("cachePreparedStatements") instanceof Boolean) {
    obj.setCachePreparedStatements((Boolean)json.getValue("cachePreparedStatements"));
  }
  if (json.getValue("database") instanceof String) {
    obj.setDatabase((String)json.getValue("database"));
  }
  if (json.getValue("host") instanceof String) {
    obj.setHost((String)json.getValue("host"));
  }
  if (json.getValue("password") instanceof String) {
    obj.setPassword((String)json.getValue("password"));
  }
  if (json.getValue("pipeliningLimit") instanceof Number) {
    obj.setPipeliningLimit(((Number)json.getValue("pipeliningLimit")).intValue());
  }
  if (json.getValue("port") instanceof Number) {
    obj.setPort(((Number)json.getValue("port")).intValue());
  }
  if (json.getValue("username") instanceof String) {
    obj.setUsername((String)json.getValue("username"));
  }
}
 

import io.vertx.core.json.JsonObject; //导入依赖的package包/类
private void getShoppingList(RoutingContext rc) {
    Single<HttpResponse<Buffer>> list = shopping.get("/shopping").rxSend();

    HttpServerResponse serverResponse = rc.response()
        .setChunked(true);

    list.subscribe(
        response -> {
            JsonObject body = response.bodyAsJsonObject();
            Observable.from(body)
                .flatMap(entry ->
                    retrievePrice(pricer, entry).toObservable())
                .subscribe(
                    product -> writeProductLine(serverResponse, product),
                    rc::fail,
                    serverResponse::end
                );
        },
        rc::fail);
}
 

import io.vertx.core.json.JsonObject; //导入依赖的package包/类
private void getShoppingListWithCB(RoutingContext rc) {
    Single<HttpResponse<Buffer>> list = shopping.get("/shopping").rxSend();

    HttpServerResponse serverResponse = rc.response()
        .setChunked(true);

    list.subscribe(
        response -> {
            JsonObject body = response.bodyAsJsonObject();
            Observable.from(body)
                .flatMap(entry ->
                    circuit.executeWithFallback(
                        future -> retrievePrice(pricer, entry, future),
                        t -> getFallbackPrice(entry)
                    )
                        .rxSetHandler().toObservable())
                .subscribe(
                    product -> writeProductLine(serverResponse, product),
                    rc::fail,
                    serverResponse::end
                );
        },
        rc::fail);
}
 

import io.vertx.core.json.JsonObject; //导入依赖的package包/类
private void indexHandler(RoutingContext context) {

    DeliveryOptions options = new DeliveryOptions().addHeader("action", "all-pages"); // <2>

    vertx.eventBus().send(wikiDbQueue, new JsonObject(), options, reply -> {  // <1>
      if (reply.succeeded()) {
        JsonObject body = (JsonObject) reply.result().body();   // <3>
        context.put("title", "Wiki home");
        context.put("pages", body.getJsonArray("pages").getList());
        templateEngine.render(context, "templates", "/index.ftl", ar -> {
          if (ar.succeeded()) {
            context.response().putHeader("Content-Type", "text/html");
            context.response().end(ar.result());
          } else {
            context.fail(ar.cause());
          }
        });
      } else {
        context.fail(reply.cause());
      }
    });
  }
 

import io.vertx.core.json.JsonObject; //导入依赖的package包/类
static ServiceDiscovery getServiceDiscovery(io.vertx.core.Vertx vertx) {
  // Discovery settings
  ServiceDiscoveryOptions serviceDiscoveryOptions = new ServiceDiscoveryOptions();
  
  // Redis settings with the standard Redis Backend
  Integer redisPort = Integer.parseInt(Optional.ofNullable(System.getenv("REDIS_PORT")).orElse("6379"));
  String redisHost = Optional.ofNullable(System.getenv("REDIS_HOST")).orElse("127.0.0.1");
  String redisAuth = Optional.ofNullable(System.getenv("REDIS_PASSWORD")).orElse(null);
  String redisRecordsKey = Optional.ofNullable(System.getenv("REDIS_RECORDS_KEY")).orElse("vert.x.ms");    // the redis hash
  
  return ServiceDiscovery.create(
    vertx,
    serviceDiscoveryOptions.setBackendConfiguration(
      new JsonObject()
        .put("host", redisHost)
        .put("port", redisPort)
        .put("auth", redisAuth)
        .put("key", redisRecordsKey)
    ));
}
 

import io.vertx.core.json.JsonObject; //导入依赖的package包/类
private void get(String uri, CacheItem<JsonObject> cache, Future<JsonObject> future, Retryable retryable) {
    client.get(HTTPS, ENDPOINT, uri).timeout(5000L).as(BodyCodec.jsonObject()).send(ar -> {
        if (ar.succeeded()) {
            HttpResponse<JsonObject> res = ar.result();
            if (res.statusCode() == OK) {
                future.complete(cache.set(res.body()));
            } else if (res.statusCode() == RATE_LIMIT) {
                retryable.retry(
                        () -> vertx.setTimer(getTimeTillReset(res), timer -> get(uri, cache, future, retryable)),
                        () -> future.fail("Too many retries."));
            } else {
                future.fail("TMDB API returned code: " + res.statusCode() +
                        "; message: " + res.statusMessage());
            }
        } else {
            retryable.retry(
                    () -> vertx.setTimer(DEFAULT_DELAY, timer -> get(uri, cache, future, retryable)),
                    () -> future.fail("Too many failures."));
        }
    });
}
 

import io.vertx.core.json.JsonObject; //导入依赖的package包/类
/**
 * a插入一条订单记录
 */
public void insert(JsonObject order, Handler<Integer> callback) {
    Integer eid = order.getInteger(EID);
    if (eid == null)
        throw new IllegalArgumentException("Eid in Order object cannot be null!!!");
    String orderId = order.getString(ORDERID);
    if (orderId == null || orderId.length() == 0)
        throw new IllegalArgumentException("OrderId in Order object cannot be null!!!");
    String orderCallback = order.getString(CALLBACK);
    if (orderCallback == null || orderCallback.length() == 0)
        throw new IllegalArgumentException("Callback in Order object cannot be null!!!");
    Integer type = order.getInteger(TYPE);
    if (type == null)
        throw new IllegalArgumentException("Type in Order object cannot be null!!!");
    String sql = "INSERT INTO awp_order (eid,orderId,callback,type,createTime) VALUES (?,?,?,?,NOW())";
    JsonArray params = new JsonArray().add(eid).add(orderId).add(orderCallback).add(type);
    update(sql, params, callback);
}
 

import io.vertx.core.json.JsonObject; //导入依赖的package包/类
private ConcurrentMap<String, VertxOptions> visit(
        final JsonArray vertxData)
        throws ZeroException {
    final ConcurrentMap<String, VertxOptions> map =
            new ConcurrentHashMap<>();
    final boolean clustered = this.clusterOptions.isEnabled();
    Fn.etJArray(vertxData, JsonObject.class, (item, index) -> {
        // 1. Extract single
        final String name = item.getString(YKEY_NAME);
        // 2. Extract VertxOptions
        final VertxOptions options = this.transformer.transform(item);
        // 3. Check the configuration for cluster sync
        Fn.flingZero(clustered != options.isClustered(), LOGGER,
                ClusterConflictException.class,
                getClass(), name, options.toString());
        // 4. Put the options into map
        map.put(name, options);
    });
    return map;
}
 

import io.vertx.core.json.JsonObject; //导入依赖的package包/类
@Test
public void cannotProvideAdditionalPropertiesInLoan()
  throws InterruptedException,
  MalformedURLException,
  TimeoutException,
  ExecutionException {

  UUID id = UUID.randomUUID();

  JsonObject requestWithAdditionalProperty = new LoanRequestBuilder()
    .withId(id)
    .create();

  requestWithAdditionalProperty.put("somethingAdditional", "foo");

  CompletableFuture<JsonErrorResponse> createCompleted = new CompletableFuture();

  client.post(loanStorageUrl(), requestWithAdditionalProperty,
    StorageTestSuite.TENANT_ID, ResponseHandler.jsonErrors(createCompleted));

  JsonErrorResponse response = createCompleted.get(5, TimeUnit.SECONDS);

  assertThat(response.getStatusCode(), is(UNPROCESSABLE_ENTITY));
  assertThat(response.getErrors(), hasSoleMessgeContaining("Unrecognized field"));
}
 

import io.vertx.core.json.JsonObject; //导入依赖的package包/类
private void apiGetPage(RoutingContext context) {
  int id = Integer.valueOf(context.request().getParam("id"));
  dbService.rxFetchPageById(id)
    .subscribe(dbObject -> {
      if (dbObject.getBoolean("found")) {
        JsonObject payload = new JsonObject()
          .put("name", dbObject.getString("name"))
          .put("id", dbObject.getInteger("id"))
          .put("markdown", dbObject.getString("content"))
          .put("html", Processor.process(dbObject.getString("content")));
        apiResponse(context, 200, "page", payload);
      } else {
        apiFailure(context, 404, "There is no page with ID " + id);
      }
    }, t -> apiFailure(context, t));
}
 

import io.vertx.core.json.JsonObject; //导入依赖的package包/类
@Override
public JsonObject toJSON() {
    JsonObject json = new JsonObject();

    //add header information
    json.put("event", this.event);
    json.put("messageID", this.uuid.toString());

    //add message body
    json.put("data", this.data);

    if (!this.ssid.isEmpty()) {
        json.put("ssid", this.ssid);
    }

    return json;
}
 

import io.vertx.core.json.JsonObject; //导入依赖的package包/类
public static Completable dumbTradingLogic(String company, int numberOfShares, io.vertx.workshop.portfolio.reactivex.PortfolioService portfolio, JsonObject quote) {
    if (quote.getString("name").equals(company)) {
        if (TraderUtils.timeToSell()) {
            System.out.println("Trying to sell " + numberOfShares + " " + company);
            return portfolio.rxSell(numberOfShares, quote)
                .doOnSuccess(p -> System.out.println("Sold " + numberOfShares + " of " + company + "!"))
                .doOnError(e -> System.out.println("D'oh, failed to sell " + numberOfShares + " of "
                    + company + ": " + e.getMessage()))
                .toCompletable();
        } else {
            System.out.println("Trying to buy " + numberOfShares + " " + company);
            return portfolio.rxBuy(numberOfShares, quote)
                .doOnSuccess(p -> System.out.println("Bought " + numberOfShares + " of " + company + " !"))
                .doOnError(e -> System.out.println("D'oh, failed to buy " + numberOfShares + " of " + company + " : " + e
                    .getMessage()))
                .toCompletable();
        }
    }

    return Completable.complete();
}
 

import io.vertx.core.json.JsonObject; //导入依赖的package包/类
@Test
public void testInsert() throws SQLException {
  AtomicInteger counter = new AtomicInteger(0);
  client.handler((event) -> {
    if (!"write".equals(event.getString("type"))) {
      return;
    }
    assertEquals(config().getString("schema"), event.getString("schema"));
    assertEquals("binlog_client_test", event.getString("table"));
    JsonObject json = event.getJsonObject("row");
    Integer id = json.getInteger("id");
    String name = json.getString("name");
    Map.Entry<Integer, String> expectedRow = rows().get(counter.getAndIncrement());
    assertEquals(expectedRow.getKey(), id);
    assertEquals(expectedRow.getValue(), name);
    if (id.equals(lastId())) {
      testComplete();
    }
  });
  insert();
  await();
}
 

import io.vertx.core.json.JsonObject; //导入依赖的package包/类
@RequiresPermissions("update")
@PUT
@Path("pages/{id}")
public Single<Response> apiUpdatePage(@PathParam("id") String id, 
		@ApiUpdateValid("markdown") JsonObject page,
		@Context HttpServerRequest req,
		@Context Vertx vertx){
	PagesDao dao = (PagesDao) AppGlobals.get().getGlobal("dao");
	return dao.updateExecAsync(new Pages().setId(Integer.valueOf(id)).setContent(page.getString("markdown")))
			.map(res -> {
			    JsonObject event = new JsonObject()
			    	      .put("id", id)
			    	      .put("client", page.getString("client"));
			    vertx.eventBus().publish("page.saved", event);
				return Response.ok(new JsonObject().put("success", true)).build();
			});
}
 

import io.vertx.core.json.JsonObject; //导入依赖的package包/类
/**
 * Gets value as JsonObject.
 * JsonObjects are converted to JsonObjs.
 * Parses JsonObject and Map types.
 */
@SuppressWarnings("unchecked")
@Override
public JsonObject getJsonObject(String key) {
  Object value = get(key);
  if (value == null) {
    return null;
  }
  if (value instanceof JsonObject) {
    if (value instanceof JsonObj) {
      return ((JsonObj) value);
    }
    return new JsonObj(((JsonObject) value).getMap());
  }
  if (value instanceof Map) {
    return new JsonObj(((Map<String, Object>) value));
  }
  return null;
}