javax.websocket.EncodeException#javax.json.JsonObjectBuilder源码实例Demo

private JsonObject doMerge(final JsonBuilderFactory jsonFactory, final JsonObject template, final JsonObject currentRoute) {
    if (currentRoute == null) {
        return template;
    }
    if (template == null) {
        return currentRoute;
    }
    return Stream.concat(template.keySet().stream(), currentRoute.keySet().stream())
        .distinct()
        .collect(Collector.of(jsonFactory::createObjectBuilder, (builder, key) -> {
            final JsonValue templateValue = template.get(key);
            final JsonValue value = ofNullable(currentRoute.get(key)).orElse(templateValue);
            switch (value.getValueType()) {
                case NULL:
                    break;
                case OBJECT:
                    builder.add(key, templateValue != null ?
                            doMerge(jsonFactory, templateValue.asJsonObject(), value.asJsonObject()) :
                            value);
                    break;
                default: // primitives + array, get or replace logic since it is "values"
                    builder.add(key, value);
                    break;
            }
        }, JsonObjectBuilder::addAll, JsonObjectBuilder::build));
}
 

private JsonObject toJsonObject() {
    JsonObjectBuilder factory = Json.createObjectBuilder();
    if (enrollmentID != null) {
        // revoke all enrollments of this user, serial and aki are ignored in this case
        factory.add("id", enrollmentID);
    } else {
        // revoke one particular enrollment
        factory.add("serial", serial);
        factory.add("aki", aki);
    }

    if (null != reason) {
        factory.add("reason", reason);
    }

    if (caName != null) {
        factory.add(HFCAClient.FABRIC_CA_REQPROP, caName);
    }

    if (genCRL != null) {
        factory.add("gencrl", genCRL);
    }
    return factory.build();
}
 

/**
 * Create an event targeted at a specific player (still use broadcast to send to
 * all connections)
 *
 * @return constructed message
 */
public static Message createSpecificEvent(String userid, String messageForUser) {
    //  player,<userId>,{
    //      "type": "event",
    //      "content": {
    //          "<userId>": "specific to player"
    //          },
    //      "bookmark": "String representing last message seen"
    //  }
    JsonObjectBuilder payload = Json.createObjectBuilder();
    payload.add(TYPE, EVENT);

    JsonObjectBuilder content = Json.createObjectBuilder();
    content.add(userid, messageForUser);
    payload.add(CONTENT, content.build());

    payload.add(BOOKMARK, PREFIX + bookmark.incrementAndGet());
    return new Message(Target.player, userid, payload.build().toString());
}
 

@GET
@Path("products-stats")
@ApiOperation(value = "Get products stats",
        response = String.class)
@ApiResponses(value = {
        @ApiResponse(code = 200, message = "Successful retrieval of products statistics"),
        @ApiResponse(code = 401, message = "Unauthorized"),
        @ApiResponse(code = 403, message = "Forbidden"),
        @ApiResponse(code = 500, message = "Internal server error")
})
@Produces(MediaType.APPLICATION_JSON)
public JsonObject getProductsStats()
        throws EntityNotFoundException, UserNotActiveException, WorkspaceNotEnabledException {

    JsonObjectBuilder productsStats = Json.createObjectBuilder();

    Workspace[] allWorkspaces = userManager.getAdministratedWorkspaces();

    for (Workspace workspace : allWorkspaces) {
        int productsCount = productService.getConfigurationItems(workspace.getId()).size();
        productsStats.add(workspace.getId(), productsCount);
    }

    return productsStats.build();

}
 

@DELETE
@Path("{id}")
public Response deleteConfig(@PathParam("id") String configId) {

    WebTarget target = resource().path(CONFIGS).path(configId);
    Response response = deleteResponse(target);

    String entity = response.readEntity(String.class);

    if (entity.isEmpty()) {
        JsonObjectBuilder jsonObject = Json.createObjectBuilder();
        jsonObject.add("id", configId);
        jsonObject.add("message", "the config is deleted.");

        return Response.ok(jsonObject.build()).build();
    }

    try (JsonReader json = Json.createReader(new StringReader(entity))) {
        return Response.status(response.getStatus()).entity(json.read()).build();
    }
}
 

/**
 * Adds a JSON encoded `filters` parameter.
 * @param filters Filters.
 */
private void addFilters(final Map<String, Iterable<String>> filters) {
    if (filters != null && !filters.isEmpty()) {
        final JsonObjectBuilder json = Json.createObjectBuilder();
        filters.forEach(
            (name, values) -> {
                final JsonArrayBuilder array = Json.createArrayBuilder();
                values.forEach(array::add);
                json.add(name, array);
            }
        );
        this.origin.addParameter("filters", json.build().toString());
    }


}
 

private static JsonObjectBuilder buildExecuteInvoke() {
    JsonObjectBuilder headerControl = factory.createObjectBuilder()
                                        .add("type", "blacklist")
                                        .add("values", factory.createArrayBuilder());
    JsonObjectBuilder paramControl = factory.createObjectBuilder()
                                        .add("type", "whitelist")
                                        .add("values", factory.createArrayBuilder());
    return factory.createObjectBuilder()
                                .add("version", "2.0.0")
                                .add("title", "invoke")
                                .add("header-control", headerControl)
                                .add("parameter-control",paramControl)
                                .add("timeout",  60)
                                .add("verb", "keep")
                                .add("cache-response", "protocol")
                                .add("cache-ttl", 900)
                                .add("stop-on-error", factory.createArrayBuilder())
                                .add("target-url", "$(target-url)$(api.operation.path)$(request.search)");
}
 

/**
 * Returns the JSON object that represents the expected header parameters for the given request case.
 */
private Optional<JsonObject> expectedHeaders( RequestCase requestCase)
  {
  JsonObjectBuilder headers = Json.createObjectBuilder();

  toStream( requestCase.getParams())
    .filter( param -> param.getLocation() == HEADER)
    .forEach( param -> TestWriterUtils.getHeaderParameterValue( param).ifPresent( value -> headers.add( param.getName(), value)));

  Optional.ofNullable( requestCase.getBody())
    .flatMap( body -> Optional.ofNullable( body.getMediaType()))
    .ifPresent( mediaType -> {
      JsonObjectBuilder contentType = Json.createObjectBuilder();
      contentType.add( "contain", mediaType);
      headers.add( "Content-Type", contentType.build());
      });

  return Optional.of( headers.build()).filter( json -> !json.isEmpty());
  }
 

@Override
public Response toResponse(Exception exception) {
    LOG.error("Failed to handle request", exception);

    int code = 500;
    if (exception instanceof WebApplicationException) {
        code = ((WebApplicationException) exception).getResponse().getStatus();
    }

    JsonObjectBuilder entityBuilder = Json.createObjectBuilder()
            .add("exceptionType", exception.getClass().getName())
            .add("code", code);

    if (exception.getMessage() != null) {
        entityBuilder.add("error", exception.getMessage());
    }

    return Response.status(code)
            .type(MediaType.APPLICATION_JSON)
            .entity(entityBuilder.build())
            .build();

}
 

@Path("/context/reactive-executor")
@GET
@Produces(MediaType.TEXT_PLAIN)
public JsonObject reactiveExecutor() {
    ReactiveExecutor executor = main.getCamelContext().adapt(ExtendedCamelContext.class).getReactiveExecutor();

    JsonObjectBuilder builder = Json.createObjectBuilder();
    builder.add("class", executor.getClass().getName());

    if (executor instanceof VertXReactiveExecutor) {
        builder.add("configured", ((VertXReactiveExecutor) executor).getVertx() != null);

    }

    return builder.build();
}
 

@Test
public void testAddField1() throws IOException, InterruptedException, InitializationException {

    final Map<String, Object> config = Collections.emptyMap();
    final JsonBuilderFactory factory = Json.createBuilderFactory(config);
    final JsonObjectBuilder builder = factory.createObjectBuilder();
    AzureLogAnalyticsProvenanceReportingTask.addField(builder, "TestKeyString", "StringValue", true);
    AzureLogAnalyticsProvenanceReportingTask.addField(builder, "TestKeyInteger", 2674440, true);
    AzureLogAnalyticsProvenanceReportingTask.addField(builder, "TestKeyLong", 1289904147324L, true);
    AzureLogAnalyticsProvenanceReportingTask.addField(builder, "TestKeyBoolean", true, true);
    AzureLogAnalyticsProvenanceReportingTask.addField(builder, "TestKeyNotSupportedObject", 1.25, true);
    AzureLogAnalyticsProvenanceReportingTask.addField(builder, "TestKeyNull", null, true);
    javax.json.JsonObject actualJson = builder.build();
    String expectedjsonString = "{" +
                                    "\"TestKeyString\": \"StringValue\"," +
                                    "\"TestKeyInteger\": 2674440," +
                                    "\"TestKeyLong\": 1289904147324," +
                                    "\"TestKeyBoolean\": true," +
                                    "\"TestKeyNotSupportedObject\": \"1.25\"," +
                                    "\"TestKeyNull\": null" +
                                "}";
    JsonObject expectedJson = new Gson().fromJson(expectedjsonString, JsonObject.class);
    assertEquals(expectedJson.toString(), actualJson.toString());
}
 

/**
 * Returns the JSON object that represents the given variable definition.
 */
private static JsonStructure toJson( IVarDef varDef)
  {
  JsonObjectBuilder builder = Json.createObjectBuilder();

  addAnnotations( builder, varDef);

  ConditionJson.toJson( varDef).ifPresent( json -> builder.add( WHEN_KEY, json));

  if( varDef.getValues() != null)
    {
    JsonObjectBuilder valuesBuilder = Json.createObjectBuilder();
    toStream( varDef.getValues()).forEach( value -> valuesBuilder.add( String.valueOf( value.getName()), toJson( value)));
    builder.add( VALUES_KEY, valuesBuilder.build());
    }
  else if( varDef.getMembers() != null)
    {
    JsonObjectBuilder membersBuilder = Json.createObjectBuilder();
    toStream( varDef.getMembers()).forEach( member -> membersBuilder.add( member.getName(), toJson( member)));
    builder.add( MEMBERS_KEY, membersBuilder.build());
    }
    
  return builder.build();
  }
 

@Test(groups = { "batch" })
public void testInvalidResource() throws Exception {
    WebTarget target = getWebTarget();

    JsonObjectBuilder bundleObject = TestUtil.getEmptyBundleJsonObjectBuilder();
    JsonObject PatientJsonObject = TestUtil.readJsonObject("InvalidPatient.json");
    JsonObject requestJsonObject = TestUtil.getRequestJsonObject("POST", "Patient");
    JsonObjectBuilder resourceObject = Json.createBuilderFactory(null).createObjectBuilder();
    resourceObject.add( "resource", PatientJsonObject).add("request", requestJsonObject);

    bundleObject.add("Entry", Json.createBuilderFactory(null).createArrayBuilder().add(resourceObject));

    Entity<JsonObject> entity = Entity.entity(bundleObject.build(), FHIRMediaType.APPLICATION_FHIR_JSON);
    Response response = target.request().post(entity, Response.class);
    assertTrue(response.getStatus() >= 400);
}
 

private void init(Node node) {
	JsonObjectBuilder nd = Json.createObjectBuilder();
	nd.add("id", String.valueOf(node.getId()));
	JsonArrayBuilder labels = Json.createArrayBuilder();
	Iterator<Label> lblIter = node.getLabels().iterator();
	boolean hasLabels = false;
	while (lblIter.hasNext()) {
		hasLabels = true;
		Label lab = lblIter.next();
		labels.add(lab.name());
	}
	if (hasLabels)
		nd.add("labels", labels);
	JsonObjectBuilder props = Json.createObjectBuilder();
	Iterator<String> pit = node.getPropertyKeys().iterator();
	while (pit.hasNext()) {
		String pKey = pit.next();
		Object pval = node.getProperty(pKey);
		writeLiteral(pKey, pval, props);
	}
	nd.add("properties", props);
	this.nodeObject = nd;
}
 

public static JsonObject toJson(final Project project) {
    final JsonObjectBuilder projectBuilder = Json.createObjectBuilder();
    projectBuilder.add("uuid", project.getUuid().toString());
    JsonUtil.add(projectBuilder, "name", project.getName());
    JsonUtil.add(projectBuilder, "version", project.getVersion());
    JsonUtil.add(projectBuilder, "description", project.getDescription());
    JsonUtil.add(projectBuilder, "purl", project.getPurl());
    if (project.getTags() != null && project.getTags().size() > 0) {
        final StringBuilder sb = new StringBuilder();
        for (final Tag tag: project.getTags()) {
            sb.append(tag.getName()).append(",");
        }
        String tags = sb.toString();
        if (tags.endsWith(",")) {
            tags = tags.substring(0, tags.length()-1);
        }
        JsonUtil.add(projectBuilder, "tags", tags);
    }
    return projectBuilder.build();
}
 

@Override
public JsonObjectBuilder toJson(RemotingConnection connection) {

   List<ServerSession> sessions = server.getSessions(connection.getID().toString());
   Set<String> users = new TreeSet<>();
   String jmsSessionClientID = null;
   for (ServerSession session : sessions) {
      String username = session.getUsername() == null ? "" : session.getUsername();
      users.add(username);
      //for the special case for JMS
      if (session.getMetaData(ClientSession.JMS_SESSION_IDENTIFIER_PROPERTY) != null) {
         jmsSessionClientID = session.getMetaData("jms-client-id");
      }
   }

   return JsonLoader.createObjectBuilder().add("connectionID", toString(connection.getID()))
      .add("remoteAddress", toString(connection.getRemoteAddress()))
      .add("users", StringUtil.joinStringList(users, ","))
      .add("creationTime", new Date(connection.getCreationTime()).toString())
      .add("implementation", toString(connection.getClass().getSimpleName()))
      .add("protocol", toString(connection.getProtocolName()))
      .add("clientID", toString(connection.getClientID() != null ? connection.getClientID() : jmsSessionClientID))
      .add("localAddress", toString(connection.getTransportLocalAddress()))
      .add("sessionCount", sessions.size());
}
 

@Override
public JsonObjectBuilder getJsonObjectBuilder() {
  return Json.createObjectBuilder()
    .add("trackIdentifier", this.trackIdentifier)
    .add("remoteSource", this.remoteSource)
    .add("ended", this.ended)
    .add("detached", this.detached)
    .add("frameWidth", this.frameWidth)
    .add("frameHeight", this.frameHeight)
    .add("framesPerSecond", this.framesPerSecond)
    .add("framesSent", this.framesSent)
    .add("framesReceived", this.framesReceived)
    .add("frameHeight", this.frameHeight)
    .add("framesDecoded", this.framesDecoded)
    .add("framesDropped", this.framesDropped)
    .add("framesCorrupted", this.framesCorrupted)
    .add("audioLevel", this.audioLevel)
    .add("timestamp", this.timestamp);
}
 

private boolean stateCloneWithProperty( String stateName, JsonValue value )
{
    JsonObject valueState = state.getJsonObject( JSONKeys.VALUE );
    if( Objects.equals( valueState.get( stateName ), value ) )
    {
        return false;
    }
    JsonObjectBuilder valueBuilder = jsonFactories.cloneBuilderExclude( valueState, stateName );
    if( value == null )
    {
        valueBuilder.addNull( stateName );
    }
    else
    {
        valueBuilder.add( stateName, value );
    }
    state = jsonFactories.cloneBuilderExclude( state, JSONKeys.VALUE )
                         .add( JSONKeys.VALUE, valueBuilder.build() )
                         .build();
    return true;
}
 

@ElementListener
public void cat(@Input("str1") final JsonObject str1, @Input("str2") final JsonObject str2,
        @Output final OutputEmitter<JsonObject> concat) {

    if (str1 == null && str2 == null) {
        return;
    }

    final JsonObjectBuilder builder = factory.createObjectBuilder();
    if (str1 != null) {
        str1.keySet().forEach(k -> builder.add(k, str1.get(k)));
    }
    if (str2 != null) {
        str2.keySet().forEach(k -> builder.add(k, str2.get(k)));
    }

    concat.emit(builder.build());
}
 

private JsonObject jsonObject(HealthCheckResponse response) {
    JsonObjectBuilder builder = jsonProvider.createObjectBuilder();
    builder.add("name", response.getName());
    builder.add("status", response.getState().toString());
    response.getData().ifPresent(d -> {
        JsonObjectBuilder data = jsonProvider.createObjectBuilder();
        for (Map.Entry<String, Object> entry : d.entrySet()) {
            Object value = entry.getValue();
            if (value instanceof String) {
                data.add(entry.getKey(), (String) value);
            } else if (value instanceof Long) {
                data.add(entry.getKey(), (Long) value);
            } else if (value instanceof Boolean) {
                data.add(entry.getKey(), (Boolean) value);
            }
        }
        builder.add("data", data.build());
    });

    return builder.build();
}
 

@Override
public JsonObjectBuilder toJson(QueueControl queue) {
   Queue q = server.locateQueue(new SimpleString(queue.getName()));
   JsonObjectBuilder obj = JsonLoader.createObjectBuilder().add("id", toString(queue.getID()))
      .add("name", toString(queue.getName())).add("address", toString(queue.getAddress()))
      .add("filter", toString(queue.getFilter())).add("rate", toString(q.getRate()))
      .add("durable", toString(queue.isDurable())).add("paused", toString(q.isPaused()))
      .add("temporary", toString(queue.isTemporary()))
      .add("purgeOnNoConsumers", toString(queue.isPurgeOnNoConsumers()))
      .add("consumerCount", toString(queue.getConsumerCount()))
      .add("maxConsumers", toString(queue.getMaxConsumers()))
      .add("autoCreated", toString(q.isAutoCreated()))
      .add("user", toString(q.getUser()))
      .add("routingType", toString(queue.getRoutingType()))
      .add("messagesAdded", toString(queue.getMessagesAdded()))
      .add("messageCount", toString(queue.getMessageCount()))
      .add("messagesAcked", toString(queue.getMessagesAcknowledged()))
      .add("deliveringCount", toString(queue.getDeliveringCount()))
      .add("messagesKilled", toString(queue.getMessagesKilled()))
      .add("deliverDeliver", toString(q.isDirectDeliver()))
      .add("exclusive", toString(queue.isExclusive()))
      .add("lastValue", toString(queue.isLastValue()))
      .add("scheduledCount", toString(queue.getScheduledCount()))
      .add("groupRebalance", toString(queue.isGroupRebalance()))
      .add("groupBuckets", toString(queue.getGroupBuckets()))
      .add("groupFirstKey", toString(queue.getGroupFirstKey()));
   return obj;
}
 

public JsonObjectBuilder toJson()
{
    JsonObjectBuilder builder = Json.createObjectBuilder();
    {
        JsonArrayBuilder concernsBuilder = Json.createArrayBuilder();
        concerns().forEach( concern -> concernsBuilder.add( concern.toJson() ) );
        builder.add( "concerns", concernsBuilder );
    }
    return builder;
}
 

public void visit( MocoServerConfigPojo config)
{
JsonObjectBuilder builder = Json.createObjectBuilder();
if( config.getFactory() != null)
  {
  builder.add( POJO_WRITER_FACTORY, config.getFactory().getClass().getName());
  }
else
  {
  builder.add( POJO_WRITER_FACTORY, JsonValue.NULL);
  }

json_ = builder.build();
}
 

public JsonObject buildOrderTeaser(Order order, URI self) {
    final JsonObjectBuilder builder = Json.createObjectBuilder();

    builder.add("date", order.getDate().toString());
    builder.add("price", order.getPrice());
    builder.add("status", order.getStatus().name());
    builder.add("_links", Json.createObjectBuilder().add("self", self.toString()));

    return builder.build();
}
 

@Test
public void testAddField3() throws IOException, InterruptedException, InitializationException {

    final Map<String, Object> config = Collections.emptyMap();
    final JsonBuilderFactory factory = Json.createBuilderFactory(config);
    final JsonObjectBuilder builder = factory.createObjectBuilder();
    Collection<String> values = new ArrayList<String>();
    values.add("TestValueString1");
    values.add("TestValueString2");
    AzureLogAnalyticsProvenanceReportingTask.addField(builder, factory, "TestKeyString", values, true);
    javax.json.JsonObject actualJson = builder.build();
    String expectedjsonString = "{\"TestKeyString\":[\"TestValueString1\",\"TestValueString2\"]}";
    JsonObject expectedJson = new Gson().fromJson(expectedjsonString, JsonObject.class);
    assertEquals(expectedJson.toString(), actualJson.toString());
}
 

@javax.ws.rs.GET
public JsonObject method() {
    final JsonObjectBuilder objectBuilder = Json.createObjectBuilder();
    objectBuilder.add("key", "value");
    if ("".equals(""))
        objectBuilder.add("another", "value");
    else
        objectBuilder.add("key", "test");
    return objectBuilder.build();
}
 

private void onCollaborativeInviteMessage(String sender, Session session, WebSocketMessage webSocketMessage) {

        String invitedUser = webSocketMessage.getString("remoteUser");
        JsonObject broadcastMessage = webSocketMessage.getJsonObject("broadcastMessage");
        String context = broadcastMessage.getString("context");
        String url = broadcastMessage.getString("url");

        CollaborativeRoom room = CollaborativeRoom.getByKeyName(webSocketMessage.getString("key"));

        if (webSocketSessionsManager.isAllowedToReachUser(sender, invitedUser)) {

            if (room.getMasterName().equals(sender) && room.findUserSession(invitedUser) == null) {
                // the master sent the invitation
                // the user is not already in the room
                if (!room.getPendingUsers().contains(invitedUser)) {
                    // the user is not yet in the pending list, add him.
                    room.addPendingUser(invitedUser);
                }

                String invite = "/invite " + url + "/room/" + room.getKey();

                JsonObjectBuilder b = Json.createObjectBuilder()
                        .add("type", CHAT_MESSAGE)
                        .add("remoteUser", sender)
                        .add("sender", sender)
                        .add("message", invite)
                        .add("context", context);
                WebSocketMessage message = new WebSocketMessage(b.build());
                webSocketSessionsManager.broadcast(invitedUser, message);
                broadcastNewContext(room);
            }


        }
    }
 

/**
 * Ctor.
 * @param objects JsonObjects to combine.
 */
Merged(final JsonObject... objects) {
    super(() -> {
        final JsonObjectBuilder combined = Json.createObjectBuilder();
        for(final JsonObject json : objects) {
            json.forEach(combined::add);
        }
        return combined.build();
    });
}
 

/**
 * Get all user profiles.
 *
 * @return All user profiles (excluding private fields like password).
 */
@GET
@Produces("application/json")
public Response getAllUsers() {
  // Validate the JWT. The JWT must be in the 'users' group.
  try {
    validateJWT(new HashSet<String>(Arrays.asList("users")));
  } catch (JWTException jwte) {
    return Response.status(Status.UNAUTHORIZED)
        .type(MediaType.TEXT_PLAIN)
        .entity(jwte.getMessage())
        .build();
  }

  // Get all the users from the database, and add them to an array.
  DB database = mongo.getMongoDB();
  DBCollection dbCollection = database.getCollection(User.DB_COLLECTION_NAME);
  DBCursor cursor = dbCollection.find();
  JsonArrayBuilder userArray = Json.createArrayBuilder();
  while (cursor.hasNext()) {
    // Exclude all private information from the list.
    userArray.add((new User(cursor.next()).getPublicJsonObject()));
  }

  // Return the user list to the caller.
  JsonObjectBuilder responseBuilder = Json.createObjectBuilder().add("users", userArray.build());
  return Response.ok(responseBuilder.build(), MediaType.APPLICATION_JSON).build();
}
 

@Override
public JsonObjectBuilder toJson(ServerSession session) {
   JsonObjectBuilder obj = JsonLoader.createObjectBuilder().add("id", toString(session.getName()))
      .add("user", toString(session.getUsername()))
      .add("creationTime", new Date(session.getCreationTime()).toString())
      .add("consumerCount", session.getConsumerCount())
      .add("producerCount", session.getProducerCount())
      .add("connectionID", session.getConnectionID().toString());
   return obj;
}