How to use

OkHttpClient

in

okhttp3

public void sendGetRequest(String url) throws IOException {
 OkHttpClient client = new OkHttpClient();
 Request request = new Request.Builder().url(url).build();
 try (Response response = client.newCall(request).execute()) {
  String responseBody = response.body().string();
  // ... do something with response
 }
}

String run(String url) throws IOException {
 Request request = new Request.Builder()
   .url(url)
   .build();
 try (Response response = client.newCall(request).execute()) {
  return response.body().string();
 }
}

public static void main(String... args) throws Exception {
 OkHttpClient client = new OkHttpClient();
 // Create request for remote resource.
 Request request = new Request.Builder()
   .url(ENDPOINT)
   .build();
 // Execute the request and retrieve the response.
 try (Response response = client.newCall(request).execute()) {
  // Deserialize HTTP response to concrete type.
  ResponseBody body = response.body();
  List<Contributor> contributors = CONTRIBUTORS_JSON_ADAPTER.fromJson(body.source());
  // Sort list by the most contributions.
  Collections.sort(contributors, (c1, c2) -> c2.contributions - c1.contributions);
  // Output list of contributors.
  for (Contributor contributor : contributors) {
   System.out.println(contributor.login + ": " + contributor.contributions);
  }
 }
}

public void run() throws Exception {
 for (int i = 0; i < 5; i++) {
  System.out.println("    Request: " + i);
  Request request = new Request.Builder()
    .url("https://api.github.com/search/repositories?q=http")
    .build();
  OkHttpClient clientForCall;
  if (i == 2) {
   // Force this request's response to be written to the cache. This way, subsequent responses
   // can be read from the cache.
   System.out.println("Force cache: true");
   clientForCall = client.newBuilder()
     .addNetworkInterceptor(REWRITE_CACHE_CONTROL_INTERCEPTOR)
     .build();
  } else {
   System.out.println("Force cache: false");
   clientForCall = client;
  }
  try (Response response = clientForCall.newCall(request).execute()) {
   if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);
   System.out.println("    Network: " + (response.networkResponse() != null));
   System.out.println();
  }
 }
}

 OkHttpClient client = new OkHttpClient();
client.setConnectTimeout(15, TimeUnit.SECONDS); // connect timeout
client.setReadTimeout(15, TimeUnit.SECONDS);    // socket timeout

Request request = new Request.Builder().url(url).build();
Response response = client.newCall(request).execute();

private @Nullable Response getCacheOnlyResponse(Request request) {
 if (!post && client.cache() != null) {
  try {
   Request cacheRequest = request.newBuilder().cacheControl(CacheControl.FORCE_CACHE).build();
   Response cacheResponse = client.newCall(cacheRequest).execute();
   if (cacheResponse.code() != 504) {
    return cacheResponse;
   }
  } catch (IOException ioe) {
   // Failures are ignored as we can fallback to the network
   // and hopefully repopulate the cache.
  }
 }
 return null;
}

private void run() {
 OkHttpClient client = new OkHttpClient.Builder()
   .readTimeout(0,  TimeUnit.MILLISECONDS)
   .build();
 Request request = new Request.Builder()
   .url("ws://echo.websocket.org")
   .build();
 client.newWebSocket(request, this);
 // Trigger shutdown of the dispatcher's executor so this process can exit cleanly.
 client.dispatcher().executorService().shutdown();
}

public static <T> JsonResponse<T> execute(JsonCodec<T> codec, OkHttpClient client, Request request)
{
  try (Response response = client.newCall(request).execute()) {
    // TODO: fix in OkHttp: https://github.com/square/okhttp/issues/3111
    if ((response.code() == 307) || (response.code() == 308)) {
      String location = response.header(LOCATION);
      if (location != null) {
        request = request.newBuilder().url(location).build();
        return execute(codec, client, request);
      }
    }
    ResponseBody responseBody = requireNonNull(response.body());
    String body = responseBody.string();
    if (isJson(responseBody.contentType())) {
      return new JsonResponse<>(response.code(), response.message(), response.headers(), body, codec);
    }
    return new JsonResponse<>(response.code(), response.message(), response.headers(), body);
  }
  catch (IOException e) {
    // OkHttp throws this after clearing the interrupt status
    // TODO: remove after updating to Okio 1.15.0+
    if ((e instanceof InterruptedIOException) && "thread interrupted".equals(e.getMessage())) {
      Thread.currentThread().interrupt();
    }
    throw new UncheckedIOException(e);
  }
}

@Override
public String postSSL(String url, String data, String certPass, InputStream certFile) {
  okhttp3.RequestBody body = okhttp3.RequestBody.create(CONTENT_TYPE_FORM, data);
  okhttp3.Request request = new okhttp3.Request.Builder().url(url).post(body).build();
  InputStream inputStream = certFile;
  try {
    KeyStore clientStore = KeyStore.getInstance("PKCS12");
    char[] passArray = certPass.toCharArray();
    clientStore.load(inputStream, passArray);
    KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
    kmf.init(clientStore, passArray);
    KeyManager[] kms = kmf.getKeyManagers();
    SSLContext sslContext = SSLContext.getInstance("TLSv1");
    sslContext.init(kms, null, new SecureRandom());
    @SuppressWarnings("deprecation")
    okhttp3.OkHttpClient httpsClient = new okhttp3.OkHttpClient().newBuilder()
        .connectTimeout(10, TimeUnit.SECONDS).writeTimeout(10, TimeUnit.SECONDS)
        .readTimeout(30, TimeUnit.SECONDS).sslSocketFactory(sslContext.getSocketFactory()).build();
    okhttp3.Response response = httpsClient.newCall(request).execute();
    if (!response.isSuccessful())
      throw new RuntimeException("Unexpected code " + response);
    return response.body().string();
  } catch (Exception e) {
    throw new RuntimeException(e);
  } finally {
    IOUtils.closeQuietly(inputStream);
  }
}

if (hostnameCount.incrementAndGet() > 100) return;
Request request = new Request.Builder()
  .url(url)
  .build();
try (Response response = client.newCall(request).execute()) {
 String responseSource = response.networkResponse() != null ? ("(network: "
   + response.networkResponse().code()
   + " over "
   + response.protocol()
 Document document = Jsoup.parse(response.body().string(), url.toString());
 for (Element element : document.select("a[href]")) {
  String href = element.attr("href");
  HttpUrl link = response.request().url().resolve(href);
  if (link == null) continue; // URL is either invalid or its scheme isn't http/https.
  queue.add(link.newBuilder().fragment(null).build());

/**
 * Inspired by https://github.com/square/okhttp/blob/parent-3.6.0/okhttp/src/main/java/okhttp3/internal/http/RetryAndFollowUpInterceptor.java#L286
 */
private Response followPostRedirect(Response response) throws IOException {
 String location = response.header("Location");
 if (location == null) {
  throw new IllegalStateException(format("Missing HTTP header 'Location' in redirect of %s", response.request().url()));
 }
 HttpUrl url = response.request().url().resolve(location);
 // Don't follow redirects to unsupported protocols.
 if (url == null) {
  throw new IllegalStateException(format("Unsupported protocol in redirect of %s to %s", response.request().url(), location));
 }
 Request.Builder redirectRequest = response.request().newBuilder();
 redirectRequest.post(response.request().body());
 response.body().close();
 return okHttpClient.newCall(redirectRequest.url(url).build()).execute();
}

OkHttpClient client        = getOkHttpClient(request);
Request      okHttpRequest = createRequest(request);
Response     response      = client.newCall(okHttpRequest).execute();
String       body          = response.body().string();
List<Cookie> cookies = Cookie.parseAll(okHttpRequest.url(), response.headers());
  cookieStore.put(okHttpRequest.url().host(), cookies);
  if (!"webpush.web.wechat.com".equals(okHttpRequest.url().host())) {
    cookieStore.put("webpush.web.wechat.com", cookies);

public void run() throws Exception {
 Request request = new Request.Builder()
   .url("https://publicobject.com/helloworld.txt")
   .build();
 Response response = client.newCall(request).execute();
 response.body().close();
}

Response response = null;
try {
  response = new OkHttpClient.Builder()
      .build()
      .newCall(new Request.Builder().get().url(url).build())
      .execute();
  if (response.body() != null) {
    in1 = response
        .body()
        .byteStream();

Response okHttpResponse;
try {
  Request.Builder builder = new Request.Builder().url(request.getUrl());
  addHeadersToRequestBuilder(builder, request);
  final RequestBody requestBody = request.getMultiPartRequestBody();
  final long requestBodyLength = requestBody.contentLength();
  builder = builder.post(new RequestProgressBody(requestBody, request.getUploadProgressListener()));
  if (request.getCacheControl() != null) {
    builder.cacheControl(request.getCacheControl());
  if (request.getOkHttpClient() != null) {
    request.setCall(request.getOkHttpClient()
        .newBuilder()
        .cache(sHttpClient.cache())
        .build()
        .newCall(okHttpRequest));
  } else {
    request.setCall(sHttpClient.newCall(okHttpRequest));

private static Response call(String url) throws IOException {
 Request request = new Request.Builder().get().url(url).build();
 return new OkHttpClient().newCall(request).execute();
}

public void run() throws Exception {
 Request request = new Request.Builder()
   .url("https://publicobject.com/helloworld.txt")
   .build();
 try (Response response = client.newCall(request).execute()) {
  System.out.println(response.request().header("Date"));
 }
}

@Override
public Response metaRefresh(String nextUrl) throws Exception {
  HttpUrl lastUrl = lastResponse.request().url();
  if (!nextUrl.startsWith("http")){
    String prefix = lastUrl.scheme()+"://"+lastUrl.host()+lastUrl.encodedPath();
    nextUrl = prefix + nextUrl;
  }
  logger.info("Seimi refresh url to={} from={}",nextUrl,lastUrl.toString());
  currentRequestBuilder.url(nextUrl);
  lastResponse = okHttpClient.newCall(currentRequestBuilder.build()).execute();
  return renderResponse(lastResponse,currentRequest);
}

public void run() throws Exception {
 Request request = new Request.Builder()
   .url("https://publicobject.com/robots.txt")
   .build();
 try (Response response = client.newCall(request).execute()) {
  if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);
  for (Certificate certificate : response.handshake().peerCertificates()) {
   System.out.println(CertificatePinner.pin(certificate));
  }
 }
}

private static Response doCall(OkHttpClient client, Request okRequest) {
 Call call = client.newCall(okRequest);
 try {
  return call.execute();
 } catch (IOException e) {
  throw new IllegalStateException("Fail to request " + okRequest.url(), e);
 }
}