Java BodyParser.Json方法代码示例

import play.mvc.BodyParser; //导入方法依赖的package包/类
@BodyParser.Of(BodyParser.Json.class)
public static Result addJobLineage() {
  JsonNode lineage = request().body().asJson();
  ObjectNode resultJson = Json.newObject();
  try {
    LineageDao.insertLineage(lineage);
    resultJson.put("return_code", 200);
    resultJson.put("message", "Lineage inserted!");
  } catch (Exception e) {
    e.printStackTrace();
    resultJson.put("return_code", 404);
    resultJson.put("error_message", e.getMessage());
  }

  return ok(resultJson);
}
 

import play.mvc.BodyParser; //导入方法依赖的package包/类
@BodyParser.Of(BodyParser.Json.class)
public static Result getDatasetDependency() {
  String queryString = request().getQueryString("query");
  JsonNode input = Json.parse(queryString);
  ObjectNode resultJson = Json.newObject();

  try {
    resultJson = DatasetDao.getDatasetDependency(input);
  } catch (Exception e) {
    Logger.error(e.getMessage());
    resultJson.put("return_code", 404);
    resultJson.put("error_message", e.getMessage());
  }

  return ok(resultJson);
}
 

import play.mvc.BodyParser; //导入方法依赖的package包/类
@Transactional
  @BodyParser.Of(BodyParser.Json.class)
  public Result save() {
  	
  	Cidadao cidadao = daoCidadao
		.find(UUID.fromString(request().username()));
if (!cidadao.isFuncionario()) {
	return unauthorized("Cidadão não autorizado");
}
  	
      Form<Mensagem> form = formFactory.form(Mensagem.class).bindFromRequest();
      if (form.hasErrors()) {
          String recebido = Controller.request().body().asJson().toString();
          if (recebido.length() > 30) {
              recebido = recebido.substring(0, 30) + "...";
          }
          Logger.debug("Submissão com erros: " + recebido + "; Erros: " + form.errorsAsJson());
          return badRequest(form.errorsAsJson());
      }
      
      Mensagem mensagem = daoMensagem.create(form.get());
      mensagem.setAutor(cidadao.getMinisterioDeAfiliacao());
      
      return created(toJson(mensagem));
  }
 

import play.mvc.BodyParser; //导入方法依赖的package包/类
@BodyParser.Of(BodyParser.Json.class)
public final CompletionStage<Result> addStructure() {
  return CompletableFuture.supplyAsync(
    () -> {
      JsonNode json = request().body().asJson();
      Structure structure = Json.fromJson(json, Structure.class);

      try {
        structure = this.postgresStructureDao.create(structure);
      } catch (GroundException e) {
        throw new CompletionException(e);
      }
      return Json.toJson(structure);
    },

    PostgresUtils.getDbSourceHttpContext(this.actorSystem))
           .thenApply(Results::created)
           .exceptionally(e -> GroundUtils.handleException(e, request()));
}
 

import play.mvc.BodyParser; //导入方法依赖的package包/类
@BodyParser.Of(BodyParser.Json.class)
public final CompletionStage<Result> addStructureVersion() {
  return CompletableFuture.supplyAsync(
    () -> {
      JsonNode json = request().body().asJson();

      List<Long> parentIds = GroundUtils.getListFromJson(json, "parentIds");
      ((ObjectNode) json).remove("parentIds");

      StructureVersion structureVersion = Json.fromJson(json, StructureVersion.class);

      try {
        structureVersion = this.postgresStructureVersionDao.create(structureVersion, parentIds);
      } catch (GroundException e) {
        throw new CompletionException(e);
      }
      return Json.toJson(structureVersion);
    },
    PostgresUtils.getDbSourceHttpContext(this.actorSystem))
           .thenApply(Results::created)
           .exceptionally(e -> GroundUtils.handleException(e, request()));
}
 

import play.mvc.BodyParser; //导入方法依赖的package包/类
@BodyParser.Of(BodyParser.Json.class)
public final CompletionStage<Result> createLineageEdge() {
  return CompletableFuture.supplyAsync(
    () -> {
      JsonNode json = request().body().asJson();
      LineageEdge lineageEdge = Json.fromJson(json, LineageEdge.class);
      try {
        lineageEdge = this.postgresLineageEdgeDao.create(lineageEdge);
      } catch (GroundException e) {
        throw new CompletionException(e);
      }
      return Json.toJson(lineageEdge);
    },
    PostgresUtils.getDbSourceHttpContext(this.actorSystem))
           .thenApply(Results::created)
           .exceptionally(e -> GroundUtils.handleException(e, request()));
}
 

import play.mvc.BodyParser; //导入方法依赖的package包/类
@BodyParser.Of(BodyParser.Json.class)
public final CompletionStage<Result> createLineageGraph() {
  return CompletableFuture.supplyAsync(
    () -> {
      JsonNode json = request().body().asJson();
      LineageGraph lineageGraph = Json.fromJson(json, LineageGraph.class);
      try {
        lineageGraph = this.postgresLineageGraphDao.create(lineageGraph);
      } catch (GroundException e) {
        throw new CompletionException(e);
      }
      return Json.toJson(lineageGraph);
    },
    PostgresUtils.getDbSourceHttpContext(this.actorSystem))
           .thenApply(Results::created)
           .exceptionally(e -> GroundUtils.handleException(e, request()));
}
 

import play.mvc.BodyParser; //导入方法依赖的package包/类
@BodyParser.Of(BodyParser.Json.class)
public final CompletionStage<Result> addGraph() {
  return CompletableFuture.supplyAsync(
    () -> {
      JsonNode json = request().body().asJson();
      Graph graph = Json.fromJson(json, Graph.class);

      try {
        graph = this.postgresGraphDao.create(graph);
      } catch (GroundException e) {
        throw new CompletionException(e);
      }

      return Json.toJson(graph);
    },
    PostgresUtils.getDbSourceHttpContext(actorSystem))
           .thenApply(Results::created)
           .exceptionally(e -> GroundUtils.handleException(e, request()));
}
 

import play.mvc.BodyParser; //导入方法依赖的package包/类
@BodyParser.Of(BodyParser.Json.class)
public final CompletionStage<Result> addGraphVersion() {
  return CompletableFuture.supplyAsync(
    () -> {
      JsonNode json = request().body().asJson();
      List<Long> parentIds = GroundUtils.getListFromJson(json, "parentIds");
      ((ObjectNode) json).remove("parentIds");
      GraphVersion graphVersion = Json.fromJson(json, GraphVersion.class);

      try {
        graphVersion = this.postgresGraphVersionDao.create(graphVersion, parentIds);
      } catch (GroundException e) {
        throw new CompletionException(e);
      }
      return Json.toJson(graphVersion);
    },
    PostgresUtils.getDbSourceHttpContext(actorSystem))
           .thenApply(Results::ok)
           .exceptionally(e -> GroundUtils.handleException(e, request()));
}
 

import play.mvc.BodyParser; //导入方法依赖的package包/类
@BodyParser.Of(BodyParser.Json.class)
public final CompletionStage<Result> addEdge() {
  return CompletableFuture.supplyAsync(
    () -> {
      JsonNode json = request().body().asJson();
      Edge edge = Json.fromJson(json, Edge.class);

      try {
        edge = this.postgresEdgeDao.create(edge);
      } catch (GroundException e) {
        throw new CompletionException(e);
      }

      return Json.toJson(edge);
    },
    PostgresUtils.getDbSourceHttpContext(this.actorSystem))
           .thenApply(Results::created)
           .exceptionally(e -> GroundUtils.handleException(e, request()));
}
 

import play.mvc.BodyParser; //导入方法依赖的package包/类
@BodyParser.Of(BodyParser.Json.class)
public final CompletionStage<Result> addEdgeVersion() {
  return CompletableFuture.supplyAsync(
    () -> {
      JsonNode json = request().body().asJson();
      List<Long> parentIds = GroundUtils.getListFromJson(json, "parentIds");

      ((ObjectNode) json).remove("parentIds");
      EdgeVersion edgeVersion = Json.fromJson(json, EdgeVersion.class);

      try {
        edgeVersion = this.postgresEdgeVersionDao.create(edgeVersion, parentIds);
      } catch (GroundException e) {
        throw new CompletionException(e);
      }

      return Json.toJson(edgeVersion);
    },
    PostgresUtils.getDbSourceHttpContext(actorSystem))
           .thenApply(Results::created)
           .exceptionally(e -> GroundUtils.handleException(e, request()));
}
 

import play.mvc.BodyParser; //导入方法依赖的package包/类
@BodyParser.Of(BodyParser.Json.class)
public final CompletionStage<Result> addNode() {
  return CompletableFuture.supplyAsync(
    () -> {
      JsonNode json = request().body().asJson();
      Node node = Json.fromJson(json, Node.class);
      try {
        node = this.postgresNodeDao.create(node);
      } catch (GroundException e) {
        throw new CompletionException(e);
      }
      return Json.toJson(node);
    },
    PostgresUtils.getDbSourceHttpContext(this.actorSystem))
           .thenApply(Results::created)
           .exceptionally(e -> GroundUtils.handleException(e, request()));
}
 

import play.mvc.BodyParser; //导入方法依赖的package包/类
@BodyParser.Of(BodyParser.Json.class)
public final CompletionStage<Result> addNodeVersion() {
  return CompletableFuture.supplyAsync(
    () -> {
      JsonNode json = request().body().asJson();

      List<Long> parentIds = GroundUtils.getListFromJson(json, "parentIds");
      ((ObjectNode) json).remove("parentIds");
      NodeVersion nodeVersion = Json.fromJson(json, NodeVersion.class);

      try {
        nodeVersion = this.postgresNodeVersionDao.create(nodeVersion, parentIds);
      } catch (GroundException e) {
        e.printStackTrace();
        throw new CompletionException(e);
      }
      return Json.toJson(nodeVersion);
    },
    PostgresUtils.getDbSourceHttpContext(this.actorSystem))
           .thenApply(Results::created)
           .exceptionally(e -> GroundUtils.handleException(e, request()));
}
 

import play.mvc.BodyParser; //导入方法依赖的package包/类
/**
 * Update the dashboard page configuration.<br/>
 * This method expects a POST with a JSON structure.
 * 
 * @param dashboardPageId
 *            the unique id of a dashboard page
 * @return
 */
@BodyParser.Of(BodyParser.Json.class)
public Promise<Result> updateDashboardPage(Long dashboardPageId) {
    return Promise.promise(new Function0<Result>() {
        @Override
        public Result apply() throws Throwable {
            try {
                JsonNode json = request().body().asJson();
                List<DashboardRowConfiguration> dashboardPageConfiguration = getObjectMapper().readValue(json.toString(),
                        new TypeReference<List<DashboardRowConfiguration>>() {
                });
                getDashboardService().updateDashboardPageConfiguration(dashboardPageId, null, dashboardPageConfiguration);
                return ok();
            } catch (Exception e) {
                log.error("Unable to update the dashboard page", e);
                return badRequest();
            }
        }
    });
}
 

import play.mvc.BodyParser; //导入方法依赖的package包/类
/**
 * Create a new widget from the specified widget identifier and return the
 * widget id as a JSON structure.
 * 
 * <pre>
 * {@code
 *  {widgetId : 1}
 * }
 * </pre>
 * 
 * A POST parameter (as JSON is expected) : a widget entry.
 * 
 * @param dashboardPageId
 *            the unique Id for the dashboard page which is to be associated
 *            with this widget
 * @return JSON structure
 */
@BodyParser.Of(BodyParser.Json.class)
public Promise<Result> createNewWidget(Long dashboardPageId) {
    return Promise.promise(new Function0<Result>() {
        @Override
        public Result apply() throws Throwable {
            try {
                JsonNode json = request().body().asJson();
                WidgetCatalogEntry widgetCatalogEntry = getObjectMapper().readValue(json.toString(), WidgetCatalogEntry.class);
                Pair<Long, String> widgetConfig = getDashboardService().createNewWidget(dashboardPageId, null, widgetCatalogEntry, "A title");
                JsonNode node = getObjectMapper().readTree("{\"id\" : " + widgetConfig.getLeft() + ",\"url\" : \"" + widgetConfig.getRight()
                        + "\",\"identifier\" : \"" + widgetCatalogEntry.getIdentifier() + "\"}");
                return ok(node);
            } catch (Exception e) {
                log.error("Unable to create a new widget", e);
                return badRequest();
            }
        }
    });
}