protected void setcontent(RequestBuilder rb) {
  switch (this.methodkind) {
    case Put:
      if (this.content != null)
        rb.setEntity(this.content);
      break;
    case Post:
      if (this.content != null)
        rb.setEntity(this.content);
      break;
    case Head:
    case Get:
    case Options:
    default:
      break;
  }
  this.content = null; // do not reuse
}
 

protected RequestBuilder selectRequestMethod(Request request) {
    String method = request.getMethod();
    if (method == null || method.equalsIgnoreCase(HttpConstant.Method.GET)) {
        //default get
        return RequestBuilder.get();
    } else if (method.equalsIgnoreCase(HttpConstant.Method.POST)) {
        RequestBuilder requestBuilder = RequestBuilder.post();
        NameValuePair[] nameValuePair = (NameValuePair[]) request.getExtra("nameValuePair");
        if (nameValuePair != null && nameValuePair.length > 0) {
            requestBuilder.addParameters(nameValuePair);
        }
        return requestBuilder;
    } else if (method.equalsIgnoreCase(HttpConstant.Method.HEAD)) {
        return RequestBuilder.head();
    } else if (method.equalsIgnoreCase(HttpConstant.Method.PUT)) {
        return RequestBuilder.put();
    } else if (method.equalsIgnoreCase(HttpConstant.Method.DELETE)) {
        return RequestBuilder.delete();
    } else if (method.equalsIgnoreCase(HttpConstant.Method.TRACE)) {
        return RequestBuilder.trace();
    }
    throw new IllegalArgumentException("Illegal HTTP Method " + method);
}
 

@Benchmark
public void test(Blackhole bh) {
    String body = "{\"name\":\"ppdai\"}";
    String url = "http://localhost:" + port + "/raptor/com.ppdai.framework.raptor.proto.Simple/sayHello";
    HttpUriRequest request = RequestBuilder.post(url)
            .addHeader("connection", "Keep-Alive")
            .setEntity(EntityBuilder.create().setText(body).setContentType(ContentType.APPLICATION_JSON).build())
            .build();
    String responseBody;
    try (CloseableHttpResponse response = httpClient.execute(request)) {
        ByteArrayOutputStream bos = new ByteArrayOutputStream(100);
        response.getEntity().writeTo(bos);
        responseBody = new String(bos.toByteArray(), StandardCharsets.UTF_8);
    } catch (IOException e) {
        throw new RuntimeException("error", e);
    }
    bh.consume(responseBody);
}
 

/**
 * Creates a HttpUriRequest based on the metadata configuration.
 * @param metadata The metadata configuration.
 * @return A configured request object.
 */
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();
}
 

protected <Res> void asyncSend(HttpRequest request, AbstractResponseConsumer<Res> consumer, FutureCallback<Res> callback,
                               String contentType, HttpMethod method, boolean httpInvoke)
        throws ClientException {
    try{
        // try refresh credentials if CredentialProvider set
        config.refreshCredentials();

        // Add all needed headers
        if (!httpInvoke
                || !ANONYMOUS.equals(((HttpInvokeFunctionRequest) request).getAuthType())) {
            FcUtil.signRequest(config, request, contentType, method, httpInvoke);
        }

        // Construct HttpRequest
        PrepareUrl prepareUrl = FcUtil.prepareUrl(request.getPath(), request.getQueryParams(), this.config);
        RequestBuilder requestBuilder = RequestBuilder.create(method.name())
                .setUri(prepareUrl.getUrl());
        copyToRequest(request, requestBuilder);
        HttpUriRequest httpRequest = requestBuilder.build();

        HttpHost httpHost = URIUtils.extractHost(httpRequest.getURI());
        httpClient.execute(new FcRequestProducer(httpHost, httpRequest), consumer, callback);
    } catch (Exception e) {
        throw new ClientException(e);
    }
}
 

@Override
public AwsTemporaryCredentials getAwsTemporaryCredentials(AthenzDomain athenzDomain, AwsRole awsRole, Duration duration, String externalId) {
    URI uri = ztsUrl.resolve(
            String.format("domain/%s/role/%s/creds", athenzDomain.getName(), awsRole.encodedName()));
    RequestBuilder requestBuilder = RequestBuilder.get(uri);

    // Add optional durationSeconds and externalId parameters
    Optional.ofNullable(duration).ifPresent(d -> requestBuilder.addParameter("durationSeconds", Long.toString(duration.getSeconds())));
    Optional.ofNullable(externalId).ifPresent(s -> requestBuilder.addParameter("externalId", s));

    HttpUriRequest request = requestBuilder.build();
    return execute(request, response -> {
        AwsTemporaryCredentialsResponseEntity entity = readEntity(response, AwsTemporaryCredentialsResponseEntity.class);
        return entity.credentials();
    });
}
 

/**
 * This is how framework makes the KeyValue pair when "application/x-www-form-urlencoded" headers
 * is passed in the request.  In case you want to build or prepare the requests differently,
 * you can override this method via @UseHttpClient(YourCustomHttpClient.class).
 *
 * @param httpUrl
 * @param methodName
 * @param reqBodyAsString
 * @return
 * @throws IOException
 */
public RequestBuilder createFormUrlEncodedRequestBuilder(String httpUrl, String methodName, String reqBodyAsString) throws IOException {
    RequestBuilder requestBuilder = RequestBuilder
            .create(methodName)
            .setUri(httpUrl);
    if (reqBodyAsString != null) {
        Map<String, Object> reqBodyMap = HelperJsonUtils.readObjectAsMap(reqBodyAsString);
        List<NameValuePair> reqBody = new ArrayList<>();
         for(String key : reqBodyMap.keySet()) {
             reqBody.add(new BasicNameValuePair(key, reqBodyMap.get(key).toString()));
         }
         HttpEntity httpEntity = new UrlEncodedFormEntity(reqBody);
         requestBuilder.setEntity(httpEntity);
        requestBuilder.setHeader(CONTENT_TYPE, APPLICATION_FORM_URL_ENCODED);
    }
    return requestBuilder;
}
 

InputStream executeRawStream(
        final RequestBuilder requestBuilder,
        @Nullable final RequestOptions requestOptions
)
        throws IOException, NomadException {

    final HttpUriRequest request = buildRequest(requestBuilder, requestOptions);
    CloseableHttpResponse response = httpClient.execute(request);
    try {
        if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
            throw ErrorResponseException.signaledInStatus(request, response);
        }
        return response.getEntity().getContent();
    } catch (Throwable e) {
        response.close();
        throw e;
    }
}
 

@Override
public void flush() {
  try {
    if (isRetry()) {
      //flushing failed and it should be retried.
      super.writeImpl(null);
      return;
    }

    if (batchRecords.isPresent() && batchRecords.get().size() > 0) {
      getLog().info("Flusing remaining subrequest of batch. # of subrequests: " + batchRecords.get().size());
      curRequest = Optional.of(newRequest(RequestBuilder.post().setUri(combineUrl(getCurServerHost(), batchResourcePath)),
                                              newPayloadForBatch()));
      super.writeImpl(null);
    }
  } catch (IOException e) {
    throw new RuntimeException(e);
  }
}
 

private <T> ServerQueryResponse<T> executeServerQueryRaw(
        @Nullable final QueryOptions<T> options,
        @Nullable final String wait,
        final ValueExtractor<T> valueExtractor,
        RequestBuilder requestBuilder
) throws IOException, NomadException {
    if (options != null) {
        if (options.getIndex() != null)
            requestBuilder.addParameter("index", options.getIndex().toString());
        if (wait != null)
            requestBuilder.addParameter("wait", wait);
        if (options.isAllowStale())
            requestBuilder.addParameter("stale", null);
    }
    return apiClient.execute(requestBuilder, new ServerQueryResponseAdapter<>(valueExtractor), options);
}
 

public static void fhirResourceDeletePurge(String resourceName)
    throws IOException, URISyntaxException {
  // String resourceName =
  //    String.format(
  //        FHIR_NAME, "project-id", "region-id", "dataset-id", "store-id", "fhir-id");

  // Initialize the client, which will be used to interact with the service.
  CloudHealthcare client = createClient();

  HttpClient httpClient = HttpClients.createDefault();
  String uri = String.format("%sv1/%s/$purge", client.getRootUrl(), resourceName);
  URIBuilder uriBuilder = new URIBuilder(uri).setParameter("access_token", getAccessToken());

  HttpUriRequest request =
      RequestBuilder.delete()
          .setUri(uriBuilder.build())
          .addHeader("Content-Type", "application/fhir+json")
          .addHeader("Accept-Charset", "utf-8")
          .addHeader("Accept", "application/fhir+json; charset=utf-8")
          .build();

  // Execute the request and process the results.
  HttpResponse response = httpClient.execute(request);
  HttpEntity responseEntity = response.getEntity();
  if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
    String errorMessage =
        String.format(
            "Exception purging FHIR resource: %s\n", response.getStatusLine().toString());
    System.err.print(errorMessage);
    responseEntity.writeTo(System.err);
    throw new RuntimeException(errorMessage);
  }
  System.out.println("FHIR resource history purged.");
  responseEntity.writeTo(System.out);
}
 

protected void setheaders(RequestBuilder rb, Map<String, String> headers) {
  // Add any defined headers
  if (headers.size() > 0) {
    for (HashMap.Entry<String, String> entry : headers.entrySet()) {
      rb.addHeader(entry.getKey(), entry.getValue());
    }
  }
}
 

/**
 * As in doTokenValidate(), validate that the token is correct. In this case we
 * can specify that the token has _just_ been retrieved so that we don't try to
 * retrieve it again if validate fails.
 *
 * @param newToken True if this is a brand new token and we shouldn't try to get
 *                 a new on 401.a
 * @throws HttpResponseException
 * @throws IOException
 * @throws OAuthException
 */
void doTokenValidate(Boolean newToken) throws HttpResponseException, IOException, OAuthException {
    if(this.accessToken == null) {
        this.doTokenRequest();
    } else {
        if (this.validateEndpoint != null) {
            log.debug("Validating access token at " + this.validateEndpoint);

            HttpUriRequest request = RequestBuilder.create("GET")
                    .setUri(this.validateEndpoint)
                    .setHeader(HttpHeaders.AUTHORIZATION, "Bearer " + this.accessToken)
                    .setHeader(HttpHeaders.ACCEPT, JSON_CONTENT_TYPE)
                    .build();

            HttpResponse response = this.httpClient.execute(request);

            if (response.getStatusLine().getStatusCode() == STATUS_SUCCESS) {
                JsonNode data = jsonParser.readTree(EntityUtils.toString(response.getEntity()));
                String clientId = data.get("client").asText();

                if (!this.clientId.equals(clientId)) {
                    throw new OAuthException("Token received for a client other than us.");
                }
            } else if (response.getStatusLine().getStatusCode() == STATUS_AUTHORIZATION_REQUIRED) {
                this.accessToken = null;

                if (newToken) {
                    throw new OAuthException("Newly acquired token is still not valid.");
                } else {
                    doTokenRequest();
                }
            } else {
                throw new HttpResponseException(response.getStatusLine().getStatusCode(), buildError(response));
            }
        } else {
            log.debug("No validate endpoint exists, skipping validation.");
        }
    }
}
 

@Override
public Optional<HttpUriRequest> onNewRecord(D record) {
  try {
    HttpUriRequest uriRequest = RequestBuilder.post()
        .addHeader(HttpHeaders.CONTENT_TYPE, ContentType.TEXT_PLAIN.getMimeType())
        .setUri(getCurServerHost())
        .setEntity(new StringEntity(record.toString(), ContentType.TEXT_PLAIN.toString()))
        .build();
    return Optional.of(uriRequest);
  } catch (Exception e) {
    throw new RuntimeException(e);
  }
}
 

private ZToken getRoleToken(AthenzDomain domain, String roleName) {
    URI uri = ztsUrl.resolve(String.format("domain/%s/token", domain.getName()));
    RequestBuilder requestBuilder = RequestBuilder.get(uri)
            .addHeader("Content-Type", "application/json");
    if (roleName != null) {
        requestBuilder.addParameter("role", roleName);
    }
    HttpUriRequest request = requestBuilder.build();
    return execute(request, response -> {
        RoleTokenResponseEntity roleTokenResponseEntity = readEntity(response, RoleTokenResponseEntity.class);
        return roleTokenResponseEntity.token;
    });
}
 

/**
 * Retrieve an access token with our client credentials.
 *
 * @throws IOException         When the HTTP request fails for some reason.
 * @throws HttpResponseException When a non 200 or 401 status code is returned.
 */
void doTokenRequest() throws HttpResponseException, OAuthException, IOException {
    this.accessToken = null;

    log.debug("Requesting access token from " + this.tokenEndpoint);

    List<NameValuePair> params = new ArrayList<>();
    params.add(new BasicNameValuePair(FIELD_GRANT_TYPE, this.grantType.name().toLowerCase()));

    HttpUriRequest request = RequestBuilder.create("POST")
            .setUri(this.tokenEndpoint)
            .setHeader(HttpHeaders.AUTHORIZATION, "Basic " + com.dtolabs.rundeck.core.utils.Base64.encode(this.clientId + ":" + this.clientSecret))
            .setHeader(HttpHeaders.ACCEPT, JSON_CONTENT_TYPE)
            .setHeader(HttpHeaders.CONTENT_TYPE, FORM_CONTENT_TYPE)
            .setEntity(new UrlEncodedFormEntity(params)).build();

    HttpResponse response = this.httpClient.execute(request);

    if(response.getStatusLine().getStatusCode() == STATUS_SUCCESS) {
        JsonNode data = jsonParser.readTree(EntityUtils.toString(response.getEntity()));
        this.accessToken = data.get(FIELD_ACCESS_TOKEN).asText();
    } else {
        throw new HttpResponseException(response.getStatusLine().getStatusCode(), buildError(response));
    }

    this.doTokenValidate(true);
}
 

@Override
public Identity getServiceIdentity(AthenzIdentity identity, String keyId, Pkcs10Csr csr) {
    URI uri = ztsUrl.resolve(String.format("instance/%s/%s/refresh", identity.getDomainName(), identity.getName()));
    HttpUriRequest request = RequestBuilder.post()
            .setUri(uri)
            .setEntity(toJsonStringEntity(new IdentityRefreshRequestEntity(csr, keyId)))
            .build();
    return execute(request, response -> {
        IdentityResponseEntity entity = readEntity(response, IdentityResponseEntity.class);
        return new Identity(entity.certificate(), entity.caCertificateBundle());
    });
}
 

@Test
public void testException() throws Exception {
    String url = "http://localhost:" + serverProperties.getPort() + "/more/get2?name=error";
    HttpClient httpClient = HttpClientBuilder.create().build();
    HttpUriRequest get = RequestBuilder.get(url)
            .addHeader(HTTP.CONTENT_TYPE, ContentType.APPLICATION_JSON.toString())
            .build();

    HttpResponse response = httpClient.execute(get);
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    response.getEntity().writeTo(bos);
    String result = new String(bos.toByteArray(), StandardCharsets.UTF_8);
    System.out.println(result);
    Assert.assertTrue(result.contains("error!"));
}
 

@Test
public final void givenConfigOnClient_whenRequestHasCustomContentType_thenCorrect() throws ClientProtocolException, IOException {
    final Header header = new BasicHeader(HttpHeaders.CONTENT_TYPE, "application/json");
    final List<Header> headers = Lists.newArrayList(header);
    client = HttpClients.custom().setDefaultHeaders(headers).build();
    final HttpUriRequest request = RequestBuilder.get().setUri(SAMPLE_URL).build();
    response = client.execute(request);
}
 

private RequestBuilder prepareWrite(
        final RequestBuilder builder,
        final URIBuilder uri,
        @Nullable final WriteOptions options
) {
    String region = apiClient.getConfig().getRegion();
    String namespace = apiClient.getConfig().getNamespace();
    String secretId = apiClient.getConfig().getAuthToken();

    if (options != null) {
        if (options.getRegion() != null)
            region = options.getRegion();
        if (options.getNamespace() != null)
            namespace = options.getNamespace();
        if (options.getSecretId() != null)
            secretId = options.getSecretId();
    }

    if (region != null)
        uri.addParameter("region", region);
    if (namespace != null)
        uri.addParameter("namespace", namespace);
    if (secretId != null)
        builder.addHeader("X-Nomad-Token", secretId);

    return builder.setUri(build(uri));
}
 

/**
 * Add payload to request. By default, payload is sent as application/json
 */
protected int addPayload(RequestBuilder builder, String payload) {
  if (payload == null || payload.length() == 0) {
    return 0;
  }


  builder.setHeader(HttpHeaders.CONTENT_TYPE, contentType.getMimeType());
  builder.setEntity(new StringEntity(payload, contentType));
  return payload.length();
}
 

@Override
public RequestBuilder handleHeaders(Map<String, Object> headers, RequestBuilder requestBuilder) {
	String authorization = (String) headers.get("Authorization");
	if (authorization != null && authorization.equals(ACCESS_TOKEN_REPLACEMENT_VALUE)) {
		headers.put("Authorization", oauth2.getAccessToken());
		LOGGER.info("Token injected into header.");
	}
	return super.handleHeaders(headers, requestBuilder);
}
 

public static void main(String[] argvs) throws Exception{
    File f1 = new File("src/test/resources/1.jpg");
    File f2 = new File("src/test/resources/2.jpg");

    try (CloseableHttpClient httpClient = HttpClients.createDefault()) {

        HttpEntity data = MultipartEntityBuilder.create()
                .setMode(HttpMultipartMode.RFC6532)
                .addBinaryBody("photo", f1, ContentType.DEFAULT_BINARY, f1.getName())
                .addBinaryBody("photo", f2, ContentType.DEFAULT_BINARY, f2.getName())
                .addTextBody("fileId", "110", ContentType.DEFAULT_BINARY)
                .build();

        HttpUriRequest request = RequestBuilder
                .post("http://127.0.0.1:8080/tvseries/10/photos")
                .setEntity(data)
                .build();

        ResponseHandler<String> responseHandler = new ResponseHandler<String>() {
            @Override
            public String handleResponse(HttpResponse response) throws ClientProtocolException, IOException {
                int status = response.getStatusLine().getStatusCode();
                System.out.println(status);
                if (status == 200) {
                    HttpEntity entity = response.getEntity();
                    return entity != null ? EntityUtils.toString(entity) : null;
                } else {
                    throw new ClientProtocolException("Unexpected response status: " + status);
                }
            }
        };
        String responseBody = httpClient.execute(request, responseHandler);
        System.out.println(responseBody);
    }
}
 

protected <T> T postRequest(String resourceUrl, RequestDto requestDto, Class<T> responseClass) throws EngineClientException {
  ByteArrayEntity serializedRequest = serializeRequest(requestDto);
  HttpUriRequest httpRequest = RequestBuilder.post(resourceUrl)
    .addHeader(HEADER_USER_AGENT)
    .addHeader(HEADER_CONTENT_TYPE_JSON)
    .setEntity(serializedRequest)
    .build();
  
  return executeRequest(httpRequest, responseClass);
}
 

protected void preExecute(RequestBuilder builder) {
    for (Map.Entry<String, List<String>> param : params.entrySet()) {
        for (String value : param.getValue()) {
            builder.addParameter(param.getKey(), value);
        }
    }
}
 

HttpUriRequest createHttpRequest() {
    final RequestBuilder builder = RequestBuilder.post(authorizationEndpoint);

    if (authorizeUsingParameters) {
        builder.addParameter("client_id", state.getClientId())
            .addParameter("client_secret", state.getClientSecret());
    }

    builder.addParameter("refresh_token", state.getRefreshToken())
        .addParameter("grant_type", "refresh_token");

    return builder.build();
}
 

/**
 * Exposed for testing.
 *
 * @param body The body to POST with.
 * @return A {@link HttpUriRequest} that is a POST.
 */
HttpUriRequest getPost(String body) {
    return RequestBuilder.post()
            .setUri(url)
            .setHeader(HttpHeaders.CONTENT_TYPE, APPLICATION_JSON.toString())
            .setEntity(new StringEntity(body, ContentType.DEFAULT_TEXT)).build();
}
 

/**
 * 通过code换取网页授权access_token
 *
 * @param appid  appid
 * @param secret secret
 * @param code   code
 * @return SnsToken
 */
public static SnsToken oauth2AccessToken(String appid, String secret, String code) {
    HttpUriRequest httpUriRequest = RequestBuilder.post()
            .setUri(BASE_URI + "/sns/oauth2/access_token")
            .addParameter("appid", appid)
            .addParameter("secret", secret)
            .addParameter("code", code)
            .addParameter("grant_type", "authorization_code")
            .build();
    return LocalHttpClient.executeJsonResult(httpUriRequest, SnsToken.class);
}
 

/**
 * 通过code换取网页授权access_token (第三方平台开发)
 *
 * @param appid                  appid
 * @param code                   code
 * @param component_appid        服务开发方的appid
 * @param component_access_token 服务开发方的access_token
 * @return SnsToken
 */
public static SnsToken oauth2ComponentAccessToken(String appid, String code, String component_appid, String component_access_token) {
    HttpUriRequest httpUriRequest = RequestBuilder.post()
            .setUri(BASE_URI + "/sns/oauth2/component/access_token")
            .addParameter("appid", appid)
            .addParameter("code", code)
            .addParameter("grant_type", "authorization_code")
            .addParameter("component_appid", component_appid)
            .addParameter("component_access_token", component_access_token)
            .build();
    return LocalHttpClient.executeJsonResult(httpUriRequest, SnsToken.class);
}
 

/**
 * 刷新access_token
 *
 * @param appid         appid
 * @param refresh_token refresh_token
 * @return SnsToken
 */
public static SnsToken oauth2RefreshToken(String appid, String refresh_token) {
    HttpUriRequest httpUriRequest = RequestBuilder.post()
            .setUri(BASE_URI + "/sns/oauth2/refresh_token")
            .addParameter("appid", appid)
            .addParameter("refresh_token", refresh_token)
            .addParameter("grant_type", "refresh_token")
            .build();
    return LocalHttpClient.executeJsonResult(httpUriRequest, SnsToken.class);
}