org.apache.http.HttpHost Java Examples

private void startRestClient() {
    try {
        HttpHost[] hosts = new HttpHost[] {
                // new HttpHost("10.132.161.173", 30002, "http")
                new HttpHost("127.0.0.1", 9200, "http") };
        client = RestClient.builder(hosts).setRequestConfigCallback(new RestClientBuilder.RequestConfigCallback() {
            @Override
            public RequestConfig.Builder customizeRequestConfig(RequestConfig.Builder requestConfigBuilder) {
                return requestConfigBuilder.setConnectTimeout(2000).setSocketTimeout(10000);
            }
        }).setMaxRetryTimeoutMillis(10000).setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
            @Override
            public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
                return httpClientBuilder.setMaxConnPerRoute(100).setMaxConnTotal(200);
                // return httpClientBuilder
                // .setDefaultIOReactorConfig(IOReactorConfig.custom().setIoThreadCount(1).build());
            }
        }).build();
    } catch (Exception e) {
        LOG.error(e.getMessage(), e.fillInStackTrace());
    }
}
 

@Override
public void process(HttpRequest request, HttpContext context) throws HttpException, IOException {
    AuthState authState = (AuthState) context.getAttribute(ClientContext.TARGET_AUTH_STATE);
    Credentials creds;
    
    if (authState.getAuthScheme() == null) {
        AuthScheme authScheme = (AuthScheme) context.getAttribute("preemptive-auth");
        CredentialsProvider credsProvider =
                (CredentialsProvider) context.getAttribute(ClientContext.CREDS_PROVIDER);
        HttpHost targetHost =
                (HttpHost) context.getAttribute(ExecutionContext.HTTP_TARGET_HOST);
        if (authScheme != null) {
            creds =
                    credsProvider.getCredentials(new AuthScope(
                            targetHost.getHostName(),
                            targetHost.getPort()));
            if (creds == null) {
                throw new HttpException("No credentials for preemptive authentication");
            }
            authState.update(authScheme, creds);
        }
    }
}
 

public static HttpDispatcher getInstance(String uri, Credentials credentials) {

        HttpDispatcher dispatcher = new HttpDispatcher(new HttpHost(uri),
                new BasicHttpContext());

        CredentialsProvider credsProvider = new BasicCredentialsProvider();

        AuthScope authScope = new AuthScope(
                dispatcher.host.getHostName(),
                dispatcher.host.getPort());

        credsProvider.setCredentials(authScope, credentials);

        ((DefaultHttpClient) dispatcher.client).getCredentialsProvider().setCredentials(
                authScope, credentials);
        return dispatcher;
    }
 

private static RestClient connect(Map<String, Integer> coordinates,
    Map<String, String> userConfig) {
    Objects.requireNonNull(coordinates, "coordinates");
    Preconditions.checkArgument(! coordinates.isEmpty(), "no ES coordinates specified");
    final Set<HttpHost> set = new LinkedHashSet<>();
    for (Map.Entry<String, Integer> entry : coordinates.entrySet()) {
        set.add(new HttpHost(entry.getKey(), entry.getValue()));
    }

    final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
    credentialsProvider.setCredentials(AuthScope.ANY,
        new UsernamePasswordCredentials(userConfig.getOrDefault("esUser", "none"),
            userConfig.getOrDefault("esPass", "none")));

    return RestClient.builder(set.toArray(new HttpHost[0]))
        .setHttpClientConfigCallback(httpClientBuilder ->
            httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider))
        .setMaxRetryTimeoutMillis(300000).build();
}
 

protected void setUsernameAndPasswordForUrl(String username, String password, String url) {

		if (username != null && password != null) {
			logger.debug("Setting username '{}' and password for server at {}.", username, url);
			java.net.URI requestURI = java.net.URI.create(url);
			String host = requestURI.getHost();
			int port = requestURI.getPort();
			AuthScope scope = new AuthScope(host, port);
			UsernamePasswordCredentials cred = new UsernamePasswordCredentials(username, password);
			CredentialsProvider credsProvider = new BasicCredentialsProvider();
			credsProvider.setCredentials(scope, cred);
			httpContext.setCredentialsProvider(credsProvider);
			AuthCache authCache = new BasicAuthCache();
			BasicScheme basicAuth = new BasicScheme();
			HttpHost httpHost = new HttpHost(requestURI.getHost(), requestURI.getPort(), requestURI.getScheme());
			authCache.put(httpHost, basicAuth);
			httpContext.setAuthCache(authCache);
		} else {
			httpContext.removeAttribute(HttpClientContext.AUTH_CACHE);
			httpContext.removeAttribute(HttpClientContext.CREDS_PROVIDER);
		}
	}
 

@Test
public void test4xxSync() throws Exception {
	proxy = new SimpleFixedHttpProxy();
	URI robotsURL = URI.create("http://foo.bor/robots.txt");
	proxy.addNon200(robotsURL, "HTTP/1.1 404 Not Found\n",
			"# goodguy can do anything\n" +
			"User-agent: goodguy\n" +
			"Disallow:\n\n" +
			"# every other guy can do nothing\n" +
			"User-agent: *\n" +
			"Disallow: /\n"
	);
	proxy.start();

	HttpClient httpClient = FetchDataTest.getHttpClient(new HttpHost("localhost", proxy.port()), false);

	FetchData fetchData = new FetchData(Helpers.getTestConfiguration(this));
	fetchData.fetch(robotsURL, httpClient, null, null, true);
	assertEquals(0, URLRespectsRobots.parseRobotsResponse(fetchData, "goodGuy").length);
	assertEquals(0, URLRespectsRobots.parseRobotsResponse(fetchData, "goodGuy foo").length);
}
 

public <Res> void asyncSendRequest(
    RequestMessage request,
    ExecutionContext context,
    ResponseConsumer<Res> consumer,
    FutureCallback<Res> callback,
    TraceLogger traceLogger)
{
    Preconditions.checkNotNull(request);
    Preconditions.checkNotNull(context);

    addExtraHeaders(request);

    context.getSigner().sign(request);
    handleRequest(request, context.getResquestHandlers());
    consumer.setContext(context);
    final HttpHost target = request.getActionUri().getHost();
    if (LOG.isDebugEnabled()) {
        LOG.debug(TRACE_ID_WITH_COLON + traceLogger.getTraceId() + DELIMITER + INTO_HTTP_ASYNC_CLIENT);
    }
    traceLogger.addEventTime(INTO_HTTP_ASYNC_CLIENT, System.currentTimeMillis());
    httpClient.execute(
        new OTSRequestProducer(target, request.getRequest(), traceLogger),
        consumer, callback);
}
 

@Test
public void NullInterceptorReturnTest() throws InterruptedException, TimeoutException, IOException, UnirestException {
    List<InterceptedMessage> messages = new ArrayList<>();

    MitmproxyJava proxy = new MitmproxyJava(MITMDUMP_PATH, (InterceptedMessage m) -> {
        messages.add(m);
        return null;
    }, 8087, null);
    proxy.start();

    Unirest.setProxy(new HttpHost("localhost", 8087));
    Unirest.get("http://appium.io").header("myTestHeader", "myTestValue").asString();

    proxy.stop();

    assertThat(messages).isNotEmpty();

    final InterceptedMessage firstMessage = messages.get(0);

    assertThat(firstMessage.getRequest().getUrl()).startsWith("http://appium.io");
    assertThat(firstMessage.getRequest().getHeaders()).containsOnlyOnce(new String[]{"myTestHeader", "myTestValue"});
    assertThat(firstMessage.getResponse().getStatusCode()).isEqualTo(200);
}
 

protected void rewriteRequestURI(
        final RequestWrapper request,
        final HttpRoute route) throws ProtocolException {
    try {

        URI uri = request.getURI();
        if (route.getProxyHost() != null && !route.isTunnelled()) {
            // Make sure the request URI is absolute
            if (!uri.isAbsolute()) {
                HttpHost target = route.getTargetHost();
                uri = URIUtils.rewriteURI(uri, target);
                request.setURI(uri);
            }
        } else {
            // Make sure the request URI is relative
            if (uri.isAbsolute()) {
                uri = URIUtils.rewriteURI(uri, null);
                request.setURI(uri);
            }
        }

    } catch (URISyntaxException ex) {
        throw new ProtocolException("Invalid URI: "
        		+ request.getRequestLine().getUri(), ex);
    }
}
 

@Override
public Socket connectSocket(final int connectTimeout,
                            final Socket socket,
                            final HttpHost host,
                            final InetSocketAddress remoteAddress,
                            final InetSocketAddress localAddress,
                            final HttpContext context) throws IOException {
  if (!(socket instanceof UnixSocket)) {
    throw new AssertionError("Unexpected socket: " + socket);
  }

  socket.setSoTimeout(connectTimeout);
  try {
    socket.getChannel().connect(new UnixSocketAddress(socketFile));
  } catch (SocketTimeoutException e) {
    throw new ConnectTimeoutException(e, null, remoteAddress.getAddress());
  }
  return socket;
}
 

/**
 * Creates a HttpClientBuilder with the default settings of GERBIL.
 * 
 * @return a HttpClientBuilder with the default settings of GERBIL.
 */
public HttpClientBuilder generateHttpClientBuilder() {
    HttpClientBuilder builder = HttpClientBuilder.create();
    builder.setUserAgent(userAgent);

    String proxyHost = GerbilConfiguration.getInstance().getString(PROXY_HOST_KEY);
    int proxyPort = GerbilConfiguration.getInstance().getInt(PROXY_PORT_KEY, DEFAULT_PROXY_PORT);

    if (proxyHost != null) {
        HttpHost proxy = new HttpHost(proxyHost, proxyPort);
        DefaultProxyRoutePlanner routePlanner = new DefaultProxyRoutePlanner(proxy);
        builder.setRoutePlanner(routePlanner);
    }
    // Use a redirect strategy that allows the "direct redirect" of POST requests
    // without creating a completely new request
    builder.setRedirectStrategy(new SimpleRedirectStrategy()).build();

    return builder;
}
 

@Test
public void testCreateSecurityProfile() throws Exception {
    final CloseableHttpResponse response = mock(CloseableHttpResponse.class);
    when(response.getStatusLine()).thenReturn(HTTP_201_REPSONSE);
    when(response.getEntity()).thenReturn(new StringEntity(SEC_PROFILE_JSON_RESPONSE));
    final CloseableHttpClient httpClient = spy(HttpClientHelper.createHttpClient(2));
    doReturn(response).when(httpClient).execute(any(HttpHost.class), any(HttpRequest.class), any(HttpClientContext.class));
    final NiciraNvpApi api = buildApi(httpClient);

    final SecurityProfile actualSecProfile = api.createSecurityProfile(new SecurityProfile());

    assertThat("Wrong Uuid in the newly created SecurityProfile", actualSecProfile, hasProperty("uuid", equalTo(UUID)));
    assertThat("Wrong Href in the newly created SecurityProfile", actualSecProfile, hasProperty("href", equalTo(HREF)));
    assertThat("Wrong Schema in the newly created SecurityProfile", actualSecProfile, hasProperty("schema", equalTo(SCHEMA)));
    verify(response, times(1)).close();
    verify(httpClient).execute(any(HttpHost.class), HttpUriRequestMethodMatcher.aMethod("POST"), any(HttpClientContext.class));
    verify(httpClient).execute(any(HttpHost.class), HttpUriRequestPathMatcher.aPath(NiciraConstants.SEC_PROFILE_URI_PREFIX), any(HttpClientContext.class));
}
 

private boolean alreadyHaveNewerCacheEntry(HttpHost target,
		HttpRequest request, HttpResponse backendResponse)
		throws IOException {
	HttpCacheEntry existing = null;
	try {
		existing = responseCache.getCacheEntry(target, request);
	} catch (IOException ioe) {
		// nop
	}
	if (existing == null)
		return false;
	Header entryDateHeader = existing.getFirstHeader("Date");
	if (entryDateHeader == null)
		return false;
	Header responseDateHeader = backendResponse.getFirstHeader("Date");
	if (responseDateHeader == null)
		return false;
	try {
		Date entryDate = DateUtils.parseDate(entryDateHeader.getValue());
		Date responseDate = DateUtils.parseDate(responseDateHeader
				.getValue());
		return responseDate.before(entryDate);
	} catch (DateParseException e) {
	}
	return false;
}
 

@RequestMapping("/_search")
public ResponseEntity<InputStreamResource> search(@RequestParam("q") String query, @RequestHeader(value = "X-ElasticSearch-Host", required = false) String elasticSearchHost) throws IOException {
    HttpHost httpHost = null;
    Collection<Task> tasks = scheduler.getTasks().values();
    Stream<HttpHost> httpHostStream = tasks.stream().map(task -> new HttpHost(task.getHostname(), task.getClientAddress().getPort()));

    if (elasticSearchHost != null) {
        httpHost = httpHostStream.filter(host -> host.toHostString().equalsIgnoreCase(elasticSearchHost)).findAny().get();
    } else {
        httpHost = httpHostStream.skip(RandomUtils.nextInt(0, tasks.size())).findAny().get();
    }

    HttpResponse esSearchResponse = httpClient.execute(httpHost, new HttpGet("/_search?q=" + URLEncoder.encode(query, "UTF-8")));

    InputStreamResource inputStreamResource = new InputStreamResource(esSearchResponse.getEntity().getContent());

    return ResponseEntity.ok()
            .contentLength(esSearchResponse.getEntity().getContentLength())
            .contentType(MediaType.APPLICATION_JSON)
            .header("X-ElasticSearch-host", httpHost.toHostString())
            .body(inputStreamResource);
}
 

private WebServiceClient(Builder builder) {
    this.host = builder.host;
    this.port = builder.port;
    this.useHttps = builder.useHttps;
    this.locales = builder.locales;
    this.licenseKey = builder.licenseKey;
    this.accountId = builder.accountId;

    mapper = new ObjectMapper();
    mapper.disable(MapperFeature.CAN_OVERRIDE_ACCESS_MODIFIERS);
    mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);

    RequestConfig.Builder configBuilder = RequestConfig.custom()
            .setConnectTimeout(builder.connectTimeout)
            .setSocketTimeout(builder.readTimeout);

    if (builder.proxy != null && builder.proxy != Proxy.NO_PROXY) {
        InetSocketAddress address = (InetSocketAddress) builder.proxy.address();
        HttpHost proxyHost = new HttpHost(address.getHostName(), address.getPort());
        configBuilder.setProxy(proxyHost);
    }

    RequestConfig config = configBuilder.build();
    httpClient =
            HttpClientBuilder.create()
                    .setUserAgent(userAgent())
                    .setDefaultRequestConfig(config).build();
}
 

@PostConstruct
public void reload() {
    var configuration = workerProperties.getAudio().getYandexProxy();
    if (StringUtils.isNotEmpty(configuration.getHost())) {
        configureApiBuilder(builder -> {
            builder.setProxy(new HttpHost(configuration.getHost(), configuration.getPort()));
        });
    }
}
 

@Override
protected HttpHost determineProxy(
    final HttpHost target,
    final HttpRequest request,
    final HttpContext context) throws HttpException {

    return doesTargetMatchNonProxyHosts(target) ? null : proxy;
}
 

private static int http(HttpUriRequest request) throws Exception {
    CloseableHttpClient client = HttpClients.custom()
            .setProxy(new HttpHost("localhost", proxy.getPort()))
            .build();
    HttpResponse response = client.execute(request);
    InputStream is = response.getEntity().getContent();
    String responseString = FileUtils.toString(is);
    logger.debug("response: {}", responseString);
    return response.getStatusLine().getStatusCode();
}
 

public static List<HttpHost> parseClusterNodes(String protocol, String nodes) {
    List<HttpHost> httpHosts = new LinkedList<>();
    log.info("elasticsearch cluster nodes: {}", nodes);
    List<String> nodesSplit = Splitter.on(",").omitEmptyStrings().splitToList(nodes);

    for (String node : nodesSplit) {
        String host = node.split(":")[0];
        String port = node.split(":")[1];
        httpHosts.add(new HttpHost(host, Integer.parseInt(port), protocol));
    }

    return httpHosts;
}
 

private HttpClientBuilder configureProxy(HttpClientBuilder builder) {
    final String proxy = config.get("proxy");
    if (isNotBlank(proxy)) {
        final int proxyPort = Integer.parseInt(config.get("proxyPort"));
        DefaultProxyRoutePlanner routePlanner = new DefaultProxyRoutePlanner(new HttpHost(proxy, proxyPort));
        builder.setRoutePlanner(routePlanner);
    }
    return builder;
}
 

@Test
public void testConnectSocket() throws Exception {
  final NamedPipeSocket npipeSocket = mock(NamedPipeSocket.class);
  when(npipeSocket.getChannel()).thenReturn(mock(SocketChannel.class));
  final Socket socket = sut.connectSocket(10, npipeSocket, HttpHost.create("http://foo.com"),
      mock(InetSocketAddress.class), mock(InetSocketAddress.class), mock(HttpContext.class));
  assertThat(socket, IsInstanceOf.instanceOf(NamedPipeSocket.class));
  assertThat((NamedPipeSocket) socket, equalTo(npipeSocket));
}
 

private void setupMockClientResponse(int statusCode, String statusReason, String responseBody) throws IOException {
  StatusLine statusLine = mock(StatusLine.class);
  when(statusLine.getStatusCode()).thenReturn(statusCode);
  when(statusLine.getReasonPhrase()).thenReturn(statusReason);

  HttpEntity entity = mock(HttpEntity.class);
  when(entity.getContent()).thenReturn(new ReaderInputStream(new StringReader(responseBody)));

  CloseableHttpResponse response = mock(CloseableHttpResponse.class);
  when(response.getStatusLine()).thenReturn(statusLine);
  when(response.getEntity()).thenReturn(entity);

  when(mockClient.execute(any(HttpHost.class), any(HttpGet.class))).thenReturn(response);
}
 

@Override
public synchronized void start() {
    logger.info("start elasticsearch sink......");
    HttpHost[] httpHosts = new HttpHost[serverAddresses.length];
    for (int i = 0; i < serverAddresses.length; i++) {
        String[] hostPort = serverAddresses[i].trim().split(":");
        String host = hostPort[0].trim();
        int port = hostPort.length == 2 ? Integer.parseInt(hostPort[1].trim())
                : DEFAULT_PORT;
        logger.info("elasticsearch host:{},port:{}", host, port);
        httpHosts[i] = new HttpHost(host, port, "http");
    }

    RestClientBuilder builder = RestClient.builder(httpHosts);
    if (StringUtils.isNotBlank(serverUser) || StringUtils.isNotBlank(serverPassword)) {
        final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(serverUser, serverPassword));
        builder.setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
            @Override
            public HttpAsyncClientBuilder customizeHttpClient(
                    HttpAsyncClientBuilder httpClientBuilder) {
                return httpClientBuilder
                        .setDefaultCredentialsProvider(credentialsProvider);
            }
        });
    }
    client = new RestHighLevelClient(builder);
    sinkCounter.start();
    super.start();
}
 

public HttpClientContext build() {
    if (StringUtils.isEmpty(preemptiveAuth)) {
        preemptiveAuth = "true";
    }
    HttpClientContext context = HttpClientContext.create();
    if (authTypes.size() == 1 && Boolean.parseBoolean(preemptiveAuth) && !authTypes.contains(AuthTypes.ANONYMOUS)) {
        AuthCache authCache = new BasicAuthCache();
        authCache.put(new HttpHost(uri.getHost(), uri.getPort(), uri.getScheme()),
                authSchemeLookup.lookup(authTypes.iterator().next()).create(context));
        context.setCredentialsProvider(credentialsProvider);
        context.setAuthCache(authCache);
    }
    return context;
}
 

private static DefaultSchemePortResolver prepareSchemePortResolver() {
    return new DefaultSchemePortResolver() {
        @Override
        public int resolve(HttpHost host) throws UnsupportedSchemeException {
            if (host.getHostName().equalsIgnoreCase("sushi-shop.test")) {
                return 9876;
            } else {
                return super.resolve(host);
            }
        }
    };
}
 

@Before
public void init() {
    //1.连接rest接口
    HttpHost http = new HttpHost("127.0.0.1", 9200, "http");
    RestClientBuilder builder = RestClient.builder(http);//rest构建器
    restHighLevelClient = new
            RestHighLevelClient(builder);//高级客户端对象
    //2.封装查询请求
    searchRequest = new SearchRequest("sku");
    searchRequest.types("doc"); //设置查询的类型
}
 

public StatefulHttpClient(int sessionTimeOut, int requestTimeOut, HttpHost proxy) {
    initCookieStore();
    this.sessionTimeOut = sessionTimeOut;
    this.requestTimeOut = requestTimeOut;
    RequestConfig.Builder requestConfigBuilder = RequestConfig.custom()
            .setConnectTimeout(this.requestTimeOut * 1000).setSocketTimeout(this.requestTimeOut * 1000);
    if (proxy != null) {
        requestConfigBuilder.setProxy(proxy);
    }
    httpclient = HttpClientBuilder.create()
            .setDefaultRequestConfig(requestConfigBuilder.build()).build();
}
 

private void complementException(
    Throwable exception,
    HttpHost host,
    InetSocketAddress localAddress,
    InetSocketAddress remoteAddress,
    int connectTimeout,
    InetAddress[] addresses,
    int currentIndex
) {
  StringBuilder builder = new StringBuilder();
  builder.append("Encountered when opening a connection with the following details:");

  appendField(builder, "host", host);
  appendField(builder, "localAddress", localAddress);
  appendField(builder, "remoteAddress", remoteAddress);

  builder.append("\n  connectTimeout: ").append(connectTimeout);

  appendAddresses(builder, "triedAddresses", addresses, index ->
      index <= currentIndex && addressTypesMatch(localAddress, addresses[index])
  );

  appendAddresses(builder, "untriedAddresses", addresses, index ->
      index > currentIndex && addressTypesMatch(localAddress, addresses[index])
  );

  appendAddresses(builder, "unsuitableAddresses", addresses, index ->
      !addressTypesMatch(localAddress, addresses[index])
  );

  exception.addSuppressed(new AdditionalDetails(builder.toString()));
}
 

public static HttpHost[] parse(String host) {
    String[] values = Strings.split(host, ',');
    HttpHost[] hosts = new HttpHost[values.length];
    for (int i = 0; i < values.length; i++) {
        String value = values[i].strip();
        hosts[i] = new HttpHost(value, 9200);
    }
    return hosts;
}
 

public void testJson() {
    try {
        CloseableHttpClient httpClient = HttpClients.createDefault();

        HttpHost target = new HttpHost("120.27.182.142", 80, HttpHost.DEFAULT_SCHEME_NAME);
        HttpRequestBase request = new HttpPost(target.toURI() + "/mry/usr/qryusr");
        request.addHeader("Api-Token", "76067");

        String data = "";
        // ((HttpPost) request).setEntity(new StringEntity(data,
        // ContentType.create("text/plain", "utf-8")));

        CloseableHttpResponse resp = httpClient.execute(request);
        HttpEntity entity = resp.getEntity();

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        InputStream is = entity.getContent();
        byte[] buf = new byte[32];
        int len = 0;
        while ((len = is.read(buf)) != -1) {
            baos.write(buf, 0, len);
        }
        String str = new String(baos.toByteArray(), "utf-8");
        for (byte b : baos.toByteArray()) {
            System.out.print(b);
            System.out.print(' ');
        }

        Reader reader = new InputStreamReader(entity.getContent(), ContentType.getOrDefault(entity).getCharset());
        // TODO decode by mime-type

        Map<String, String> rspMap = GSON.fromJson(reader, HashMap.class);
        String usrJson = rspMap.get("usr");
        Map<String, Object> usr = GSON.fromJson(usrJson, HashMap.class);
        System.out.println(usr.get("id").toString() + usr.get("name"));
    } catch (Exception e) {
        e.printStackTrace();
    }
}