AsyncHttpClient client = new AsyncHttpClient(); WebSocketListener listener = new Listener(); WebSocketUpgradeHandler handler = new WebSocketUpgradeHandler.Builder() socket = client.prepareGet(url).execute(handler).get(); LOG.info("Successfully connected to {}.", url); } catch (ExecutionException e) { client.close();
private boolean doAuthenticate(final UsernamePasswordToken upToken) { final BoundRequestBuilder builder = httpClient.preparePost(securityConfig.getShiroOktaUrl() + "/api/v1/authn"); try { final ImmutableMap<String, String> body = ImmutableMap.<String, String>of("username", upToken.getUsername(), "password", String.valueOf(upToken.getPassword())); builder.setBody(mapper.writeValueAsString(body)); } catch (final JsonProcessingException e) { log.warn("Error while generating Okta payload"); throw new AuthenticationException(e); builder.addHeader("Authorization", "SSWS " + securityConfig.getShiroOktaAPIToken()); builder.addHeader("Content-Type", "application/json; charset=UTF-8"); final Response response; try { response = futureStatus.get(DEFAULT_TIMEOUT_SECS, TimeUnit.SECONDS); } catch (final TimeoutException toe) { log.warn("Timeout while connecting to Okta");
grizzlyClient.executeRequest(connectorRequest, new AsyncHandler<Void>() { private volatile HttpResponseStatus status = null;
final int DEFAULT_TIMEOUT = 20 * 1000; AsyncHttpClient aClient = new AsyncHttpClient(); aClient.setTimeout(DEFAULT_TIMEOUT); //... continue as normal
static CompletableFuture<Integer> AccessTheWebAsync(){ try(AsyncHttpClient asyncHttpClient = new AsyncHttpClient()){ Future<Response> f = asyncHttpClient .prepareGet("https://msdn.microsoft.com") .execute(); return CompletableFuture.supplyAsync( () -> return f.get().getResponseBody().length()); } }
AsyncHttpClient client = new AsyncHttpClient(); client.get("http://www.google.com", new AsyncHttpResponseHandler() { @Override public void onStart() { // Called before a request is started } @Override public void onSuccess(int statusCode, Header[] headers, byte[] response) { // Called when response HTTP status is "200 OK" } @Override public void onFailure(int statusCode, Header[] headers, byte[] errorResponse, Throwable e) { // Called when response HTTP status is "4XX" (for example, 401, 403, 404) } @Override public void onRetry(int retryNo) { // Called when request is retried } });
AsyncHttpClient client = new AsyncHttpClient(); client.get("http://mwesly.com/test", null, new JsonHttpResponseHandler() { @Override public void onSuccess(JSONObject json) { // do something with the json int value = json.getInt("value"); } });
private Response doGetRequest(final String path) { final BoundRequestBuilder builder = httpClient.prepareGet(securityConfig.getShiroOktaUrl() + path); builder.addHeader("Authorization", "SSWS " + securityConfig.getShiroOktaAPIToken()); builder.addHeader("Content-Type", "application/json; charset=UTF-8"); final Response response; try { final ListenableFuture<Response> futureStatus = builder.execute(new AsyncCompletionHandler<Response>() { @Override public Response onCompleted(final Response response) throws Exception { return response; } }); response = futureStatus.get(DEFAULT_TIMEOUT_SECS, TimeUnit.SECONDS); } catch (final TimeoutException toe) { log.warn("Timeout while connecting to Okta"); throw new AuthorizationException(toe); } catch (final Exception e) { log.warn("Error while connecting to Okta"); throw new AuthorizationException(e); } return response; }
private static AsyncHttpClient client = new AsyncHttpClient();
public static void main(String[] args) { SecureRandom secureRandom = new SecureRandom(); SSLContext sslContext = null; try { sslContext = SSLContext.getInstance("TLS"); sslContext.init(null, null, secureRandom); } catch (Exception e) { e.printStackTrace(); } AsyncHttpClientConfig config = new AsyncHttpClientConfig.Builder() .setConnectTimeout(5000) .setSSLContext(sslContext).build(); AsyncHttpClient client = new AsyncHttpClient(new GrizzlyAsyncHttpProvider(config), config); long start = System.currentTimeMillis(); try { client.executeRequest(client.prepareGet("http://www.google.com").build()).get(); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } LOGGER.debug("COMPLETE: " + (System.currentTimeMillis() - start) + "ms"); } }
if (resultCode == Activity.RESULT_OK) { //blah blah blah all the code that decodes and adds it to the listview AsyncHttpClient client = new AsyncHttpClient(); RequestParams params = new RequestParams(); params.put("qrcode", "XXXXXXXXXXXXX"); client.post("myserver.com/API/addqr", params, new JsonHttpResponseHandler() { public void onSuccess(int statusCode, Header[] headers, JSONObject response) { //do something with the response, if there is one. } }); }
@Test(groups = { "standalone", "default_provider" }) public void testPutEmptyBody() throws Throwable { try (AsyncHttpClient client = getAsyncHttpClient(null)) { Response response = client.preparePut(getTargetUrl()).setBody("String").execute().get(); assertNotNull(response); assertEquals(response.getStatusCode(), 204); assertEquals(response.getResponseBody(), ""); assertTrue(response.getResponseBodyAsStream() instanceof InputStream); assertEquals(response.getResponseBodyAsStream().read(), -1); } } }
switch (request.getMethod().toUpperCase()) { case "POST": requestBuilder = httpClient.preparePost(url); break; case "PUT": requestBuilder = httpClient.preparePut(url); break; case "DELETE": requestBuilder = httpClient.prepareDelete(url); break; default: requestBuilder.setBody(objectMapper.writeValueAsBytes(body)); LOG.trace("Added body {} to reqeust", body); Request httpRequest = requestBuilder.build(); response = httpClient.executeRequest(httpRequest).get(); } catch (IOException|ExecutionException|InterruptedException e) { LOG.error("Could not proxy request {} to leader", e);
@Override public void close() { grizzlyClient.close(); }
private LoadBalancerUpdateHolder sendRequest(LoadBalancerRequestId loadBalancerRequestId, Request request, BaragonRequestState onFailure) { try { LOG.trace("Sending LB {} request for {} to {}", request.getMethod(), loadBalancerRequestId, request.getUrl()); ListenableFuture<Response> future = httpClient.executeRequest(request); Response response = future.get(loadBalancerTimeoutMillis, TimeUnit.MILLISECONDS); LOG.trace("LB {} request {} returned with code {}", request.getMethod(), loadBalancerRequestId, response.getStatusCode()); if (response.getStatusCode() == 504) { return new LoadBalancerUpdateHolder(BaragonRequestState.UNKNOWN, Optional.of(String.format("LB %s request %s timed out", request.getMethod(), loadBalancerRequestId))); } else if (!JavaUtils.isHttpSuccess(response.getStatusCode())) { return new LoadBalancerUpdateHolder(onFailure, Optional.of(String.format("Response status code %s", response.getStatusCode()))); } BaragonResponse lbResponse = readResponse(response); return new LoadBalancerUpdateHolder(lbResponse.getLoadBalancerState(), lbResponse.getMessage()); } catch (TimeoutException te) { LOG.trace("LB {} request {} timed out after waiting {}", request.getMethod(), loadBalancerRequestId, JavaUtils.durationFromMillis(loadBalancerTimeoutMillis)); return new LoadBalancerUpdateHolder(BaragonRequestState.UNKNOWN, Optional.of(String.format("Timed out after %s", JavaUtils.durationFromMillis(loadBalancerTimeoutMillis)))); } catch (Throwable t) { LOG.error("LB {} request {} to {} threw error", request.getMethod(), loadBalancerRequestId, request.getUrl(), t); return new LoadBalancerUpdateHolder(BaragonRequestState.UNKNOWN, Optional.of(String.format("Exception %s - %s", t.getClass().getSimpleName(), t.getMessage()))); } }
builder = client.prepareGet(requestUrl); break; case POST: builder = client.preparePost(requestUrl); break; case PUT: builder = client.preparePut(requestUrl); break; case HEAD: builder = client.prepareHead(requestUrl); break; case OPTIONS: builder = client.prepareOptions(requestUrl); break; case DELETE: builder = client.prepareDelete(requestUrl); break; default: builder.setBody(postData); String charset = ""; if (null!=this.httpHeaderMap) { builder.setBodyEncoding(charset);
@Test(groups = { "standalone", "default_provider" }) public void asyncHttpClientConfigBeanTest() throws Exception { try (AsyncHttpClient client = getAsyncHttpClient(new AsyncHttpClientConfigBean().setUserAgent("test"))) { AsyncHttpClient.BoundRequestBuilder builder = client.prepareGet(getTargetUrl()); Response r = client.executeRequest(builder.build()).get(); assertEquals(200, r.getStatusCode()); } }
AsyncHttpClient client = new AsyncHttpClient(); RequestParams params = new RequestParams(); params.put("q", "google"); client.post("http://google.com", params, new AsyncHttpResponseHandler(){ public void onSuccess(String arg0) { Log.d("TAG", "Success"); }; public void onFailure(Throwable arg0, String arg1) { Log.d("TAG", "Failure"); }; });
@Override public Future<BrokerResponse> executeQueryAsync(String brokerAddress, final String query) { try { ObjectNode json = JsonNodeFactory.instance.objectNode(); json.put("pql", query); final String url = "http://" + brokerAddress + "/query"; final Future<Response> response = _httpClient.preparePost(url).setBody(json.toString()).execute(); return new BrokerResponseFuture(response, query, url); } catch (Exception e) { throw new PinotClientException(e); } }
CompletableFuture<Integer> AccessTheWebAsync() { AsyncHttpClient asyncHttpClient = new DefaultAsyncHttpClient(); return asyncHttpClient .prepareGet("http://msdn.microsoft.com") .execute() .toCompletableFuture() .thenApply(Response::getResponseBody) .thenApply(String::length); }