@Bean
public ConnectionKeepAliveStrategy connectionKeepAliveStrategy() {
  return (httpResponse, httpContext) -> {
    HeaderIterator headerIterator = httpResponse.headerIterator(HTTP.CONN_KEEP_ALIVE);
    HeaderElementIterator elementIterator = new BasicHeaderElementIterator(headerIterator);

    while (elementIterator.hasNext()) {
      HeaderElement element = elementIterator.nextElement();
      String param = element.getName();
      String value = element.getValue();
      if (value != null && param.equalsIgnoreCase("timeout")) {
        return Long.parseLong(value) * 1000; // convert to ms
      }
    }

    return DEFAULT_KEEP_ALIVE_TIME;
  };
}
 

public Set<String> getAllowedMethods(final HttpResponse response) {
    if (response == null) {
        throw new IllegalArgumentException("HTTP response may not be null");
    }

    HeaderIterator it = response.headerIterator("Allow");
    Set<String> methods = new HashSet<String>();
    while (it.hasNext()) {
        Header header = it.nextHeader();
        HeaderElement[] elements = header.getElements();
        for (HeaderElement element : elements) {
            methods.add(element.getName());
        }
    }
    return methods;
}
 

protected static void writeHeaders(final HeaderGroup headers, final OutputStream output) throws IOException {
	for (final HeaderIterator it = headers.iterator(); it.hasNext();) {
		final org.apache.http.Header header = it.nextHeader();
		Util.toOutputStream(BasicLineFormatter.formatHeader(header, null), output);
		output.write(ByteArraySessionOutputBuffer.CRLF);
	}
}
 

public static Set<String> keys(HeaderGroup hg) {
	Set<String> ret = new HashSet<>();
	for (HeaderIterator it = hg.iterator(); it.hasNext();) {
		Header header = it.nextHeader();
		ret.add(header.getName().toLowerCase());
	}
	return ret;
}
 

public static String toString(HttpResponse response) throws ParseException, IOException{
	StringBuilder str = new StringBuilder();
	str.append("statusCode:")
		.append(response.getStatusLine().getStatusCode())
		.append("\n");
	HeaderIterator headerIt = response.headerIterator();
	while(headerIt.hasNext()){
		Header header = headerIt.nextHeader();
		str.append(header).append("\n");
	}
	HttpEntity entity = response.getEntity();
	str.append(EntityUtils.toString(entity));
	return str.toString();
}
 

static void printResponse(HttpResponse response) throws ParseException, IOException{
	System.out.println("statusCode:"+response.getStatusLine().getStatusCode());
	HeaderIterator headerIt = response.headerIterator();
	while(headerIt.hasNext()){
		Header header = headerIt.nextHeader();
		System.out.println(header);
	}
	HttpEntity entity = response.getEntity();
	System.out.println(EntityUtils.toString(entity));
}
 

private void logRequest(HttpUriRequest httpRequest) {
	StringBuilder sb = new StringBuilder();

	// method
	sb.append(httpRequest.getMethod());
	sb.append(" ");

	// url
	sb.append(httpRequest.getURI());
	sb.append(" ");

	// headers, if any
	HeaderIterator iterator = httpRequest.headerIterator();
	if (iterator.hasNext()) {
		sb.append("Headers:[");

		Header header = iterator.nextHeader();
		sb.append(header.getName()).append("=").append(header.getValue());

		while (iterator.hasNext()) {
			header = iterator.nextHeader();
			sb.append(header.getName()).append("=").append(header.getValue());
			sb.append(";");
		}

		sb.append("] ");
	}

	//
	log.finest(sb.toString());
}
 

@Override
public HeaderIterator headerIterator() {
    throw new UnsupportedOperationException("Not supported yet.");
}
 

@Override
public HeaderIterator headerIterator(final String name) {
    throw new UnsupportedOperationException("Not supported yet.");
}
 

@Override
public HeaderIterator headerIterator() {
    return original.headerIterator();
}
 

@Override
public HeaderIterator headerIterator(final String name) {
    return original.headerIterator(name);
}
 

@Override
public HeaderIterator headerIterator() {
    return null;
}
 

@Override
public HeaderIterator headerIterator(String s) {
    return null;
}
 

@Override
public HeaderIterator headerIterator()
{
    return request.headerIterator();
}
 

@Override
public HeaderIterator headerIterator(String name)
{
    return request.headerIterator(name);
}
 

@Override
public HeaderIterator headerIterator()
{
    return implementation.headerIterator();
}
 

@Override
public HeaderIterator headerIterator(String name)
{
    return implementation.headerIterator(name);
}
 

public HeaderIterator headerIterator() {
    return original.headerIterator();
}
 

public HeaderIterator headerIterator(final String name) {
    return original.headerIterator(name);
}
 

@Override
public HeaderIterator headerIterator() {
    return httpResponse.headerIterator();
}
 

@Override
public HeaderIterator headerIterator(String name) {
    return httpResponse.headerIterator(name);
}
 

@Override
public ProtocolResponse handleResponse(HttpResponse response)
        throws IOException {

    StatusLine statusLine = response.getStatusLine();
    int status = statusLine.getStatusCode();

    StringBuilder verbatim = new StringBuilder();
    if (storeHTTPHeaders) {
        verbatim.append(statusLine.toString()).append("\r\n");
    }

    Metadata metadata = new Metadata();
    HeaderIterator iter = response.headerIterator();
    while (iter.hasNext()) {
        Header header = iter.nextHeader();
        if (storeHTTPHeaders) {
            verbatim.append(header.toString()).append("\r\n");
        }
        metadata.addValue(header.getName().toLowerCase(Locale.ROOT),
                header.getValue());
    }

    MutableBoolean trimmed = new MutableBoolean();

    byte[] bytes = new byte[] {};

    if (!Status.REDIRECTION.equals(Status.fromHTTPCode(status))) {
        bytes = HttpProtocol.toByteArray(response.getEntity(), maxContent,
                trimmed);
        if (trimmed.booleanValue()) {
            metadata.setValue(ProtocolResponse.TRIMMED_RESPONSE_KEY, "true");
            LOG.warn("HTTP content trimmed to {}", bytes.length);
        }
    }

    if (storeHTTPHeaders) {
        verbatim.append("\r\n");
        metadata.setValue(ProtocolResponse.RESPONSE_HEADERS_KEY,
                verbatim.toString());
    }

    return new ProtocolResponse(bytes, status, metadata);
}
 

@Override
public HeaderIterator headerIterator() {
	return this.headergroup.iterator();
}
 

@Override
public HeaderIterator headerIterator(String name) {
	return this.headergroup.iterator(name);
}