JAVA HELP

OkHttp Java (How It Works For Developers)

Published July 1, 2024

In modern Java development, efficient handling of HTTP requests is crucial for building robust applications, especially those that rely on web services and APIs. OkHttp, a powerful HTTP & HTTP/2 client for Java and Kotlin, has become a popular choice due to its performance, ease of use, and advanced features.

This article provides a comprehensive guide to OkHttp, covering its key features, installation, and common use cases.

What is OkHttp?

OkHttp is a versatile open-source Java library for handling HTTP requests, offering a comprehensive set of features for seamless integration into your applications. With its intuitive API, creating a new request or executing a simple POST request is as easy as configuring a new request builder with query parameters and a string URL.

Additionally, OkHttp facilitates efficient response handling, providing access to the response body, response headers, and even supporting response caching to optimize network traffic and reduce server availability problems. Whether you're making synchronous or asynchronous calls, OkHttp's connection pooling ensures optimal performance, even when dealing with multiple IP addresses.

OkHttp Java (How It Works For Developers): Figure 1

For developers accustomed to using Apache HTTP Client, OkHttp offers a more modern and efficient alternative, with improved performance and flexibility. Its support for asynchronous calls and callbacks makes it a preferred choice for applications requiring responsiveness and scalability.

With OkHttp, managing many HTTP clients and requests becomes effortless, empowering developers to focus on building robust and reliable applications without compromising on performance or functionality.

Key Features

Key features of OkHttp include:

Synchronous and asynchronous request handling: OkHttp allows for both synchronous (blocking) and asynchronous (non-blocking) operations.
Connection pooling: Reuses HTTP connections to minimize client connectivity problems and improve performance.
Transparent GZIP compression: Reduces the size of HTTP responses, saving bandwidth and speeding up data transfer.
Caching: Supports response caching, reducing the need for repeated network requests.
HTTP/2 support: Enhances performance by allowing multiple requests and responses to be multiplexed over a single connection.
Timeouts and retries: Offers fine-grained control over connection and read timeouts, as well as retry mechanisms for failed requests.

Installing OkHttp

To start using OkHttp in your Java project, you need to include its dependency in your build configuration. If you're using Maven, add the following dependency to your pom.xml file:

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>5.0.0-alpha.14</version>
</dependency>

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>5.0.0-alpha.14</version>
</dependency>

XML

For Gradle, add this line to your build.gradle file:

implementation 'com.squareup.okhttp3:okhttp:5.0.0-alpha.14'

Make sure to check for the latest version on Maven Central or GitHub.

Basic Usage

Creating an OkHttpClient

The OkHttpClient class is the main entry point for executing HTTP requests. It is recommended to create a single OkHttpClient instance and reuse it throughout your application to take advantage of connection pooling.

import okhttp3.OkHttpClient;
OkHttpClient client = new OkHttpClient();

import okhttp3.OkHttpClient;
OkHttpClient client = new OkHttpClient();

JAVA

Making GET Requests

To make a simple GET request, you need to create a Request object and execute it using the OkHttpClient.

import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.io.IOException;

public class OkHttpExample {
    public static void main(String[] args) {
        OkHttpClient client = new OkHttpClient();
        Request request = new Request.Builder()
                .url("https://jsonplaceholder.typicode.com/posts/1")
                .build();
        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful()) {
                System.out.println(response.body().string());
            } else {
                System.err.println("Request failed: " + response.code());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.io.IOException;

public class OkHttpExample {
    public static void main(String[] args) {
        OkHttpClient client = new OkHttpClient();
        Request request = new Request.Builder()
                .url("https://jsonplaceholder.typicode.com/posts/1")
                .build();
        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful()) {
                System.out.println(response.body().string());
            } else {
                System.err.println("Request failed: " + response.code());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

JAVA

OkHttp Java (How It Works For Developers): Figure 2

Making POST Requests

For a POST request, you need to include a request body and return response. OkHttp provides the RequestBody class to handle this.

import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;
import java.io.IOException;

public class OkHttpExample {
    public static final MediaType JSON = MediaType.get("application/json; charset=utf-8");

    public static void main(String[] args) {
        OkHttpClient client = new OkHttpClient();
        String json = "{\"title\":\"foo\",\"body\":\"bar\",\"userId\":1}";
        RequestBody body = RequestBody.create(json, JSON);
        Request request = new Request.Builder()
                .url("https://jsonplaceholder.typicode.com/posts")
                .post(body)
                .build();
        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful()) {
                System.out.println(response.body().string());
            } else {
                System.err.println("Request failed: " + response.code());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;
import java.io.IOException;

public class OkHttpExample {
    public static final MediaType JSON = MediaType.get("application/json; charset=utf-8");

    public static void main(String[] args) {
        OkHttpClient client = new OkHttpClient();
        String json = "{\"title\":\"foo\",\"body\":\"bar\",\"userId\":1}";
        RequestBody body = RequestBody.create(json, JSON);
        Request request = new Request.Builder()
                .url("https://jsonplaceholder.typicode.com/posts")
                .post(body)
                .build();
        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful()) {
                System.out.println(response.body().string());
            } else {
                System.err.println("Request failed: " + response.code());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

JAVA

OkHttp Java (How It Works For Developers): Figure 3

Asynchronous Requests

Asynchronous requests are handled using callbacks, allowing your application to remain responsive while waiting for the response.

import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.io.IOException;

public class OkHttpExample {
    public static void main(String[] args) {
        OkHttpClient client = new OkHttpClient();
        Request request = new Request.Builder()
                .url("https://jsonplaceholder.typicode.com/posts/1")
                .build();
        client.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                e.printStackTrace();
            }
            @Override
            public void onResponse(Call call, Response response) throws IOException {
                if (response.isSuccessful()) {
                    System.out.println(response.body().string());
                } else {
                    System.err.println("Request failed: " + response.code());
                }
            }
        });
    }
}

import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.io.IOException;

public class OkHttpExample {
    public static void main(String[] args) {
        OkHttpClient client = new OkHttpClient();
        Request request = new Request.Builder()
                .url("https://jsonplaceholder.typicode.com/posts/1")
                .build();
        client.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                e.printStackTrace();
            }
            @Override
            public void onResponse(Call call, Response response) throws IOException {
                if (response.isSuccessful()) {
                    System.out.println(response.body().string());
                } else {
                    System.err.println("Request failed: " + response.code());
                }
            }
        });
    }
}

JAVA

Advanced Features

Interceptors

Interceptors are a powerful feature that allows you to inspect, modify, or retry requests and responses. They can be used for logging, adding headers, or handling authentication.

import okhttp3.Interceptor;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.io.IOException;

public class OkHttpExample {
    public static void main(String[] args) {
        OkHttpClient client = new OkHttpClient.Builder()
                .addInterceptor(new Interceptor() {
                    @Override
                    public Response intercept(Chain chain) throws IOException {
                        Request request = chain.request().newBuilder()
                                .addHeader("Authorization", "Bearer your_token_here")
                                .build();
                        return chain.proceed(request);
                    }
                })
                .build();
        Request request = new Request.Builder()
                .url("https://jsonplaceholder.typicode.com/posts/1")
                .build();
        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful()) {
                System.out.println(response.body().string());
            } else {
                System.err.println("Request failed: " + response.code());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import okhttp3.Interceptor;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.io.IOException;

public class OkHttpExample {
    public static void main(String[] args) {
        OkHttpClient client = new OkHttpClient.Builder()
                .addInterceptor(new Interceptor() {
                    @Override
                    public Response intercept(Chain chain) throws IOException {
                        Request request = chain.request().newBuilder()
                                .addHeader("Authorization", "Bearer your_token_here")
                                .build();
                        return chain.proceed(request);
                    }
                })
                .build();
        Request request = new Request.Builder()
                .url("https://jsonplaceholder.typicode.com/posts/1")
                .build();
        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful()) {
                System.out.println(response.body().string());
            } else {
                System.err.println("Request failed: " + response.code());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

JAVA

Handling Timeouts

OkHttp provides methods to set timeouts for different stages of the HTTP request itself.

import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.io.IOException;
import java.util.concurrent.TimeUnit;

public class OkHttpExample {
    public static void main(String[] args) {
        OkHttpClient client = new OkHttpClient.Builder()
                .connectTimeout(10, TimeUnit.SECONDS)
                .writeTimeout(10, TimeUnit.SECONDS)
                .readTimeout(30, TimeUnit.SECONDS)
                .build();
        Request request = new Request.Builder()
                .url("https://jsonplaceholder.typicode.com/posts/1")
                .build();
        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful()) {
                System.out.println(response.body().string());
            } else {
                System.err.println("Request failed: " + response.code());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.io.IOException;
import java.util.concurrent.TimeUnit;

public class OkHttpExample {
    public static void main(String[] args) {
        OkHttpClient client = new OkHttpClient.Builder()
                .connectTimeout(10, TimeUnit.SECONDS)
                .writeTimeout(10, TimeUnit.SECONDS)
                .readTimeout(30, TimeUnit.SECONDS)
                .build();
        Request request = new Request.Builder()
                .url("https://jsonplaceholder.typicode.com/posts/1")
                .build();
        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful()) {
                System.out.println(response.body().string());
            } else {
                System.err.println("Request failed: " + response.code());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

JAVA

Caching Responses

OkHttp can cache responses to reduce request latency and improve performance. This requires setting up a cache directory and size.

import okhttp3.Cache;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.io.File;
import java.io.IOException;

public class OkHttpExample {
    public static void main(String[] args) {
        File cacheDirectory = new File("cacheDirectory");
        Cache cache = new Cache(cacheDirectory, 10 * 1024 * 1024); // 10 MB cache
        OkHttpClient client = new OkHttpClient.Builder()
                .cache(cache)
                .build();
        Request request = new Request.Builder()
                .url("https://jsonplaceholder.typicode.com/posts/1")
                .build();
        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful()) {
                System.out.println(response.body().string());
            } else {
                System.err.println("Request failed: " + response.code());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import okhttp3.Cache;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.io.File;
import java.io.IOException;

public class OkHttpExample {
    public static void main(String[] args) {
        File cacheDirectory = new File("cacheDirectory");
        Cache cache = new Cache(cacheDirectory, 10 * 1024 * 1024); // 10 MB cache
        OkHttpClient client = new OkHttpClient.Builder()
                .cache(cache)
                .build();
        Request request = new Request.Builder()
                .url("https://jsonplaceholder.typicode.com/posts/1")
                .build();
        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful()) {
                System.out.println(response.body().string());
            } else {
                System.err.println("Request failed: " + response.code());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

JAVA

Integrating OkHttp with IronPDF in Java

Combining the capabilities of OkHttp and IronPDF allows Java developers to fetch data from the web and convert it into PDFs. OkHttp is a robust HTTP client for handling network requests, while IronPDF is a powerful library for generating PDFs from various sources.

IronPDF - Overview

IronPDF for Java is a comprehensive library designed to simplify PDF generation within Java applications. Leveraging its intuitive API, developers can effortlessly create, manipulate, and render PDF documents from various data sources, including HTML, images, and text.

With support for advanced features like PDF encryption, digital signatures, and interactive form filling, IronPDF empowers developers to produce professional-grade PDFs tailored to their specific requirements. Its seamless integration and extensive documentation make it a go-to solution for Java developers seeking to enhance their applications with robust PDF generation capabilities.

OkHttp Java (How It Works For Developers): Figure 4

Setting Up Dependencies

First, add the necessary dependencies to your pom.xml (for Maven) xml file or build.gradle (for Gradle) file.

Maven

<dependency>
    <groupId>com.ironsoftware</groupId>
    <artifactId>ironpdf</artifactId>
    <version>2024.3.1</version>
</dependency>

<dependency>
    <groupId>com.ironsoftware</groupId>
    <artifactId>ironpdf</artifactId>
    <version>2024.3.1</version>
</dependency>

XML

Gradle

implementation 'com.ironsoftware:ironpdf:2024.3.1'

Integrating OkHttp and IronPDF

Now, let's combine the two functionalities: fetching HTML content with OkHttp and generating a PDF with IronPDF.

import com.ironsoftware.ironpdf.PdfDocument;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.io.IOException;
import java.nio.file.Paths;

public class OkHttpToPdf {
    private final OkHttpClient client = new OkHttpClient();

    public String fetchHtml(String url) throws IOException {
        Request request = new Request.Builder()
                .url(url)
                .build();
        try (Response response = client.newCall(request).execute()) {
            if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);
            return response.body().string();
        }
    }

    public void generatePdfFromUrl(String url, String outputFilePath) {
        try {
            String htmlContent = fetchHtml(url);
            PdfDocument pdf = PdfDocument.renderHtmlAsPdf(htmlContent);
            pdf.saveAs(Paths.get(outputFilePath));
            System.out.println("PDF generated successfully at " + outputFilePath);
        } catch (IOException e) {
            System.err.println("Failed to fetch HTML content: " + e.getMessage());
        } catch (Exception e) {
            System.err.println("Failed to generate PDF: " + e.getMessage());
        }
    }

    public static void main(String[] args) {
        OkHttpToPdf converter = new OkHttpToPdf();
        converter.generatePdfFromUrl("https://ironpdf.com/java", "website.pdf");
    }
}

import com.ironsoftware.ironpdf.PdfDocument;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import java.io.IOException;
import java.nio.file.Paths;

public class OkHttpToPdf {
    private final OkHttpClient client = new OkHttpClient();

    public String fetchHtml(String url) throws IOException {
        Request request = new Request.Builder()
                .url(url)
                .build();
        try (Response response = client.newCall(request).execute()) {
            if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);
            return response.body().string();
        }
    }

    public void generatePdfFromUrl(String url, String outputFilePath) {
        try {
            String htmlContent = fetchHtml(url);
            PdfDocument pdf = PdfDocument.renderHtmlAsPdf(htmlContent);
            pdf.saveAs(Paths.get(outputFilePath));
            System.out.println("PDF generated successfully at " + outputFilePath);
        } catch (IOException e) {
            System.err.println("Failed to fetch HTML content: " + e.getMessage());
        } catch (Exception e) {
            System.err.println("Failed to generate PDF: " + e.getMessage());
        }
    }

    public static void main(String[] args) {
        OkHttpToPdf converter = new OkHttpToPdf();
        converter.generatePdfFromUrl("https://ironpdf.com/java", "website.pdf");
    }
}

JAVA

Code Explanation

The above code demonstrates how to fetch HTML content from a URL and convert it into a PDF file using the OkHttp and IronPDF libraries in Java:

Import Statements: The necessary libraries are imported, including IronPDF for PDF generation and OkHttp for HTTP requests.
OkHttpClient Initialization: An instance of OkHttpClient is created.
fetchHtml Method: This method fetches HTML content from a specified URL.
- A request is built with the provided URL.
- The request is executed and the response is obtained.
- If the response is not successful, an IOException is thrown.
- The response body is returned as a string.
generatePdfFromUrl Method: This method generates a PDF from the HTML content of a specified URL and saves it to a given file path.
- The HTML content is fetched using the fetchHtml method.
- The HTML content is rendered as a PDF using IronPDF.
- The PDF is saved to the specified file path.
- Appropriate error handling is included for both HTML fetching and PDF generation.
main Method: This is the entry point of the program.
- An instance of OkHttpToPdf is created.
- The generatePdfFromUrl method is called with a specific URL and output file path.

Output

The URL data is fetched using OkHttp client and then rendered using IronPDF efficiently to convert it to PDF as shown below:

OkHttp Java (How It Works For Developers): Figure 5

For more detailed information on IronPDF, please visit this documentation page. Please also check this code examples and API Reference page for further utilizing IronPDF.

Conclusion

OkHttp is a versatile and powerful HTTP client for Java and Android that simplifies the process of making network requests. With its support for synchronous and asynchronous operations, connection pooling, transparent GZIP compression, caching, and HTTP/2, the OkHttp client is well-suited for a wide range of use cases. By integrating OkHttp into your Java applications, you can enhance their performance, reliability, and efficiency.

By integrating OkHttp with IronPDF, you can efficiently fetch HTML content from web sources and convert it into PDF documents. This approach is especially useful for applications that need to generate reports, save web pages, or convert web content into offline documents.

Unlock the potential of PDF generation in your Java applications with IronPDF's free trial, enabling seamless integration of professional-grade PDF generation into your projects. Download now and elevate your PDF generation experience!

< PREVIOUS
Apache Commons IO (How It Works For Developers)

NEXT >
Gson Java (How It Works For Developers)