Example usage for org.apache.http.client.methods RequestBuilder setEntity

List of usage examples for org.apache.http.client.methods RequestBuilder setEntity

  1. HOME
  2. Java
  3. org.apache.http
  4. org.apache.http.client.methods.*
  5. RequestBuilder
  6. setEntity

Introduction

In this page you can find the example usage for org.apache.http.client.methods RequestBuilder setEntity.

Prototype

public RequestBuilder setEntity(final HttpEntity entity)

Source Link

Usage

From source file:com.github.tomakehurst.wiremock.client.HttpAdminClient.java

private <B, R> R executeRequest(RequestSpec requestSpec, PathParams pathParams, B requestBody,
        Class<R> responseType) {
    String url = String.format(ADMIN_URL_PREFIX + requestSpec.path(pathParams), scheme, host, port,
            urlPathPrefix);//w  w  w . java  2s.  com
    RequestBuilder requestBuilder = RequestBuilder.create(requestSpec.method().getName()).setUri(url);

    if (requestBody != null) {
        requestBuilder.setEntity(jsonStringEntity(Json.write(requestBody)));
    }

    String responseBodyString = safelyExecuteRequest(url, requestBuilder.build());

    return responseType == Void.class ? null : Json.read(responseBodyString, responseType);
}

From source file:com.yahoo.validatar.execution.rest.JSON.java

/**
 * Creates a HttpUriRequest based on the metadata configuration.
 * @param metadata The metadata configuration.
 * @return A configured request object.// w w  w  .  j a v a 2s. com
 */
private HttpUriRequest createRequest(Map<String, String> metadata) {
    String verb = metadata.getOrDefault(VERB_KEY, DEFAULT_VERB);
    String url = metadata.get(URL_KEY);
    if (url == null || url.isEmpty()) {
        throw new IllegalArgumentException("The " + URL_KEY + " must be provided and contain a valid url.");
    }
    RequestBuilder builder;
    if (GET.equals(verb)) {
        builder = RequestBuilder.get(url);
    } else if (POST.equals(verb)) {
        builder = RequestBuilder.post(url);
        String body = metadata.getOrDefault(BODY_KEY, EMPTY_BODY);
        builder.setEntity(new StringEntity(body, Charset.defaultCharset()));
    } else {
        throw new UnsupportedOperationException("This HTTP method is not currently supported: " + verb);
    }
    // Everything else is assumed to be a header
    metadata.entrySet().stream().filter(entry -> !KNOWN_KEYS.contains(entry.getKey()))
            .forEach(entry -> builder.addHeader(entry.getKey(), entry.getValue()));
    return builder.build();
}

From source file:org.keycloak.authorization.client.util.HttpMethod.java

public HttpMethod<R> form() {
    return new HttpMethod<R>(this.configuration, authenticator, this.builder, this.params, this.headers) {
        @Override//from  ww w  .  j  a  v  a  2 s  . c  om
        protected void preExecute(RequestBuilder builder) {
            if (params != null) {
                List<NameValuePair> formparams = new ArrayList<>();

                for (Map.Entry<String, List<String>> param : params.entrySet()) {
                    for (String value : param.getValue()) {
                        formparams.add(new BasicNameValuePair(param.getKey(), value));
                    }
                }

                try {
                    builder.setEntity(new UrlEncodedFormEntity(formparams, "UTF-8"));
                } catch (UnsupportedEncodingException e) {
                    throw new RuntimeException("Error creating form parameters");
                }
            }
        }
    };
}

From source file:com.hp.octane.integrations.services.rest.OctaneRestClientImpl.java

/**
 * This method should be the ONLY mean that creates Http Request objects
 *
 * @param octaneRequest Request data as it is maintained in Octane related flavor
 * @return pre-configured HttpUriRequest
 *///  w ww . j a v a  2s.  c o m
private HttpUriRequest createHttpRequest(OctaneRequest octaneRequest) {
    HttpUriRequest request;
    RequestBuilder requestBuilder;

    //  create base request by METHOD
    if (octaneRequest.getMethod().equals(HttpMethod.GET)) {
        requestBuilder = RequestBuilder.get(octaneRequest.getUrl());
    } else if (octaneRequest.getMethod().equals(HttpMethod.DELETE)) {
        requestBuilder = RequestBuilder.delete(octaneRequest.getUrl());
    } else if (octaneRequest.getMethod().equals(HttpMethod.POST)) {
        requestBuilder = RequestBuilder.post(octaneRequest.getUrl());
        requestBuilder
                .addHeader(new BasicHeader(RestService.CONTENT_ENCODING_HEADER, RestService.GZIP_ENCODING));
        requestBuilder.setEntity(new GzipCompressingEntity(
                new InputStreamEntity(octaneRequest.getBody(), ContentType.APPLICATION_JSON)));
    } else if (octaneRequest.getMethod().equals(HttpMethod.PUT)) {
        requestBuilder = RequestBuilder.put(octaneRequest.getUrl());
        requestBuilder
                .addHeader(new BasicHeader(RestService.CONTENT_ENCODING_HEADER, RestService.GZIP_ENCODING));
        requestBuilder.setEntity(new GzipCompressingEntity(
                new InputStreamEntity(octaneRequest.getBody(), ContentType.APPLICATION_JSON)));
    } else {
        throw new RuntimeException("HTTP method " + octaneRequest.getMethod() + " not supported");
    }

    //  set custom headers
    if (octaneRequest.getHeaders() != null) {
        for (Map.Entry<String, String> e : octaneRequest.getHeaders().entrySet()) {
            requestBuilder.setHeader(e.getKey(), e.getValue());
        }
    }

    //  set system headers
    requestBuilder.setHeader(CLIENT_TYPE_HEADER, CLIENT_TYPE_VALUE);

    request = requestBuilder.build();
    return request;
}

From source file:com.aliyun.api.gateway.demo.Client.java

/**
 * ??//from  ww w .  ja v  a 2s  .co m
 *
 * @param request
 *            requestnull{@link NullPointerException}
 * @return HttpResponse HTTP?
 * @throws IOException
 *             HTTP?
 * @throws ClientProtocolException
 *             ????
 */
public HttpResponse execute(Request request) throws ClientProtocolException, IOException {
    if (request == null) {
        return null;
    }
    RequestBuilder requestBuilder = request.getMethod().requestbuilder().setUri(request.getUrl().toString());
    requestBuilder
            .setConfig(RequestConfig.custom().setConnectTimeout(getTimeout(request.getTimeout())).build());
    requestBuilder.addHeader(SystemHeader.X_CA_TIMESTAMP, String.valueOf(System.currentTimeMillis()));
    requestBuilder.addHeader(SystemHeader.X_CA_NONCE, UUID.randomUUID().toString());
    requestBuilder.addHeader(SystemHeader.X_CA_KEY, appKey);
    if (testEnv) {
        requestBuilder.addHeader(SystemHeader.X_CA_STAGE, "test");
    }
    requestBuilder.build().getAllHeaders();
    initialBasicHeader(requestBuilder, request.getHeaders(), request.getUrl(), request.getFormBody(),
            request.getSignHeaderPrefixes());
    HttpEntity entity = getEntity(request);
    if (entity != null) {
        requestBuilder.setEntity(entity);
    }
    return httpClient.execute(requestBuilder.build());
}

From source file:com.wudaosoft.net.httpclient.Request.java

/**
 * /*w  w  w  .  j  a  v a2  s.  c o  m*/
 * @param workerBuilder
 * @param responseHandler
 * @return
 * @throws Exception
 */
public <T> T doRequest(WorkerBuilder workerBuilder, ResponseHandler<T> responseHandler) throws Exception {

    String method = workerBuilder.getMethod();
    String url = workerBuilder.getUrl();

    Args.notNull(workerBuilder, "WorkerBuilder");
    Args.notEmpty(method, "WorkerBuilder.getMethod()");
    Args.notEmpty(url, "WorkerBuilder.getUrl()");
    Args.notNull(responseHandler, "responseHandler");

    //      if(!workerBuilder.isAnyHost()) {
    if (!isFullUrl(url)) {
        //         notFullUrl(url);
        Args.notEmpty(hostConfig.getHostUrl(), "HostConfig.getHostUrl()");
        url = hostConfig.getHostUrl() + url;
    }

    Charset charset = hostConfig.getCharset() == null ? Consts.UTF_8 : hostConfig.getCharset();
    String stringBody = workerBuilder.getStringBody();
    File fileBody = workerBuilder.getFileBody();
    InputStream streamBody = workerBuilder.getStreamBody();
    Map<String, String> params = workerBuilder.getParameters();

    String contentType = null;

    if (responseHandler instanceof JsonResponseHandler) {
        contentType = MediaType.APPLICATION_JSON_VALUE;
    } else if (responseHandler instanceof SAXSourceResponseHandler
            || responseHandler instanceof XmlResponseHandler) {
        contentType = MediaType.APPLICATION_XML_VALUE;
    } else if (responseHandler instanceof FileResponseHandler || responseHandler instanceof ImageResponseHandler
            || responseHandler instanceof OutputStreamResponseHandler) {
        contentType = MediaType.ALL_VALUE;
    } else if (responseHandler instanceof NoResultResponseHandler) {
        contentType = ((NoResultResponseHandler) responseHandler).getContentType().getMimeType();
    } else {
        contentType = MediaType.TEXT_PLAIN_VALUE;
    }

    RequestBuilder requestBuilder = RequestBuilder.create(method).setCharset(charset).setUri(url);

    if (stringBody != null) {

        StringEntity reqEntity = new StringEntity(stringBody, charset);
        reqEntity.setContentType(contentType + ";charset=" + charset.name());
        requestBuilder.setEntity(reqEntity);

    } else if (fileBody != null || streamBody != null) {

        String filename = workerBuilder.getFilename();

        MultipartEntityBuilder reqEntity = MultipartEntityBuilder.create().setLaxMode();

        if (fileBody != null) {
            Args.check(fileBody.isFile(), "fileBody must be a file");
            Args.check(fileBody.canRead(), "fileBody must be readable");

            if (filename == null && streamBody == null)
                filename = fileBody.getName();

            FileBody bin = new FileBody(fileBody, ContentType.APPLICATION_OCTET_STREAM,
                    streamBody != null ? fileBody.getName() : filename);
            reqEntity.addPart(workerBuilder.getFileFieldName(), bin);
        }

        Args.notEmpty(filename, "filename");

        if (streamBody != null)
            reqEntity.addBinaryBody(workerBuilder.getFileFieldName(), streamBody,
                    ContentType.APPLICATION_OCTET_STREAM, filename);

        buildParameters(reqEntity, params, charset);

        requestBuilder.setEntity(reqEntity.build());
    }

    if (fileBody == null && streamBody == null) {
        buildParameters(requestBuilder, params);
    }

    if (workerBuilder.getReadTimeout() > -1) {

        requestBuilder.setConfig(RequestConfig.copy(this.hostConfig.getRequestConfig())
                .setSocketTimeout(workerBuilder.getReadTimeout()).build());
    }

    HttpUriRequest httpRequest = ParameterRequestBuilder.build(requestBuilder);

    setAcceptHeader(httpRequest, contentType);

    if (workerBuilder.isAjax())
        setAjaxHeader(httpRequest);

    HttpClientContext context = workerBuilder.getContext();
    if (context == null)
        context = defaultHttpContext;

    T result = getHttpClient().execute(httpRequest, responseHandler, context);

    if (log.isDebugEnabled()) {
        log.debug(String.format("Send data to path:[%s]\"%s\". result: %s", method, url, result));
    }

    return result;
}

From source file:org.springframework.cloud.netflix.ribbon.apache.RibbonApacheHttpRequest.java

public HttpUriRequest toRequest(final RequestConfig requestConfig) {
    final RequestBuilder builder = RequestBuilder.create(this.context.getMethod());
    builder.setUri(this.uri);
    for (final String name : this.context.getHeaders().keySet()) {
        final List<String> values = this.context.getHeaders().get(name);
        for (final String value : values) {
            builder.addHeader(name, value);
        }//w w w  .ja v  a 2 s  . co m
    }

    for (final String name : this.context.getParams().keySet()) {
        final List<String> values = this.context.getParams().get(name);
        for (final String value : values) {
            builder.addParameter(name, value);
        }
    }

    if (this.context.getRequestEntity() != null) {
        final BasicHttpEntity entity;
        entity = new BasicHttpEntity();
        entity.setContent(this.context.getRequestEntity());
        // if the entity contentLength isn't set, transfer-encoding will be set
        // to chunked in org.apache.http.protocol.RequestContent. See gh-1042
        if (this.context.getContentLength() != null) {
            entity.setContentLength(this.context.getContentLength());
        } else if ("GET".equals(this.context.getMethod())) {
            entity.setContentLength(0);
        }
        builder.setEntity(entity);
    }

    customize(this.context.getRequestCustomizers(), builder);

    builder.setConfig(requestConfig);
    return builder.build();
}

From source file:org.apache.commons.jcs.auxiliary.remote.http.client.RemoteHttpCacheDispatcher.java

/**
 * Process single request/*from   ww  w.  jav a2s  .c  o m*/
 *
 * @param requestAsByteArray request body
 * @param remoteCacheRequest the cache request
 * @param url target url
 *
 * @return byte[] - the response
 *
 * @throws IOException
 * @throws HttpException
 */
protected <K, V> byte[] processRequest(byte[] requestAsByteArray, RemoteCacheRequest<K, V> remoteCacheRequest,
        String url) throws IOException, HttpException {
    RequestBuilder builder = RequestBuilder.post(url).setCharset(DEFAULT_ENCODING);

    if (getRemoteHttpCacheAttributes().isIncludeCacheNameAsParameter()
            && remoteCacheRequest.getCacheName() != null) {
        builder.addParameter(PARAMETER_CACHE_NAME, remoteCacheRequest.getCacheName());
    }
    if (getRemoteHttpCacheAttributes().isIncludeKeysAndPatternsAsParameter()) {
        String keyValue = "";
        switch (remoteCacheRequest.getRequestType()) {
        case GET:
        case REMOVE:
        case GET_KEYSET:
            keyValue = remoteCacheRequest.getKey().toString();
            break;
        case GET_MATCHING:
            keyValue = remoteCacheRequest.getPattern();
            break;
        case GET_MULTIPLE:
            keyValue = remoteCacheRequest.getKeySet().toString();
            break;
        case UPDATE:
            keyValue = remoteCacheRequest.getCacheElement().getKey().toString();
            break;
        default:
            break;
        }
        builder.addParameter(PARAMETER_KEY, keyValue);
    }
    if (getRemoteHttpCacheAttributes().isIncludeRequestTypeasAsParameter()) {
        builder.addParameter(PARAMETER_REQUEST_TYPE, remoteCacheRequest.getRequestType().toString());
    }

    builder.setEntity(new ByteArrayEntity(requestAsByteArray));
    HttpResponse httpResponse = doWebserviceCall(builder);
    byte[] response = EntityUtils.toByteArray(httpResponse.getEntity());
    return response;
}