Java JsonArray类代码示例

import io.vertx.core.json.JsonArray; //导入依赖的package包/类
private TableColumn processChoiceBoxColumnName(String name, JsonArray items){
    TableColumn column = new TableColumn(name);
    column.setCellValueFactory( p -> ((TableColumn.CellDataFeatures<Item, Object>)p).getValue().getStringProperty(name));
    ObservableList list = FXCollections.observableArrayList();
    if(items!=null) list.addAll(items.getList());
    column.setCellFactory(ChoiceBoxTableCell.forTableColumn(list));
    column.setOnEditCommit( t -> {
        int index = ((TableColumn.CellEditEvent<Item, Object>) t).getTablePosition().getRow();
        Item item = ((TableColumn.CellEditEvent<Item, Object>) t).getTableView().getItems().get(index);
        item.setProperty(name,((TableColumn.CellEditEvent<Item, Object>) t).getNewValue());
    });
    columnMap.put(name, column);
    return column;
}
 

import io.vertx.core.json.JsonArray; //导入依赖的package包/类
private static JsonArray reformatJsonArray(JsonArray result, CaseConversion conversion, boolean capitalAtStart) {
    if (result == null || result.isEmpty()) {
        return new JsonArray();
    }
    List<Object> reformatedList = new LinkedList<>();
    for (Object obj : result.getList()) {
        if (obj instanceof JsonObject || obj instanceof Map) {
            @SuppressWarnings("unchecked")
            JsonObject jsonObject = (obj instanceof JsonObject) ? (JsonObject) obj
                    : new JsonObject((Map<String, Object>) obj);
            reformatedList.add(reformatJsonObject(jsonObject, conversion, capitalAtStart));
        } else {
            reformatedList.add(obj);
        }
    }
    return new JsonArray(reformatedList);

}
 

import io.vertx.core.json.JsonArray; //导入依赖的package包/类
private ConcurrentMap<Integer, ServidorOptions> visit(final JsonArray serverData)
        throws ZeroException {
    LOGGER.info(Info.INF_B_VERIFY, KEY, ServerType.IPC, serverData.encode());
    Ruler.verify(KEY, serverData);
    final ConcurrentMap<Integer, ServidorOptions> map =
            new ConcurrentHashMap<>();
    Fn.itJArray(serverData, JsonObject.class, (item, index) -> {
        if (isServer(item)) {
            // 1. Extract port
            final int port = extractPort(item.getJsonObject(YKEY_CONFIG));
            // 2. Convert JsonObject to HttpServerOptions
            final ServidorOptions options = this.transformer.transform(item);
            Fn.safeNull(() -> {
                // 3. Add to map;
                map.put(port, options);
            }, port, options);
        }
    });
    LOGGER.info(Info.INF_A_VERIFY, KEY, ServerType.IPC, map.keySet());
    return map;
}
 

import io.vertx.core.json.JsonArray; //导入依赖的package包/类
@Override
public void handle(RoutingContext rc) {
  Long genreId = PathUtil.parseLongParam(rc.pathParam("genreId"));
  if (genreId == null) {
    rc.next();
    return;
  }

  dbClient.rxGetConnection().flatMap(sqlConnection -> {
    Single<JsonObject> gs = findGenre(sqlConnection, genreId);
    Single<JsonArray> als = findAlbums(sqlConnection, genreId);
    Single<JsonArray> ars = findArtists(sqlConnection, genreId);

    return Single.zip(gs, als, ars, (genre, albums, artists) -> {
      Map<String, Object> data = new HashMap<>();
      data.put("genre", genre);
      data.put("albums", albums);
      data.put("artists", artists);
      return data;
    }).doAfterTerminate(sqlConnection::close);
  }).flatMap(data -> {
    data.forEach(rc::put);
    return templateEngine.rxRender(rc, "templates/genre");
  }).subscribe(rc.response()::end, rc::fail);
}
 

import io.vertx.core.json.JsonArray; //导入依赖的package包/类
private JsonArray getSubscriptionBody() {
	final JsonArray result = new JsonArray();
	final JsonObject subscribe = new JsonObject();
	final JsonObject ext = new JsonObject();
	final JsonObject replay = new JsonObject();
	// TODO: Handling of Replay options need to be fixed here!
	replay.put(this.getListenerConfig().getListenSubject(), -2);
	ext.put("replay", replay);
	subscribe.put("ext", ext);
	subscribe.put("clientId", this.clientId);
	subscribe.put("channel", "/meta/subscribe");
	subscribe.put("subscription", this.getListenerConfig().getListenSubject());
	subscribe.put("id", "3");
	result.add(subscribe);
	return result;
}
 

import io.vertx.core.json.JsonArray; //导入依赖的package包/类
@Override
public WikiDatabaseService fetchPage(String name, Handler<AsyncResult<JsonObject>> resultHandler) {
  dbClient.queryWithParams(sqlQueries.get(SqlQuery.GET_PAGE), new JsonArray().add(name), fetch -> {
    if (fetch.succeeded()) {
      JsonObject response = new JsonObject();
      ResultSet resultSet = fetch.result();
      if (resultSet.getNumRows() == 0) {
        response.put("found", false);
      } else {
        response.put("found", true);
        JsonArray row = resultSet.getResults().get(0);
        response.put("id", row.getInteger(0));
        response.put("rawContent", row.getString(1));
      }
      resultHandler.handle(Future.succeededFuture(response));
    } else {
      LOGGER.error("Database query error", fetch.cause());
      resultHandler.handle(Future.failedFuture(fetch.cause()));
    }
  });
  return this;
}
 

import io.vertx.core.json.JsonArray; //导入依赖的package包/类
@Override
public void handle(RoutingContext rc) {
  Long artistId = PathUtil.parseLongParam(rc.pathParam("artistId"));
  if (artistId == null) {
    rc.next();
    return;
  }

  dbClient.rxGetConnection().flatMap(sqlConnection -> {
    Single<JsonObject> ars = findArtist(sqlConnection, artistId);
    Single<JsonArray> als = findAlbums(sqlConnection, artistId);

    return Single.zip(ars, als, (artist, albums) -> {
      Map<String, Object> data = new HashMap<>(2);
      data.put("artist", artist);
      data.put("albums", albums);
      return data;
    }).doAfterTerminate(sqlConnection::close);

  }).flatMap(data -> {
    data.forEach(rc::put);
    return templateEngine.rxRender(rc, "templates/artist");
  }).subscribe(rc.response()::end, rc::fail);
}
 

import io.vertx.core.json.JsonArray; //导入依赖的package包/类
/**
 * Handler for the /api endpoint, listing out routes and loaded verticles
 * 
 * @param ctx
 */
private void rootHandler(final RoutingContext ctx) {
	ctx.response().putHeader(Constants.CONTENT_HEADER, Constants.CONTENT_TYPE_JSON);
	final JsonObject result = new JsonObject().put("RunningSince", Utils.getDateString(this.startDate));
	final JsonObject routeObject = new JsonObject();
	for (final Route r : this.router.getRoutes()) {
		final String p = r.getPath();
		if (p != null) {
			routeObject.put(p, String.valueOf(r));
		}
	}
	result.put("Routes", routeObject);
	final JsonArray verticleArray = new JsonArray(this.loadedVerticles);
	result.put("Verticles", verticleArray);
	ctx.response().end(result.encodePrettily());
}
 

import io.vertx.core.json.JsonArray; //导入依赖的package包/类
@Override
public BookDatabaseService getBookById(int id, Handler<AsyncResult<JsonObject>> resultHandler) {
  pgConnectionPool.rxPreparedQuery(SQL_FIND_BOOK_BY_ID, Tuple.of(id))
    .map(PgResult::getDelegate)
    .subscribe(pgResult -> {
      JsonArray jsonArray = transformPgResultToJson(pgResult);
      if (jsonArray.size() == 0) {
        resultHandler.handle(Future.succeededFuture(new JsonObject()));
      } else {
        JsonObject dbResponse = jsonArray.getJsonObject(0);
        resultHandler.handle(Future.succeededFuture(dbResponse));
      }
    }, throwable -> {
      LOGGER.error("Failed to get the book by id " + id, throwable);
      resultHandler.handle(Future.failedFuture(throwable));
    });
  return this;
}
 

import io.vertx.core.json.JsonArray; //导入依赖的package包/类
private Handler<AsyncResult<Set<Character>>> createSetCharHandler(Message msg) {
  return res -> {
    if (res.failed()) {
      if (res.cause() instanceof ServiceException) {
        msg.reply(res.cause());
      } else {
        msg.reply(new ServiceException(-1, res.cause().getMessage()));
      }
    } else {
      JsonArray arr = new JsonArray();
      for (Character chr: res.result()) {
        arr.add((int) chr);
      }
      msg.reply(arr);
    }
  };
}
 

import io.vertx.core.json.JsonArray; //导入依赖的package包/类
protected void parseMenu (Stage stage, MenuBar menuBar, JsonArray jsonArray) {
    Platform.runLater(() -> {
        for (int i = 0; i < jsonArray.size(); i++) {
            //get menu entry
            JsonObject entry = jsonArray.getJsonObject(i);

            //get event and title
            //String event = entry.getString("event");
            String title = entry.getString("title");

            //create new menu
            Menu menu = new Menu(title);

            //add sub menus
            this.parseSubMenus(menu, entry.getJsonArray("submenus"));

            //add menu to menu bar
            menuBar.getMenus().add(menu);
        }

        menuBar.prefWidthProperty().bind(stage.widthProperty());
    });
}
 

import io.vertx.core.json.JsonArray; //导入依赖的package包/类
@Override
public Single<Void> deployToResteasy(VertxResteasyDeployment deployment) {
	JsonArray packages = AppGlobals.get().getConfig().getJsonArray("scan");
	if(packages == null) {
		System.err.println("Not scanning any packages, please specify the 'scan' array of packages in configuration");
	}else {
		String[] packagesToScan = (String[]) packages.getList().toArray(new String[packages.size()+1]);
		packagesToScan[packagesToScan.length-1] = "net.redpipe.engine";
		new FastClasspathScanner(packagesToScan)
			.matchClassesWithAnnotation(Path.class, klass -> {
				if(!Modifier.isAbstract(klass.getModifiers()))
					deployment.getActualResourceClasses().add(klass);
			})
			.matchClassesWithAnnotation(Provider.class, klass -> {
				if(!Modifier.isAbstract(klass.getModifiers()))
					deployment.getActualProviderClasses().add(klass);
			})
			.scan();
	}
	return Single.just(null);
}
 

import io.vertx.core.json.JsonArray; //导入依赖的package包/类
private void step4ActionSubscribe() {
	if (this.shuttingDown || this.shutdownCompleted) {
		this.shutdownCompleted = true;
		return;
	}

	final JsonArray body = this.getSubscriptionBody();
	final HttpRequest<Buffer> request = this.initWebPostRequest(Constants.URL_SUBSCRIBE);

	request.sendJson(body, postReturn -> {
		if (postReturn.succeeded()) {
			this.step4ResultSubscribe(postReturn.result());
		} else {
			this.logger.error(postReturn.cause());
		}
	});
}
 

import io.vertx.core.json.JsonArray; //导入依赖的package包/类
/**
 * 查询所有账号
 * 返回JSON包括id,name,email字段
 * 需要管理员权限
 */
private void getAccountList(RoutingContext rc) {
    if (forbidAccess(rc, "id", false)) {
        return;
    }
    log.debug("即将发送EventBus消息查询所有账号");
    vertx.eventBus().<JsonArray>send(ADDR_ACCOUNT_DB.get(), makeMessage(COMMAND_GET_ALL_ACCOUNT), ar -> {
        HttpServerResponse response = rc.response();
        if(ar.succeeded()){
            JsonArray rows = ar.result().body();
            response.putHeader("content-type", "application/json; charset=utf-8").end(rows.toString());
        } else {
            log.error("EventBus消息响应错误", ar.cause());
            response.setStatusCode(500).end("EventBus error!");
        }
    });
}
 

import io.vertx.core.json.JsonArray; //导入依赖的package包/类
@Test
public void testAddingView() throws Exception {
    goAndWaitForPageToLoad();
    searchForMovie();
    openDetailView();
    WebElement addToViewsButton = driver.findElementByCssSelector("#add-watch > div.card-content");
    sleep(driver, 5, visibilityOf(addToViewsButton));
    addToViewsButton.click();
    WebElement watchStartNowButton = driver.findElementById("watchStartNow");
    sleep(driver, 5, visibilityOf(watchStartNowButton));
    watchStartNowButton.click();
    driver.findElement(id("watchEndCalculate")).click();
    driver.findElement(id("add-btn")).click();
    await().atMost(5, SECONDS).until(() -> localDatabase
            .queryBlocking("SELECT * FROM Views WHERE MovieId = ?", new JsonArray().add(315837))
            .size() > 0);
}