CompletableFuture<Integer> AccessTheWebAsync() { AsyncHttpClient asyncHttpClient = new DefaultAsyncHttpClient(); return asyncHttpClient .prepareGet("http://msdn.microsoft.com") .execute() .toCompletableFuture() .thenApply(Response::getResponseBody) .thenApply(String::length); }
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()); } }
static CompletableFuture<Integer> AccessTheWebAsyncNio(){ final AsyncHttpClient asyncHttpClient = new AsyncHttpClient(); final CompletableFuture<Integer> promise = new CompletableFuture<>(); asyncHttpClient .prepareGet("https://msdn.microsoft.com") .execute(new AsyncCompletionHandler<Response>(){ @Override public Response onCompleted(Response resp) throws Exception { promise.complete(resp.getResponseBody().length()); return resp; } }); return promise; }
public static WrappedRequestBuilder get(String url) { return new WrappedRequestBuilder(getNingClient().prepareGet(url), "GET " + url); }
public static void asyncHttpGet(String url, List<String> headers, Map<String, String> paramValues, AsyncCompletionHandler handler) throws Exception { if (!MapUtils.isEmpty(paramValues)) { String encodedContent = encodingParams(paramValues, "UTF-8"); url += (null == encodedContent) ? "" : ("?" + encodedContent); } AsyncHttpClient.BoundRequestBuilder builder = asyncHttpClient.prepareGet(url); if (!CollectionUtils.isEmpty(headers)) { for (String header : headers) { builder.setHeader(header.split("=")[0], header.split("=")[1]); } } builder.setHeader("Accept-Charset", "UTF-8"); if (handler != null) { builder.execute(handler); } else { builder.execute(); } }
socket = client.prepareGet(url).execute(handler).get(); LOG.info("Successfully connected to {}.", url); } catch (ExecutionException e) {
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; }
URL target = new URL(host, healthChecker.getPath()); AsyncHttpClient.BoundRequestBuilder builder = asyncHttpClient.prepareGet(target.toString()); Map<String, String> customHeaders = healthChecker.getCustomHeaders(); for (Map.Entry<String, String> entry : customHeaders.entrySet()) {
public String sse(final String path, final int count) throws Exception { CountDownLatch latch = new CountDownLatch(count); String result = client.prepareGet("http://localhost:" + port + path) .addHeader("Content-Type", MediaType.sse.name()) .addHeader("last-event-id", count + "")
@Override public SingularityLoadBalancerUpdate getState(LoadBalancerRequestId loadBalancerRequestId) { final String uri = getLoadBalancerUri(loadBalancerRequestId); final BoundRequestBuilder requestBuilder = httpClient.prepareGet(uri); if (loadBalancerQueryParams.isPresent()) { addAllQueryParams(requestBuilder, loadBalancerQueryParams.get()); } return sendRequestWrapper(loadBalancerRequestId, LoadBalancerMethod.CHECK_STATE, requestBuilder.build(), BaragonRequestState.UNKNOWN); }
.prepareGet(url) .addQueryParameter("path", fileFullPath) .setPerRequestConfig(unlimitedTimeout)
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"); } }
@SuppressWarnings("deprecation") public Optional<MesosFileChunkObject> read(String slaveHostname, String fullPath, Optional<Long> offset, Optional<Long> length) throws SlaveNotFoundException { try { final AsyncHttpClient.BoundRequestBuilder builder = asyncHttpClient.prepareGet(String.format("http://%s:5051/files/read", slaveHostname)) .addQueryParameter("path", fullPath);
public Collection<MesosFileObject> browse(String slaveHostname, String fullPath) throws SlaveNotFoundException { try { PerRequestConfig timeoutConfig = new PerRequestConfig(); timeoutConfig.setRequestTimeoutInMs((int) configuration.getSandboxHttpTimeoutMillis()); Response response = asyncHttpClient .prepareGet(String.format("http://%s:5051/files/browse", slaveHostname)) .setPerRequestConfig(timeoutConfig) .addQueryParameter("path", fullPath) .execute() .get(); if (response.getStatusCode() == 404) { return Collections.emptyList(); } if (response.getStatusCode() != 200) { throw new RuntimeException(String.format("Got HTTP %s from Mesos slave", response.getStatusCode())); } return objectMapper.readValue(response.getResponseBodyAsStream(), MESOS_FILE_OBJECTS); } catch (ConnectException ce) { throw new SlaveNotFoundException(ce); } catch (Exception e) { if (e.getCause().getClass() == ConnectException.class) { throw new SlaveNotFoundException(e); } else { throw Throwables.propagate(e); } } }
private SingularityUserPermissionsResponse verifyUncached(String authHeaderValue) { try { Response response = asyncHttpClient.prepareGet(webhookAuthConfiguration.getAuthVerificationUrl()) .addHeader("Authorization", authHeaderValue) .execute() .get(); if (response.getStatusCode() > 299) { throw WebExceptions.unauthorized(String.format("Got status code %d when verifying jwt", response.getStatusCode())); } else { String responseBody = response.getResponseBody(); SingularityUserPermissionsResponse permissionsResponse = objectMapper.readValue(responseBody, SingularityUserPermissionsResponse.class); if (!permissionsResponse.getUser().isPresent()) { throw WebExceptions.unauthorized(String.format("No user present in response %s", permissionsResponse)); } if (!permissionsResponse.getUser().get().isAuthenticated()) { throw WebExceptions.unauthorized(String.format("User not authenticated (response: %s)", permissionsResponse)); } permissionsCache.put(authHeaderValue, permissionsResponse); return permissionsResponse; } } catch (Throwable t) { throw new RuntimeException(t); } } }
builder = client.prepareGet(requestUrl); break; case POST:
public class RestClient { public static void main(String[] args) throws ExecutionException, InterruptedException, IOException, ClassNotFoundException { AsyncHttpClient asyncHttpClient = new AsyncHttpClient(); Response r = asyncHttpClient.prepareGet("http://127.0.0.1:5701/hazelcast/rest/maps/default/key1") .execute().get(); ObjectInputStream objectInputStream = new ObjectInputStream( new ByteArrayInputStream(r.getResponseBodyAsBytes())); final Person o = (Person) objectInputStream.readObject(); System.out.println(o.toString()); } }
private void crawlURL(String url, TweetFetcherHandler handler) { try { asyncHttpClient.prepareGet(url).addHeader("Accept-Charset", "utf-8") .addHeader("Accept-Language", "en-US").execute(handler); } catch (IOException e) { LOG.warn("Abandoning due to error (" + e + "): " + url); crawl_repair.put(handler.getId(), handler.getLine()); connections.decrementAndGet(); } }
//imports import java.util.concurrent.Future; import com.ning.http.client.AsyncHttpClient; import com.ning.http.client.AsyncHttpClient.BoundRequestBuilder; import com.ning.http.client.Response; //request AsyncHttpClient asyncHttpClient = new AsyncHttpClient(); BoundRequestBuilder prepareGet = asyncHttpClient.prepareGet(url); Future<Response> fResponse = prepareGet.execute(); Response r = fResponse.get(); InputStream responseBodyAsStream = r.getResponseBodyAsStream(); return ok(responseBodyAsStream).as('image/png');
Single<Response> fetch(String address) { return Single.create(subscriber -> asyncHttpClient .prepareGet(address) .execute(handler(subscriber))); }