Java ContentType.APPLICATION_JSON屬性代碼示例

/**
 * Updates a modules config for the given app
 *
 * @param customerName
 *        the name of the customer
 * @param appName
 *        the name of the app
 * @param moduleName
 *        the name of the module to update config for
 * @param key
 *        config key
 * @param value
 *        value of the config
 * @return request object to check status codes and return values
 */
public Response updateConfig( String customerName, String appName, String moduleName, String key,
	String value )
{
	final HttpPut request = new HttpPut( this.yambasBase + "customers/" + customerName + "/apps/" + appName );
	setAuthorizationHeader( request );
	request.addHeader( "ContentType", "application/json" );
	request.addHeader( "x-apiomat-system", this.system.toString( ) );
	try
	{
		final HttpEntity requestEntity = new StringEntity(
			"{\"configuration\":" + "	{\"" + this.system.toString( ).toLowerCase( ) + "Config\": {\"" +
				moduleName + "\":{\"" + key + "\":\"" + value + "\"}}}, \"applicationName\":\"" + appName + "\"}",
			ContentType.APPLICATION_JSON );
		request.setEntity( requestEntity );

		final HttpResponse response = this.client.execute( request );
		return new Response( response );
	}
	catch ( final IOException e )
	{
		e.printStackTrace( );
	}
	return null;
}
 

/**
 * Creates an object of the given dataModelName and moduleName
 * the appname which is set in this object will be used
 *
 * @param moduleName
 *        the modulenname
 * @param dataModelName
 *        the name of the datamodels
 * @param otherFieldsObject
 *        the other fields to set as JSONObject (the @type field will be added automatically)
 * @return request object to check status codes and return values
 */
public Response createObject( String moduleName, String dataModelName, JSONObject otherFieldsObject )
{
	final HttpPost request = new HttpPost(
		this.yambasBase + "apps/" + this.appName + "/models/" + moduleName + "/" + dataModelName );
	setAuthorizationHeader( request );
	request.addHeader( "ContentType", "application/json" );
	request.addHeader( "x-apiomat-apikey", this.apiKey );
	request.addHeader( "x-apiomat-system", this.system.toString( ) );
	request.addHeader( "x-apiomat-sdkVersion", this.sdkVersion );
	try
	{
		otherFieldsObject.put( "@type", moduleName + '$' + dataModelName );
		final HttpEntity requestEntity =
			new StringEntity( otherFieldsObject.toString( ), ContentType.APPLICATION_JSON );
		request.setEntity( requestEntity );
		final HttpResponse response = this.client.execute( request );
		return new Response( response );
	}
	catch ( final IOException e )
	{
		e.printStackTrace( );
	}
	return null;
}
 

@Override
public boolean bulkIndex(List<String> bulkData) {
    StringBuilder bulkRequestBody = new StringBuilder();
    for (String bulkItem : bulkData) {
        bulkRequestBody.append(actionMetaData);
        bulkRequestBody.append(bulkItem);
        bulkRequestBody.append("\n");
    }
    HttpEntity entity = new NStringEntity(bulkRequestBody.toString(), ContentType.APPLICATION_JSON);
    try {
        Response response = client.performRequest("POST", "/geonames/type/_noop_bulk", Collections.emptyMap(), entity);
        return response.getStatusLine().getStatusCode() == HttpStatus.SC_OK;
    } catch (Exception e) {
        throw new ElasticsearchException(e);
    }
}
 

private static void bufferLimitTest(HeapBufferedAsyncResponseConsumer consumer, int bufferLimit) throws Exception {
    ProtocolVersion protocolVersion = new ProtocolVersion("HTTP", 1, 1);
    StatusLine statusLine = new BasicStatusLine(protocolVersion, 200, "OK");
    consumer.onResponseReceived(new BasicHttpResponse(statusLine));

    final AtomicReference<Long> contentLength = new AtomicReference<>();
    HttpEntity entity = new StringEntity("", ContentType.APPLICATION_JSON) {
        @Override
        public long getContentLength() {
            return contentLength.get();
        }
    };
    contentLength.set(randomLong(bufferLimit));
    consumer.onEntityEnclosed(entity, ContentType.APPLICATION_JSON);

    contentLength.set(randomLongBetween(bufferLimit + 1, MAX_TEST_BUFFER_SIZE));
    try {
        consumer.onEntityEnclosed(entity, ContentType.APPLICATION_JSON);
    } catch(ContentTooLongException e) {
        assertEquals("entity content is too long [" + entity.getContentLength() +
                "] for the configured buffer limit [" + bufferLimit + "]", e.getMessage());
    }
}
 

@Test
public void testPositiveCreateQueue() throws IOException {
    String queueName = "testPositiveCreateQueue";
    QueueCreateRequest request = new QueueCreateRequest()
            .name(queueName).durable(false).autoDelete(false);

    HttpPost httpPost = new HttpPost(apiBasePath + "/queues");

    String value = objectMapper.writeValueAsString(request);
    StringEntity stringEntity = new StringEntity(value, ContentType.APPLICATION_JSON);
    httpPost.setEntity(stringEntity);

    CloseableHttpResponse response = client.execute(httpPost);

    Assert.assertEquals(response.getStatusLine().getStatusCode(), HttpStatus.SC_CREATED);
    Assert.assertEquals(response.getFirstHeader(HttpHeaders.LOCATION).getValue(),
                        apiBasePath + "/queues/" + queueName,
                        "Incorrect location header");

    String body = responseHandler.handleResponse(response);
    QueueCreateResponse queueCreateResponse = objectMapper.readValue(body, QueueCreateResponse.class);

    Assert.assertFalse(queueCreateResponse.getMessage().isEmpty(), "Response body shouldn't be empty");

}
 

@Test
public void testDeleteQueue() throws IOException {
    String queueName = "testDeleteQueue";

    // Create a queue to delete.
    QueueCreateRequest request = new QueueCreateRequest()
            .name(queueName).durable(false).autoDelete(false);

    HttpPost httpPost = new HttpPost(apiBasePath + "/queues");

    String value = objectMapper.writeValueAsString(request);
    StringEntity stringEntity = new StringEntity(value, ContentType.APPLICATION_JSON);
    httpPost.setEntity(stringEntity);

    CloseableHttpResponse response = client.execute(httpPost);
    Assert.assertEquals(response.getStatusLine().getStatusCode(), HttpStatus.SC_CREATED);

    // Delete the queue.
    HttpDelete httpDelete = new HttpDelete(apiBasePath + QueuesApiDelegate.QUEUES_API_PATH + "/" + queueName);
    response = client.execute(httpDelete);

    Assert.assertEquals(response.getStatusLine().getStatusCode(), HttpStatus.SC_OK);
}
 

/**
 * Create Post Request with json body
 */
public HttpPost createPost(String uri, String data) {
    HttpPost httpPost = new HttpPost(uri);
    httpPost.setHeader("Content-Type", "application/json");
    HttpEntity entity = new StringEntity(data, ContentType.APPLICATION_JSON);
    httpPost.setEntity(entity);
    return httpPost;
}
 

static HttpEntity scrollEntity(String scroll) {
    try (XContentBuilder entity = JsonXContent.contentBuilder()) {
        return new StringEntity(entity.startObject()
            .field("scroll_id", scroll)
            .endObject().string(), ContentType.APPLICATION_JSON);
    } catch (IOException e) {
        throw new ElasticsearchException("failed to build scroll entity", e);
    }
}
 

void index(String key, String value) {
  try {
    final HttpEntity entity = new NStringEntity(value, ContentType.APPLICATION_JSON);
    final String endpoint = String.format("%s/%s", "/tweets/tweet", key);
    final Response response = restClient.performRequest("PUT", endpoint, Collections.<String, String>emptyMap(), entity);
    if (response.getStatusLine().getStatusCode() != 200
        && response.getStatusLine().getStatusCode() != 201) {
      throw new IllegalStateException(response.getStatusLine().getReasonPhrase());
    }
  } catch (IOException e) {
    throw new RuntimeException(e);
  }
}
 

/**
 * Creates an index and adds an alias to it.
 * @param aliasName
 * @param version
 * @param indexConf must be a valid ES config JSON.
 */
public void createIndex(String aliasName, int version, String indexConf) {
    HttpEntity entity = new NStringEntity(indexConf, ContentType.APPLICATION_JSON);
    String indexName = aliasName + INDEX_VERSION_INFIX + version;
    try {
        restClient.performRequest("PUT", indexName, Collections.emptyMap(), entity);
        addAlias(indexName, aliasName);
    } catch (IOException e) {
        e.printStackTrace();
    }
}
 

@Test
public void testDuplicateQueueCreation() throws IOException {
    QueueCreateRequest request = new QueueCreateRequest()
            .name("testDuplicateQueueCreation").durable(false).autoDelete(false);
    HttpPost httpPost = new HttpPost(apiBasePath + "/queues");

    String value = objectMapper.writeValueAsString(request);
    StringEntity stringEntity = new StringEntity(value, ContentType.APPLICATION_JSON);
    httpPost.setEntity(stringEntity);

    CloseableHttpResponse response = client.execute(httpPost);
    Assert.assertEquals(response.getStatusLine().getStatusCode(), HttpStatus.SC_CREATED, "Incorrect status code");

    response = client.execute(httpPost);
    Assert.assertEquals(response.getStatusLine().getStatusCode(), HttpStatus.SC_BAD_REQUEST, "Incorrect status "
            + "code");

    String body = EntityUtils.toString(response.getEntity());
    Error error = objectMapper.readValue(body, Error.class);
    Assert.assertFalse(error.getMessage().isEmpty(), "Response body shouldn't be empty");
}
 

@Override
public void send(String body) throws IOException {
	HttpEntity entity = new NStringEntity(body.toString(), ContentType.APPLICATION_JSON);
	Response response = this.restClient.performRequest(HTTP_METHOD, "_bulk", Collections.emptyMap(), entity);
	if (response.getStatusLine().getStatusCode() >= 300) {
		throw new HttpResponseException(response.getStatusLine().getStatusCode(), response.getStatusLine().getReasonPhrase());
	}
}
 

static <T> StringEntity toEntity(T resource) {
    StringWriter sink = new StringWriter();
    new JsonSinkWriter<>(sink).write(resource);
    String serializedResource = sink.toString();
    return new StringEntity(serializedResource,
                            ContentType.APPLICATION_JSON);  // (*)
}
 

public <T> T put(String resource, String body ,Class<T> responseClass, boolean assertSuccess) throws IOException {
	final HttpEntity entity = new NStringEntity(body, ContentType.APPLICATION_JSON);
	final Response response = client.performRequest("PUT", resource, Collections.<String, String>emptyMap(),
			entity);
	if (assertSuccess) {
		assertSuccess(response);
	}
	return mapper.readValue(IOUtils.toString(response.getEntity().getContent(), "UTF-8"), responseClass);
}
 

private HttpPost createRequestFor(final DeltaAnalysisRequest payload) throws URISyntaxException {
    final CodeSceneUser user = config.user();

    final Header authorization = new BasicHeader("Authorization", "Basic " + user.asBase64Encoded());

    HttpPost codeSceneRequest = new HttpPost(config.codeSceneUrl().toURI());
    codeSceneRequest.addHeader(authorization);

    StringEntity requestEntity = new StringEntity(
            payload.asJson().toString(),
            ContentType.APPLICATION_JSON);
    codeSceneRequest.setEntity(requestEntity);

    return codeSceneRequest;
}