DEV Community: Deividas Strole

Production-Ready Java REST Client: Retries, Pagination, Rate Limits, and Error Handling

Deividas Strole — Tue, 06 Oct 2026 00:24:08 +0000

Production-Ready Java REST Client: Retries, Pagination, Rate Limits, and Error Handling

A simple REST client is easy to build.

A production-ready REST client is a different story.

Once your application starts talking to real APIs, you quickly run into problems such as:

Temporary server failures
Rate limits
Network timeouts
Pagination
Empty responses
Retry storms
Non-JSON error responses
Authentication failures
Slow downstream services
APIs returning 429 Too Many Requests
APIs returning 500, 502, 503, or 504

In the previous article, we built a reusable REST client using:

Java HttpClient
Jackson
Java records
Generic response types
Bearer-token authentication

In this tutorial, we'll make that client much more resilient.

We'll add:

Centralized error handling
Custom exceptions
Safe retry logic
Exponential backoff
Retry-After handling
Rate-limit awareness
Pagination
Request timeouts
Retryable vs non-retryable status codes
Defensive JSON parsing
Reusable API client architecture

By the end, we'll have a REST client that is much closer to something you could actually use in production.

1. Why a Basic REST Client Is Not Enough

A basic client often looks like this:

HttpResponse<String> response = client.send(
        request,
        HttpResponse.BodyHandlers.ofString()
);

if (response.statusCode() >= 200 &&
    response.statusCode() < 300) {

    return mapper.readValue(
            response.body(),
            responseType
    );
}

throw new RuntimeException(
        "HTTP " + response.statusCode()
);

That works when everything goes well.

But real APIs don't always behave perfectly.

What happens if the server returns:

503 Service Unavailable

Should we fail immediately?

Maybe not.

What about:

401 Unauthorized

Should we retry?

Usually no.

What about:

429 Too Many Requests

Should we retry immediately?

Definitely not.

What about:

504 Gateway Timeout

Maybe retrying is reasonable.

Production clients need rules.

2. Classify Errors Before Retrying

The first important idea is this:

Not every failure should be retried.

A useful classification looks like this:

2xx
    → success

4xx
    → usually client error
    → usually do not retry

429
    → rate limited
    → retry later

5xx
    → server error
    → some are retryable

Network failure
    → often retryable

Timeout
    → often retryable

A basic retryable status set might be:

429 Too Many Requests
500 Internal Server Error
502 Bad Gateway
503 Service Unavailable
504 Gateway Timeout

We can encode that:

private boolean isRetryableStatus(int status) {
    return status == 429 ||
           status == 500 ||
           status == 502 ||
           status == 503 ||
           status == 504;
}

This is much safer than retrying everything.

3. Create a Custom API Exception

Let's create an exception that keeps useful information.

public class ApiException extends RuntimeException {

    private final int statusCode;
    private final String responseBody;

    public ApiException(
            int statusCode,
            String responseBody
    ) {
        super(
                "HTTP " +
                statusCode +
                ": " +
                responseBody
        );

        this.statusCode = statusCode;
        this.responseBody = responseBody;
    }

    public int statusCode() {
        return statusCode;
    }

    public String responseBody() {
        return responseBody;
    }
}

Now our code can distinguish:

catch (ApiException e) {

    if (e.statusCode() == 404) {
        System.out.println(
                "Resource not found"
        );
    }
}

That is better than throwing a generic RuntimeException.

4. Separate API Failures from Network Failures

This distinction matters.

An API failure means:

The server responded.

For example:

A network failure means:

The request did not complete normally.

For example:

DNS failure
connection reset
connection refused
socket error
timeout

So conceptually:

HTTP response received
    ↓
ApiException

No usable HTTP response
    ↓
IOException

This lets callers handle different problems differently.

5. Add Request Timeouts

Never assume a remote API will respond quickly.

Add a connection timeout to HttpClient:

HttpClient client = HttpClient.newBuilder()
        .connectTimeout(
                Duration.ofSeconds(10)
        )
        .build();

And a per-request timeout:

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create(url))
        .timeout(
                Duration.ofSeconds(20)
        )
        .GET()
        .build();

These timeouts solve different problems.

Connection timeout

How long Java waits to establish a connection.

Request timeout

How long the request itself is allowed to take.

A useful mental model:

connectTimeout
    → "Can I connect?"

request timeout
    → "How long can this whole request take?"

6. Retry Logic: Start Simple

Let's create a method that retries a request.

private HttpResponse<String> sendWithRetry(
        HttpRequest request
) throws IOException, InterruptedException {

    int maxAttempts = 3;

    for (int attempt = 1;
         attempt <= maxAttempts;
         attempt++) {

        try {

            HttpResponse<String> response =
                    client.send(
                            request,
                            HttpResponse.BodyHandlers.ofString()
                    );

            if (!isRetryableStatus(
                    response.statusCode()
            )) {
                return response;
            }

            if (attempt == maxAttempts) {
                return response;
            }

            Thread.sleep(1000);

        } catch (IOException e) {

            if (attempt == maxAttempts) {
                throw e;
            }

            Thread.sleep(1000);
        }
    }

    throw new IllegalStateException(
            "Unexpected retry state"
    );
}

This works.

But there is an immediate problem.

We always wait:

1 second

That's not ideal.

7. Use Exponential Backoff

A better retry pattern is:

attempt 1
    ↓
wait 1 second

attempt 2
    ↓
wait 2 seconds

attempt 3
    ↓
wait 4 seconds

attempt 4
    ↓
wait 8 seconds

This is called exponential backoff.

A simple implementation:

private long backoffMillis(
        int attempt
) {

    return 1000L *
            (1L << (attempt - 1));
}

For:

attempt = 1

we get:

1000 ms

For:

attempt = 2

we get:

2000 ms

For:

attempt = 3

we get:

4000 ms

8. Add Jitter

If many application instances all retry at exactly the same time, you can create a retry storm.

Imagine:

100 servers
    ↓
all receive 503
    ↓
all wait exactly 2 seconds
    ↓
all retry at the same moment

That's bad.

A common improvement is jitter.

Jitter adds a small random delay.

private long backoffWithJitter(
        int attempt
) {

    long base =
            1000L *
            (1L << (attempt - 1));

    long jitter =
            ThreadLocalRandom.current()
                    .nextLong(0, 500);

    return base + jitter;
}

Now waits might be:

1.23 seconds
2.41 seconds
4.09 seconds

instead of exactly:

1
2
4

This reduces synchronized retry spikes.

9. Respect `Retry-After`

When an API returns:

429 Too Many Requests

it may include:

Retry-After: 5

That means:

Try again after 5 seconds.

You should respect that when possible.

Example:

private long retryDelayMillis(
        HttpResponse<String> response,
        int attempt
) {

    Optional<String> retryAfter =
            response.headers()
                    .firstValue(
                            "Retry-After"
                    );

    if (retryAfter.isPresent()) {

        try {

            long seconds =
                    Long.parseLong(
                            retryAfter.get()
                    );

            return seconds * 1000L;

        } catch (NumberFormatException ignored) {
        }
    }

    return backoffWithJitter(
            attempt
    );
}

This handles the common numeric form.

10. Build a Better Retry Loop

Now we can combine everything.

private HttpResponse<String> sendWithRetry(
        HttpRequest request
) throws IOException, InterruptedException {

    int maxAttempts = 4;

    for (int attempt = 1;
         attempt <= maxAttempts;
         attempt++) {

        try {

            HttpResponse<String> response =
                    client.send(
                            request,
                            HttpResponse.BodyHandlers.ofString()
                    );

            int status =
                    response.statusCode();

            if (!isRetryableStatus(status)) {
                return response;
            }

            if (attempt == maxAttempts) {
                return response;
            }

            long delay =
                    retryDelayMillis(
                            response,
                            attempt
                    );

            Thread.sleep(delay);

        } catch (IOException e) {

            if (attempt == maxAttempts) {
                throw e;
            }

            long delay =
                    backoffWithJitter(
                            attempt
                    );

            Thread.sleep(delay);
        }
    }

    throw new IllegalStateException(
            "Unexpected retry state"
    );
}

Now the client handles:

Retryable server errors
429
Network failures
Exponential backoff
Jitter
Retry-After

11. Do Not Retry Every HTTP Method Blindly

This is one of the most important production concerns.

Retrying:

GET

is usually safer than retrying:

POST

Why?

Because a POST might have succeeded on the server even if your client never received the response.

Example:

Client sends payment request
        ↓
Server processes payment
        ↓
Connection drops
        ↓
Client retries
        ↓
Payment happens twice

That's a serious problem.

So retries should consider idempotency.

12. What Is Idempotency?

An idempotent request can be repeated without changing the result beyond the first application.

Commonly:

GET
PUT
DELETE

are designed to be idempotent.

POST usually is not.

So a safer default is:

private boolean isMethodRetryable(
        String method
) {

    return switch (method) {
        case "GET",
             "HEAD",
             "PUT",
             "DELETE",
             "OPTIONS" -> true;

        default -> false;
    };
}

Then:

if (!isMethodRetryable(
        request.method()
)) {

    return client.send(
            request,
            HttpResponse.BodyHandlers.ofString()
    );
}

13. Retrying POST Requests Safely

Some APIs support idempotency keys.

For example:

Idempotency-Key: 72a9a9f8-...

You generate a unique ID:

String idempotencyKey =
        UUID.randomUUID()
                .toString();

Then send:

.header(
        "Idempotency-Key",
        idempotencyKey
)

The server can recognize repeated requests with the same key and avoid performing the operation twice.

This is commonly used in payment APIs and other sensitive operations.

If the API supports idempotency keys, POST retries can be much safer.

If it does not, be very careful.

14. Rate Limiting

Many APIs limit how many requests you can send.

For example:

100 requests per minute

If you exceed the limit, you may receive:

429 Too Many Requests

Some APIs expose headers like:

X-RateLimit-Limit: 100
X-RateLimit-Remaining: 3
X-RateLimit-Reset: 1699999999

There is no universal header format, but the idea is common.

You can inspect response headers:

response.headers()
        .firstValue(
                "X-RateLimit-Remaining"
        )
        .ifPresent(
                value ->
                        System.out.println(
                                "Remaining: " +
                                value
                        )
        );

At minimum, your client should correctly handle 429.

15. Rate Limit Handling Strategy

A simple strategy is:

response = 429
    ↓
read Retry-After
    ↓
wait
    ↓
retry

But you should also cap retries.

Never do:

retry forever

Use:

max attempts

For example:

private static final int MAX_ATTEMPTS = 4;

Without limits, a broken downstream API can keep your application stuck indefinitely.

16. Don't Sleep Forever

You should also cap the retry delay.

Suppose:

Retry-After: 7200

That means:

2 hours

You probably don't want one request thread sleeping for two hours.

So add a maximum:

private static final long MAX_RETRY_DELAY_MS =
        30_000;

Then:

delay = Math.min(
        delay,
        MAX_RETRY_DELAY_MS
);

This keeps retry behavior bounded.

17. Pagination: Why It Matters

Many APIs do not return all records at once.

Suppose an API has:

100,000 users

It would be expensive to return all of them in one response.

Instead, the API might return:

page 1
page 2
page 3
...

For example:

GET /users?page=1&size=100

Then:

GET /users?page=2&size=100

This is called pagination.

18. Common Pagination Styles

There are several common styles.

Page number

?page=1&size=100

Offset + limit

?offset=0&limit=100

Cursor

?cursor=abc123

Link header

The server provides the next URL in an HTTP Link header.

Different APIs use different systems.

We'll start with page-number pagination.

19. Define a Paginated Response

Suppose the API returns:

{
  "items": [
    {
      "id": 1,
      "name": "Alice"
    },
    {
      "id": 2,
      "name": "Bob"
    }
  ],
  "page": 1,
  "totalPages": 5
}

We can represent it using:

public record PageResponse<T>(
        List<T> items,
        int page,
        int totalPages
) {
}

Because this contains a generic type, we'll use Jackson's TypeReference.

20. Fetch a Single Page

Suppose we have:

PageResponse<User> page =
        client.get(
                url,
                new TypeReference<
                        PageResponse<User>
                >() {}
        );

Then:

page.items()

returns the users.

And:

page.totalPages()

tells us how many pages exist.

21. Fetch All Pages

We can write:

public List<User> getAllUsers()
        throws IOException,
               InterruptedException {

    List<User> allUsers =
            new ArrayList<>();

    int page = 1;

    while (true) {

        String url =
                baseUrl +
                "/users?page=" +
                page +
                "&size=100";

        PageResponse<User> result =
                client.get(
                        url,
                        new TypeReference<
                                PageResponse<User>
                        >() {}
                );

        allUsers.addAll(
                result.items()
        );

        if (page >=
            result.totalPages()) {

            break;
        }

        page++;
    }

    return allUsers;
}

This automatically walks through every page.

22. Be Careful with "Fetch Everything"

This looks convenient:

List<User> allUsers =
        api.getAllUsers();

But imagine:

2 million users

Now you're loading them all into memory.

That may be a bad idea.

A more scalable design might:

Process one page at a time
Stream results
Save each page
Stop after a limit
Expose pagination to the caller

So production code should think about data volume.

23. Cursor-Based Pagination

Cursor pagination is common in modern APIs.

A response might look like:

{
  "items": [
    {
      "id": 1,
      "name": "Alice"
    }
  ],
  "nextCursor": "eyJpZCI6MTAwfQ=="
}

Define:

public record CursorPage<T>(
        List<T> items,
        String nextCursor
) {
}

Then:

String cursor = null;

while (true) {

    String url =
            baseUrl + "/users";

    if (cursor != null) {
        url += "?cursor=" +
                URLEncoder.encode(
                        cursor,
                        StandardCharsets.UTF_8
                );
    }

    CursorPage<User> page =
            client.get(
                    url,
                    new TypeReference<
                            CursorPage<User>
                    >() {}
            );

    process(page.items());

    cursor =
            page.nextCursor();

    if (cursor == null ||
        cursor.isBlank()) {

        break;
    }
}

Cursor pagination is often better when data changes frequently.

24. Why Cursor Pagination Can Be Better

Imagine page-number pagination:

page 1
page 2
page 3

While you're fetching pages, new records are inserted.

Now items may shift between pages.

You might:

Miss records
Process records twice

Cursor-based pagination often avoids this by giving you a stable continuation token.

25. Handle Empty Bodies Safely

Some successful responses contain no body.

For example:

204 No Content

So don't blindly parse every successful response.

Use:

private <T> T read(
        HttpResponse<String> response,
        Class<T> responseType
) throws IOException {

    validate(response);

    if (response.statusCode() == 204) {
        return null;
    }

    String body =
            response.body();

    if (body == null ||
        body.isBlank()) {

        return null;
    }

    return mapper.readValue(
            body,
            responseType
    );
}

This avoids unnecessary parsing failures.

26. Error Responses Might Not Be JSON

A REST API may normally return JSON:

{
  "error": "User not found"
}

But a proxy might return:

<html>
  <body>
    502 Bad Gateway
  </body>
</html>

So never assume error bodies are JSON.

This is especially important when parsing error payloads.

27. Parse Error JSON Defensively

Suppose your API normally returns:

{
  "code": "USER_NOT_FOUND",
  "message": "User 10 does not exist"
}

Create:

public record ErrorResponse(
        String code,
        String message
) {
}

Then:

private String extractErrorMessage(
        String body
) {

    if (body == null ||
        body.isBlank()) {

        return "No response body";
    }

    try {

        ErrorResponse error =
                mapper.readValue(
                        body,
                        ErrorResponse.class
                );

        if (error.message() != null) {
            return error.message();
        }

    } catch (Exception ignored) {
    }

    return body;
}

This gives you structured errors when possible, and raw text otherwise.

28. Improve `ApiException`

We can now make the exception more useful:

public class ApiException
        extends RuntimeException {

    private final int statusCode;
    private final String responseBody;

    public ApiException(
            int statusCode,
            String message,
            String responseBody
    ) {

        super(message);

        this.statusCode =
                statusCode;

        this.responseBody =
                responseBody;
    }

    public int statusCode() {
        return statusCode;
    }

    public String responseBody() {
        return responseBody;
    }
}

Then:

throw new ApiException(
        response.statusCode(),
        extractErrorMessage(
                response.body()
        ),
        response.body()
);

Now callers get both:

human-readable error

and:

raw response body

29. Validate Responses in One Place

Avoid repeating:

if (status < 200 ||
    status >= 300)

everywhere.

Create:

private void validate(
        HttpResponse<String> response
) {

    int status =
            response.statusCode();

    if (status >= 200 &&
        status < 300) {

        return;
    }

    throw new ApiException(
            status,
            extractErrorMessage(
                    response.body()
            ),
            response.body()
    );
}

Now every API method behaves consistently.

30. Centralize Sending Too

We can also centralize:

client.send(...)

with retries.

private HttpResponse<String> send(
        HttpRequest request
) throws IOException,
         InterruptedException {

    return sendWithRetry(
            request
    );
}

Then all methods use:

HttpResponse<String> response =
        send(request);

This means retry behavior is implemented once.

31. Generic GET

Our GET method stays simple:

public <T> T get(
        String url,
        Class<T> responseType
) throws IOException,
         InterruptedException {

    HttpRequest request =
            requestBuilder(url)
                    .GET()
                    .build();

    HttpResponse<String> response =
            send(request);

    return read(
            response,
            responseType
    );
}

32. Generic GET for Lists and Generic Types

Use:

public <T> T get(
        String url,
        TypeReference<T> responseType
) throws IOException,
         InterruptedException {

    HttpRequest request =
            requestBuilder(url)
                    .GET()
                    .build();

    HttpResponse<String> response =
            send(request);

    validate(response);

    String body =
            response.body();

    if (body == null ||
        body.isBlank()) {

        return null;
    }

    return mapper.readValue(
            body,
            responseType
    );
}

Now this works:

List<User> users =
        client.get(
                url,
                new TypeReference<
                        List<User>
                >() {}
        );

33. Generic POST

public <T, R> R post(
        String url,
        T requestBody,
        Class<R> responseType
) throws IOException,
         InterruptedException {

    String json =
            mapper.writeValueAsString(
                    requestBody
            );

    HttpRequest request =
            requestBuilder(url)
                    .header(
                            "Content-Type",
                            "application/json"
                    )
                    .POST(
                            HttpRequest.BodyPublishers
                                    .ofString(json)
                    )
                    .build();

    HttpResponse<String> response =
            send(request);

    return read(
            response,
            responseType
    );
}

Remember:

POST retries should be treated carefully.

Our retry method should only retry POST automatically if we explicitly allow it.

34. Make Retry Behavior Explicit

Instead of guessing based only on the method, we can support a retry flag:

private HttpResponse<String> send(
        HttpRequest request,
        boolean allowRetry
) throws IOException,
         InterruptedException {

    if (!allowRetry) {

        return client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );
    }

    return sendWithRetry(
            request
    );
}

Then GET:

send(
    request,
    true
);

POST:

send(
    request,
    false
);

This makes behavior much more obvious.

35. Better: Create a Request Policy

As the client grows, a boolean becomes limiting.

We can create:

public record RequestPolicy(
        boolean retry,
        int maxAttempts
) {
}

For example:

RequestPolicy safeRetry =
        new RequestPolicy(
                true,
                4
        );

RequestPolicy noRetry =
        new RequestPolicy(
                false,
                1
        );

Then:

send(
        request,
        safeRetry
);

This becomes easier to extend later.

36. Production Retry Rules

A practical default might be:

GET
    → retry transient failures

HEAD
    → retry transient failures

PUT
    → usually retryable

DELETE
    → usually retryable

POST
    → no automatic retry
      unless idempotency is guaranteed

PATCH
    → depends on API semantics

There is no universal rule.

The API contract matters.

37. Add a Base URL

Instead of passing:

"https://api.example.com/users/10"

everywhere, store:

private final String baseUrl;

Constructor:

public RestClient(
        String baseUrl,
        String token
) {

    this.baseUrl =
            baseUrl;

    this.token =
            token;

    // ...
}

Then:

private URI uri(
        String path
) {

    return URI.create(
            baseUrl + path
    );
}

Usage:

client.get(
        "/users/10",
        User.class
);

Much cleaner.

38. Avoid Double Slashes

If:

baseUrl = https://api.example.com/

and:

path = /users

you get:

https://api.example.com//users

A simple helper:

private String normalizeUrl(
        String baseUrl,
        String path
) {

    return baseUrl.replaceAll(
            "/+$",
            ""
    ) +
    "/" +
    path.replaceAll(
            "^/+",
            ""
    );
}

Or normalize the base URL once in the constructor.

39. Add Default Headers

Your builder can centralize headers:

private HttpRequest.Builder requestBuilder(
        String path
) {

    HttpRequest.Builder builder =
            HttpRequest.newBuilder()
                    .uri(
                            URI.create(
                                    normalizeUrl(
                                            baseUrl,
                                            path
                                    )
                            )
                    )
                    .timeout(
                            Duration.ofSeconds(20)
                    )
                    .header(
                            "Accept",
                            "application/json"
                    )
                    .header(
                            "User-Agent",
                            "MyJavaClient/1.0"
                    );

    if (token != null &&
        !token.isBlank()) {

        builder.header(
                "Authorization",
                "Bearer " + token
        );
    }

    return builder;
}

Now every request is consistent.

40. Log Carefully

Logging helps diagnose API problems.

Useful things to log include:

HTTP method
URL
status code
request duration
retry attempt

But be careful with:

Authorization headers
API tokens
passwords
personal data
payment information
full request bodies

Never blindly log everything.

A safe example:

System.out.println(
        request.method() +
        " " +
        request.uri()
);

And:

System.out.println(
        "HTTP " +
        response.statusCode()
);

In real applications, use a logging framework rather than System.out.

41. Measure Request Duration

You can easily measure latency:

long start =
        System.nanoTime();

HttpResponse<String> response =
        client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

long elapsedMillis =
        Duration.ofNanos(
                System.nanoTime() -
                start
        ).toMillis();

Then:

System.out.println(
        "Request took " +
        elapsedMillis +
        " ms"
);

This is useful for monitoring slow APIs.

42. Beware of Retry Multiplication

Suppose:

Service A
    ↓ retries 3 times
Service B
    ↓ retries 3 times
Service C
    ↓ retries 3 times

One user request can theoretically cause many downstream attempts.

Retries compound.

That's why retry counts should stay modest.

Usually:

2–4 attempts

is far more reasonable than:

20 attempts

43. Retries Are Not a Substitute for Resilience

Retries help with temporary failures.

They do not fix:

Long outages
Bad credentials
Invalid input
Broken API contracts
Persistent rate limits
Dependency overload
Application bugs

Production systems often also use:

Circuit breakers
Queues
Caching
Bulkheads
Fallbacks
Monitoring

But those are separate concerns.

44. A More Complete Client

Here is a compact version combining many of the ideas from this tutorial.

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.Optional;
import java.util.concurrent.ThreadLocalRandom;

public class RestClient {

    private static final int MAX_ATTEMPTS = 4;

    private static final long MAX_RETRY_DELAY_MS =
            30_000;

    private final HttpClient client;
    private final ObjectMapper mapper;
    private final String baseUrl;
    private final String token;

    public RestClient(
            String baseUrl,
            String token
    ) {

        this.baseUrl =
                baseUrl.replaceAll(
                        "/+$",
                        ""
                );

        this.token =
                token;

        this.client =
                HttpClient.newBuilder()
                        .connectTimeout(
                                Duration.ofSeconds(10)
                        )
                        .build();

        this.mapper =
                new ObjectMapper()
                        .configure(
                                DeserializationFeature
                                        .FAIL_ON_UNKNOWN_PROPERTIES,
                                false
                        );
    }

    public <T> T get(
            String path,
            Class<T> responseType
    ) throws IOException,
         InterruptedException {

        HttpRequest request =
                requestBuilder(path)
                        .GET()
                        .build();

        HttpResponse<String> response =
                sendWithRetry(
                        request
                );

        return read(
                response,
                responseType
        );
    }

    public <T> T get(
            String path,
            TypeReference<T> responseType
    ) throws IOException,
         InterruptedException {

        HttpRequest request =
                requestBuilder(path)
                        .GET()
                        .build();

        HttpResponse<String> response =
                sendWithRetry(
                        request
                );

        validate(response);

        String body =
                response.body();

        if (body == null ||
            body.isBlank()) {

            return null;
        }

        return mapper.readValue(
                body,
                responseType
        );
    }

    public <T, R> R post(
            String path,
            T requestBody,
            Class<R> responseType
    ) throws IOException,
         InterruptedException {

        String json =
                mapper.writeValueAsString(
                        requestBody
                );

        HttpRequest request =
                requestBuilder(path)
                        .header(
                                "Content-Type",
                                "application/json"
                        )
                        .POST(
                                HttpRequest.BodyPublishers
                                        .ofString(json)
                        )
                        .build();

        HttpResponse<String> response =
                client.send(
                        request,
                        HttpResponse.BodyHandlers.ofString()
                );

        return read(
                response,
                responseType
        );
    }

    private HttpRequest.Builder requestBuilder(
            String path
    ) {

        String url =
                baseUrl +
                "/" +
                path.replaceAll(
                        "^/+",
                        ""
                );

        HttpRequest.Builder builder =
                HttpRequest.newBuilder()
                        .uri(
                                URI.create(url)
                        )
                        .timeout(
                                Duration.ofSeconds(20)
                        )
                        .header(
                                "Accept",
                                "application/json"
                        )
                        .header(
                                "User-Agent",
                                "JavaRestClient/1.0"
                        );

        if (token != null &&
            !token.isBlank()) {

            builder.header(
                    "Authorization",
                    "Bearer " + token
            );
        }

        return builder;
    }

    private HttpResponse<String> sendWithRetry(
            HttpRequest request
    ) throws IOException,
         InterruptedException {

        for (int attempt = 1;
             attempt <= MAX_ATTEMPTS;
             attempt++) {

            try {

                HttpResponse<String> response =
                        client.send(
                                request,
                                HttpResponse.BodyHandlers.ofString()
                        );

                if (!isRetryableStatus(
                        response.statusCode()
                )) {

                    return response;
                }

                if (attempt ==
                    MAX_ATTEMPTS) {

                    return response;
                }

                sleep(
                        retryDelayMillis(
                                response,
                                attempt
                        )
                );

            } catch (IOException e) {

                if (attempt ==
                    MAX_ATTEMPTS) {

                    throw e;
                }

                sleep(
                        backoffWithJitter(
                                attempt
                        )
                );
            }
        }

        throw new IllegalStateException(
                "Unexpected retry state"
        );
    }

    private boolean isRetryableStatus(
            int status
    ) {

        return status == 429 ||
               status == 500 ||
               status == 502 ||
               status == 503 ||
               status == 504;
    }

    private long retryDelayMillis(
            HttpResponse<String> response,
            int attempt
    ) {

        Optional<String> retryAfter =
                response.headers()
                        .firstValue(
                                "Retry-After"
                        );

        if (retryAfter.isPresent()) {

            try {

                long seconds =
                        Long.parseLong(
                                retryAfter.get()
                        );

                return Math.min(
                        seconds * 1000L,
                        MAX_RETRY_DELAY_MS
                );

            } catch (
                    NumberFormatException ignored
            ) {
            }
        }

        return Math.min(
                backoffWithJitter(
                        attempt
                ),
                MAX_RETRY_DELAY_MS
        );
    }

    private long backoffWithJitter(
            int attempt
    ) {

        long base =
                1000L *
                (1L <<
                 (attempt - 1));

        long jitter =
                ThreadLocalRandom
                        .current()
                        .nextLong(
                                0,
                                500
                        );

        return base + jitter;
    }

    private void sleep(
            long millis
    ) throws InterruptedException {

        try {

            Thread.sleep(
                    millis
            );

        } catch (
                InterruptedException e
        ) {

            Thread.currentThread()
                    .interrupt();

            throw e;
        }
    }

    private void validate(
            HttpResponse<String> response
    ) {

        int status =
                response.statusCode();

        if (status >= 200 &&
            status < 300) {

            return;
        }

        throw new ApiException(
                status,
                extractErrorMessage(
                        response.body()
                ),
                response.body()
        );
    }

    private <T> T read(
            HttpResponse<String> response,
            Class<T> responseType
    ) throws IOException {

        validate(response);

        String body =
                response.body();

        if (response.statusCode() == 204 ||
            body == null ||
            body.isBlank()) {

            return null;
        }

        return mapper.readValue(
                body,
                responseType
        );
    }

    private String extractErrorMessage(
            String body
    ) {

        if (body == null ||
            body.isBlank()) {

            return "No response body";
        }

        try {

            ErrorResponse error =
                    mapper.readValue(
                            body,
                            ErrorResponse.class
                    );

            if (error.message() != null &&
                !error.message()
                        .isBlank()) {

                return error.message();
            }

        } catch (Exception ignored) {
        }

        return body;
    }
}

Supporting records:

public record ErrorResponse(
        String code,
        String message
) {
}

And:

public class ApiException
        extends RuntimeException {

    private final int statusCode;
    private final String responseBody;

    public ApiException(
            int statusCode,
            String message,
            String responseBody
    ) {

        super(message);

        this.statusCode =
                statusCode;

        this.responseBody =
                responseBody;
    }

    public int statusCode() {
        return statusCode;
    }

    public String responseBody() {
        return responseBody;
    }
}

45. One Important Improvement to the Example

Notice that our retry method is used for GET:

sendWithRetry(request)

but POST uses:

client.send(...)

directly.

That is intentional.

We are being conservative.

GET requests are generally safe to retry.

POST requests may cause duplicate side effects.

If your API guarantees idempotency for a POST endpoint, then you can explicitly enable retry for that operation.

46. Example: Pagination Client

Suppose the API returns:

public record PageResponse<T>(
        List<T> items,
        int page,
        int totalPages
) {
}

Then:

public List<User> getAllUsers()
        throws IOException,
               InterruptedException {

    List<User> users =
            new ArrayList<>();

    int page = 1;

    while (true) {

        PageResponse<User> result =
                client.get(
                        "/users?page=" +
                        page +
                        "&size=100",
                        new TypeReference<
                                PageResponse<User>
                        >() {}
                );

        users.addAll(
                result.items()
        );

        if (page >=
            result.totalPages()) {

            break;
        }

        page++;
    }

    return users;
}

This gives the API-specific class responsibility for pagination, while the generic REST client handles transport.

47. Keep API-Specific Logic Outside the Generic Client

The generic REST client should know about:

HTTP
JSON
timeouts
retries
headers
status codes

It should not know:

what a User is
how GitHub paginates
how Stripe errors look
how a weather API structures pages

That belongs in API-specific classes.

For example:

UserService
    ↓
UserApi
    ↓
RestClient

Or:

GitHubApi
    ↓
RestClient

This keeps the generic client reusable.

48. A Clean Architecture

A production application might look like this:

Application / Service Layer
          ↓
      GitHubApi
          ↓
      RestClient
          ↓
 ┌───────────────────┐
 │ HttpClient        │
 │ ObjectMapper      │
 │ retries           │
 │ backoff           │
 │ error handling    │
 │ authentication    │
 └───────────────────┘
          ↓
     External API

Each layer has a clear responsibility.

49. Quick Retry Cheat Sheet

A practical retry policy might look like:

200–299
    → success

400
    → don't retry

401
    → don't retry

403
    → don't retry

404
    → don't retry

408
    → maybe retry

409
    → depends on API

429
    → retry after delay

500
    → retry

502
    → retry

503
    → retry

504
    → retry

But always check the API's own documentation.

50. Quick Production Checklist

Before calling your REST client production-ready, ask:

✓ Are connection timeouts configured?

✓ Are request timeouts configured?

✓ Are retry attempts bounded?

✓ Is exponential backoff used?

✓ Is jitter used?

✓ Is Retry-After respected?

✓ Are only appropriate requests retried?

✓ Are POST retries safe?

✓ Are 429 responses handled?

✓ Are 5xx failures handled?

✓ Are non-JSON errors tolerated?

✓ Are empty bodies handled?

✓ Is pagination implemented safely?

✓ Are tokens kept out of logs?

✓ Is HttpClient reused?

✓ Is ObjectMapper reused?

✓ Are interrupted threads re-interrupted?

✓ Are huge result sets prevented from exhausting memory?

If the answer is yes to most of these, you're already well beyond a basic tutorial client.

Final Thoughts

Building a REST client is easy.

Building one that behaves well when the network is slow, the API is overloaded, rate limits are reached, or data is paginated takes more thought.

The biggest production improvements are usually not complicated individually:

timeouts
retries
backoff
jitter
rate-limit handling
pagination
error classification

The real value comes from combining them consistently.

A useful mental model is:

Request
   ↓
Timeout protection
   ↓
Send
   ↓
Temporary failure?
   ↓ yes
Retry safely
   ↓
Backoff + jitter
   ↓
Respect rate limits
   ↓
Receive response
   ↓
Validate status
   ↓
Parse JSON
   ↓
Return Java object

And architecturally:

Application
    ↓
API-specific client
    ↓
Reusable RestClient
    ↓
HttpClient + Jackson
    ↓
External API

The goal is not to hide every possible failure.

The goal is to make failure behavior predictable.

That is what separates a demo REST client from a production-ready one.

About the Author

Deividas Strole is a Full-Stack Developer based in California, specializing in Java, Spring Boot, JavaScript, React, SQL, and AI-powered applications. He writes about software engineering, modern full-stack development, and digital marketing.

Connect with me:

🌐 Portfolio
💼 LinkedIn
💻 GitHub
🎥 YouTube
✍️ Medium
🐦 X
👽 Reddit
🚀 Lake Apps
🔧 Strole Consulting

Building a REST API Client with Java HttpClient + Jackson

Deividas Strole — Sun, 20 Sep 2026 05:43:54 +0000

Building a REST API Client with Java `HttpClient` + Jackson

Java's built-in HttpClient is great for sending HTTP requests.

Jackson is great for converting JSON into Java objects.

Put them together, and you have everything you need to build a clean REST API client without introducing a heavyweight framework.

In this tutorial, we'll build a reusable API client that can:

Send GET requests
Send POST requests
Convert JSON responses into Java objects
Convert Java objects into JSON
Deserialize JSON arrays into List<T>
Work with Java records
Handle HTTP errors
Reuse HttpClient
Reuse Jackson's ObjectMapper
Support bearer-token authentication
Add timeouts
Build a cleaner generic REST client

By the end, we'll have a small client that feels much closer to production code than a simple one-off HTTP request.

1. The Problem

Suppose an API returns this JSON:

{
  "id": 1,
  "name": "Alice",
  "email": "alice@example.com"
}

Using only HttpClient, we can retrieve it as a String:

HttpResponse<String> response = client.send(
        request,
        HttpResponse.BodyHandlers.ofString()
);

String json = response.body();

That works.

But now our application has this:

String json;

when what we really want is this:

User user;

That's where Jackson comes in.

Jackson can convert:

JSON
 ↓
Java object

and also:

Java object
 ↓
JSON

So the architecture becomes:

HttpClient
    ↓
HTTP request
    ↓
REST API
    ↓
JSON response
    ↓
Jackson
    ↓
Java object

2. Add Jackson to Your Project

If you're using Maven, add Jackson Databind:

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.20.0</version>
</dependency>

If you're using Gradle:

implementation("com.fasterxml.jackson.core:jackson-databind:2.20.0")

Jackson Databind pulls in the core Jackson libraries we need for JSON serialization and deserialization.

3. Create a Java Model

Let's start with a simple API response:

{
  "id": 1,
  "name": "Alice",
  "email": "alice@example.com"
}

We can represent it using a Java record:

public record User(
        int id,
        String name,
        String email
) {
}

Records are a great fit for API models because they are concise and immutable.

Instead of writing:

public class User {

    private int id;
    private String name;
    private String email;

    // constructor
    // getters
    // setters
}

we can simply write:

public record User(
        int id,
        String name,
        String email
) {
}

4. Create an `ObjectMapper`

Jackson's main class is:

ObjectMapper

Create one like this:

import com.fasterxml.jackson.databind.ObjectMapper;

ObjectMapper mapper = new ObjectMapper();

You can think of ObjectMapper as the object that translates between Java and JSON.

For example:

JSON String
    ↓
ObjectMapper
    ↓
User

And in the opposite direction:

User
    ↓
ObjectMapper
    ↓
JSON String

Just like HttpClient, you should generally reuse one ObjectMapper instead of creating a new one for every request.

5. Converting JSON into a Java Object

Suppose we have:

String json = """
        {
          "id": 1,
          "name": "Alice",
          "email": "alice@example.com"
        }
        """;

Jackson can convert it into a User:

User user = mapper.readValue(
        json,
        User.class
);

Now:

System.out.println(user.name());

prints:

Alice

And:

System.out.println(user.email());

prints:

alice@example.com

This is called deserialization.

JSON
 ↓
Java object

6. Converting a Java Object into JSON

Jackson can also go the other way.

Suppose we have:

User user = new User(
        1,
        "Alice",
        "alice@example.com"
);

Convert it into JSON:

String json = mapper.writeValueAsString(user);

The result will look like:

{"id":1,"name":"Alice","email":"alice@example.com"}

This is called serialization.

Java object
 ↓
JSON

7. Your First `HttpClient` + Jackson GET Request

Now let's combine both libraries.

We'll use JSONPlaceholder for our examples.

The endpoint:

https://jsonplaceholder.typicode.com/users/1

returns JSON similar to:

{
  "id": 1,
  "name": "Leanne Graham",
  "username": "Bret",
  "email": "Sincere@april.biz"
}

For simplicity, our record can ignore fields we don't need.

public record User(
        int id,
        String name,
        String email
) {
}

However, by default Jackson may complain about JSON fields that are not represented in our record.

We can configure it to ignore unknown fields:

import com.fasterxml.jackson.databind.DeserializationFeature;

ObjectMapper mapper = new ObjectMapper()
        .configure(
                DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,
                false
        );

Now let's make the request:

HttpClient client = HttpClient.newHttpClient();

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create(
                "https://jsonplaceholder.typicode.com/users/1"
        ))
        .GET()
        .build();

HttpResponse<String> response = client.send(
        request,
        HttpResponse.BodyHandlers.ofString()
);

User user = mapper.readValue(
        response.body(),
        User.class
);

System.out.println(user);

Complete example:

import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {

    public static void main(String[] args) throws Exception {

        HttpClient client = HttpClient.newHttpClient();

        ObjectMapper mapper = new ObjectMapper()
                .configure(
                        DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,
                        false
                );

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(
                        "https://jsonplaceholder.typicode.com/users/1"
                ))
                .GET()
                .build();

        HttpResponse<String> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

        User user = mapper.readValue(
                response.body(),
                User.class
        );

        System.out.println(user);
    }
}

And our record:

public record User(
        int id,
        String name,
        String email
) {
}

8. Check the Status Code Before Parsing JSON

There is one important problem with the previous example.

We immediately parse:

response.body()

But what if the server returns:

404 Not Found

or:

500 Internal Server Error

The response body may not contain the JSON structure we expect.

So check the status code first:

if (response.statusCode() >= 200 &&
    response.statusCode() < 300) {

    User user = mapper.readValue(
            response.body(),
            User.class
    );

    System.out.println(user);

} else {

    System.err.println(
            "HTTP error: " + response.statusCode()
    );
}

A useful rule is:

Send request
    ↓
Check status
    ↓
Parse JSON

Not:

Send request
    ↓
Immediately parse everything

9. Create a Reusable GET Method

Let's start making this more useful.

Instead of repeating the same code, we can create:

public <T> T get(
        String url,
        Class<T> responseType
)

The Class<T> argument tells Jackson which Java type to create.

Example implementation:

public <T> T get(
        String url,
        Class<T> responseType
) throws IOException, InterruptedException {

    HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Accept", "application/json")
            .GET()
            .build();

    HttpResponse<String> response = client.send(
            request,
            HttpResponse.BodyHandlers.ofString()
    );

    if (response.statusCode() >= 200 &&
        response.statusCode() < 300) {

        return mapper.readValue(
                response.body(),
                responseType
        );
    }

    throw new IOException(
            "HTTP " + response.statusCode()
    );
}

Now we can write:

User user = api.get(
        "https://jsonplaceholder.typicode.com/users/1",
        User.class
);

Instead of manually dealing with JSON every time.

10. Build the API Client Class

Let's put the pieces into a reusable class.

import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;

public class RestClient {

    private final HttpClient client;
    private final ObjectMapper mapper;

    public RestClient() {

        client = HttpClient.newBuilder()
                .connectTimeout(Duration.ofSeconds(10))
                .build();

        mapper = new ObjectMapper()
                .configure(
                        DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,
                        false
                );
    }

    public <T> T get(
            String url,
            Class<T> responseType
    ) throws IOException, InterruptedException {

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .timeout(Duration.ofSeconds(20))
                .header("Accept", "application/json")
                .GET()
                .build();

        HttpResponse<String> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

        if (response.statusCode() >= 200 &&
            response.statusCode() < 300) {

            return mapper.readValue(
                    response.body(),
                    responseType
            );
        }

        throw new IOException(
                "HTTP " +
                response.statusCode() +
                ": " +
                response.body()
        );
    }
}

Usage:

RestClient client = new RestClient();

User user = client.get(
        "https://jsonplaceholder.typicode.com/users/1",
        User.class
);

System.out.println(user.name());

This is already much cleaner.

11. Sending a Java Object with POST

Now let's add POST support.

Suppose we want to send:

CreatePostRequest post = new CreatePostRequest(
        "Learning Java",
        "HttpClient and Jackson work nicely together",
        1
);

Define the record:

public record CreatePostRequest(
        String title,
        String body,
        int userId
) {
}

Jackson can serialize it:

String json = mapper.writeValueAsString(post);

Then we can send that JSON with HttpClient.

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create(url))
        .header("Content-Type", "application/json")
        .POST(
                HttpRequest.BodyPublishers.ofString(json)
        )
        .build();

12. Create a Generic POST Method

Let's make POST reusable too.

public <T, R> R post(
        String url,
        T requestBody,
        Class<R> responseType
) throws IOException, InterruptedException {

    String json = mapper.writeValueAsString(
            requestBody
    );

    HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .timeout(Duration.ofSeconds(20))
            .header(
                    "Accept",
                    "application/json"
            )
            .header(
                    "Content-Type",
                    "application/json"
            )
            .POST(
                    HttpRequest.BodyPublishers.ofString(json)
            )
            .build();

    HttpResponse<String> response = client.send(
            request,
            HttpResponse.BodyHandlers.ofString()
    );

    if (response.statusCode() >= 200 &&
        response.statusCode() < 300) {

        return mapper.readValue(
                response.body(),
                responseType
        );
    }

    throw new IOException(
            "HTTP " +
            response.statusCode() +
            ": " +
            response.body()
    );
}

Notice the generic types:

<T, R>

Here:

T = request body type
R = response body type

For example:

CreatePostRequest
        ↓
        T

Post
        ↓
        R

Usage:

CreatePostRequest request =
        new CreatePostRequest(
                "Learning Java",
                "HttpClient + Jackson",
                1
        );

Post response = client.post(
        "https://jsonplaceholder.typicode.com/posts",
        request,
        Post.class
);

13. Complete POST Example

Let's create the request type:

public record CreatePostRequest(
        String title,
        String body,
        int userId
) {
}

And the response type:

public record Post(
        int id,
        String title,
        String body,
        int userId
) {
}

Then:

RestClient client = new RestClient();

CreatePostRequest request =
        new CreatePostRequest(
                "Java HTTP Client",
                "Sending objects instead of manually building JSON",
                1
        );

Post post = client.post(
        "https://jsonplaceholder.typicode.com/posts",
        request,
        Post.class
);

System.out.println(post);

Now our application does not manually deal with JSON strings at all.

We send:

CreatePostRequest

and receive:

Post

The client handles the JSON conversion.

14. The Flow Now Looks Much Better

Our application code:

CreatePostRequest request =
        new CreatePostRequest(
                "Hello",
                "REST API",
                1
        );

Post post = client.post(
        endpoint,
        request,
        Post.class
);

Internally:

CreatePostRequest
       ↓
Jackson
       ↓
JSON
       ↓
HttpClient
       ↓
REST API
       ↓
JSON
       ↓
Jackson
       ↓
Post

This separation is very useful.

Your application works with Java objects.

The API client deals with HTTP and JSON.

15. What About JSON Arrays?

Suppose this endpoint:

https://jsonplaceholder.typicode.com/users

returns:

[
  {
    "id": 1,
    "name": "Leanne Graham"
  },
  {
    "id": 2,
    "name": "Ervin Howell"
  }
]

We want:

List<User>

You might expect this to work:

client.get(
        url,
        List<User>.class
);

But Java does not allow:

List<User>.class

because of type erasure.

So we need another approach.

16. Using `TypeReference`

Jackson provides:

TypeReference<T>

We can deserialize a list like this:

List<User> users = mapper.readValue(
        json,
        new TypeReference<List<User>>() {}
);

You will need:

import com.fasterxml.jackson.core.type.TypeReference;

The strange-looking:

new TypeReference<List<User>>() {}

preserves the generic type information Jackson needs.

17. Add a `TypeReference` GET Method

We can overload our get() method:

public <T> T get(
        String url,
        TypeReference<T> responseType
) throws IOException, InterruptedException {

    HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .timeout(Duration.ofSeconds(20))
            .header("Accept", "application/json")
            .GET()
            .build();

    HttpResponse<String> response = client.send(
            request,
            HttpResponse.BodyHandlers.ofString()
    );

    if (response.statusCode() >= 200 &&
        response.statusCode() < 300) {

        return mapper.readValue(
                response.body(),
                responseType
        );
    }

    throw new IOException(
            "HTTP " +
            response.statusCode() +
            ": " +
            response.body()
    );
}

Now:

List<User> users = client.get(
        "https://jsonplaceholder.typicode.com/users",
        new TypeReference<List<User>>() {}
);

And then:

for (User user : users) {
    System.out.println(user.name());
}

18. Why `Class<T>` Works for One Object but Not `List<T>`

This works:

User.class

because the runtime knows:

User

But this doesn't exist:

List<User>.class

At runtime, Java mostly sees:

List

instead of:

List<User>

This is due to type erasure.

Jackson's TypeReference gives it enough information to reconstruct:

List<User>

So a useful rule is:

Single object
    → Class<T>

Generic type
    → TypeReference<T>

Examples:

User.class

for:

User

and:

new TypeReference<List<User>>() {}

for:

List<User>

19. Supporting Bearer Tokens

Many real APIs require authentication.

For example:

Authorization: Bearer YOUR_TOKEN

We could add the token when creating our client.

public class RestClient {

    private final HttpClient client;
    private final ObjectMapper mapper;
    private final String token;

    public RestClient(String token) {
        this.token = token;

        client = HttpClient.newHttpClient();
        mapper = new ObjectMapper();
    }
}

Then add it to every request:

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create(url))
        .header(
                "Authorization",
                "Bearer " + token
        )
        .header(
                "Accept",
                "application/json"
        )
        .GET()
        .build();

But don't hardcode real secrets into your source code.

Prefer something like:

String token = System.getenv("API_TOKEN");

Then:

RestClient client =
        new RestClient(token);

20. Avoid Repeating Headers

Once the client becomes larger, repeated request-building code starts becoming annoying.

For example, we keep writing:

.header("Accept", "application/json")

and maybe:

.header(
        "Authorization",
        "Bearer " + token
)

We can create a helper method:

private HttpRequest.Builder requestBuilder(
        String url
) {

    HttpRequest.Builder builder =
            HttpRequest.newBuilder()
                    .uri(URI.create(url))
                    .timeout(
                            Duration.ofSeconds(20)
                    )
                    .header(
                            "Accept",
                            "application/json"
                    );

    if (token != null &&
        !token.isBlank()) {

        builder.header(
                "Authorization",
                "Bearer " + token
        );
    }

    return builder;
}

Then GET becomes:

HttpRequest request = requestBuilder(url)
        .GET()
        .build();

And POST becomes:

HttpRequest request = requestBuilder(url)
        .header(
                "Content-Type",
                "application/json"
        )
        .POST(
                HttpRequest.BodyPublishers.ofString(json)
        )
        .build();

Much cleaner.

21. Don't Create a New `HttpClient` Per Request

This is worth repeating.

Avoid this:

public User getUser() {

    HttpClient client =
            HttpClient.newHttpClient();

    // request
}

every time a request is made.

Instead:

private final HttpClient client;

and create it once:

client = HttpClient.newBuilder()
        .connectTimeout(
                Duration.ofSeconds(10)
        )
        .build();

Then reuse it.

A shared HttpClient can reuse connections and manage resources more efficiently.

22. Reuse `ObjectMapper` Too

The same idea applies to Jackson.

Avoid:

new ObjectMapper()

inside every method.

Instead:

private final ObjectMapper mapper;

Then initialize it once:

mapper = new ObjectMapper()
        .configure(
                DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,
                false
        );

ObjectMapper is designed to be reused after configuration.

23. Handling Empty Responses

Not every API response contains JSON.

For example:

204 No Content

If you blindly do:

mapper.readValue(
        response.body(),
        responseType
);

you may get a parsing error because there is no body.

One approach is to check:

if (response.statusCode() == 204) {
    return null;
}

Or create separate methods for operations that do not return data.

For example:

public void delete(String url)

instead of forcing every request to return an object.

24. Add DELETE Support

A simple DELETE method might look like this:

public void delete(
        String url
) throws IOException, InterruptedException {

    HttpRequest request = requestBuilder(url)
            .DELETE()
            .build();

    HttpResponse<String> response = client.send(
            request,
            HttpResponse.BodyHandlers.ofString()
    );

    if (response.statusCode() < 200 ||
        response.statusCode() >= 300) {

        throw new IOException(
                "HTTP " +
                response.statusCode() +
                ": " +
                response.body()
        );
    }
}

Usage:

client.delete(
        "https://example.com/users/10"
);

25. Add PUT Support

We can use the same serialization pattern as POST:

public <T, R> R put(
        String url,
        T requestBody,
        Class<R> responseType
) throws IOException, InterruptedException {

    String json =
            mapper.writeValueAsString(
                    requestBody
            );

    HttpRequest request =
            requestBuilder(url)
                    .header(
                            "Content-Type",
                            "application/json"
                    )
                    .PUT(
                            HttpRequest.BodyPublishers
                                    .ofString(json)
                    )
                    .build();

    HttpResponse<String> response =
            client.send(
                    request,
                    HttpResponse.BodyHandlers.ofString()
            );

    if (response.statusCode() >= 200 &&
        response.statusCode() < 300) {

        return mapper.readValue(
                response.body(),
                responseType
        );
    }

    throw new IOException(
            "HTTP " +
            response.statusCode() +
            ": " +
            response.body()
    );
}

26. Add PATCH Support

HttpRequest.Builder doesn't have a dedicated .PATCH() method.

Use:

.method()

Example:

HttpRequest request = requestBuilder(url)
        .header(
                "Content-Type",
                "application/json"
        )
        .method(
                "PATCH",
                HttpRequest.BodyPublishers.ofString(json)
        )
        .build();

We can create:

public <T, R> R patch(
        String url,
        T requestBody,
        Class<R> responseType
)

using the same pattern as POST and PUT.

27. We Are Starting to Repeat Ourselves

Look at GET:

build request
send request
check status
deserialize

POST:

serialize
build request
send request
check status
deserialize

PUT:

serialize
build request
send request
check status
deserialize

PATCH:

serialize
build request
send request
check status
deserialize

This is a sign that we can refactor.

28. Create a Shared Response Handler

We can move the repeated response processing into one method:

private <T> T handleResponse(
        HttpResponse<String> response,
        Class<T> responseType
) throws IOException {

    int status = response.statusCode();

    if (status < 200 || status >= 300) {

        throw new IOException(
                "HTTP " +
                status +
                ": " +
                response.body()
        );
    }

    return mapper.readValue(
            response.body(),
            responseType
    );
}

Now methods become smaller:

public <T> T get(
        String url,
        Class<T> responseType
) throws IOException, InterruptedException {

    HttpRequest request =
            requestBuilder(url)
                    .GET()
                    .build();

    HttpResponse<String> response =
            client.send(
                    request,
                    HttpResponse.BodyHandlers.ofString()
            );

    return handleResponse(
            response,
            responseType
    );
}

Much cleaner.

29. Create a Custom API Exception

Throwing a generic:

IOException

for an HTTP 404 or 500 works for a small example, but we can make errors clearer.

Create:

public class ApiException
        extends RuntimeException {

    private final int statusCode;

    public ApiException(
            int statusCode,
            String message
    ) {
        super(message);
        this.statusCode = statusCode;
    }

    public int statusCode() {
        return statusCode;
    }
}

Then:

throw new ApiException(
        response.statusCode(),
        response.body()
);

Now callers can distinguish:

catch (ApiException e) {

    if (e.statusCode() == 404) {
        System.out.println(
                "Resource not found"
        );
    }
}

That's more expressive than treating every HTTP status as a networking problem.

30. Network Errors and API Errors Are Different

A useful distinction is:

Network problem
    ↓
IOException

Server responded with 404 / 500
    ↓
ApiException

For example:

try {

    User user = client.get(
            url,
            User.class
    );

} catch (ApiException e) {

    System.err.println(
            "API error: " +
            e.statusCode()
    );

} catch (IOException e) {

    System.err.println(
            "Network error: " +
            e.getMessage()
    );

}

This makes error handling much clearer.

31. A More Complete `RestClient`

Let's combine the ideas into a cleaner reusable client.

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;

public class RestClient {

    private final HttpClient client;
    private final ObjectMapper mapper;
    private final String token;

    public RestClient() {
        this(null);
    }

    public RestClient(String token) {

        this.token = token;

        this.client = HttpClient.newBuilder()
                .connectTimeout(
                        Duration.ofSeconds(10)
                )
                .build();

        this.mapper = new ObjectMapper()
                .configure(
                        DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,
                        false
                );
    }

    public <T> T get(
            String url,
            Class<T> responseType
    ) throws IOException, InterruptedException {

        HttpRequest request =
                requestBuilder(url)
                        .GET()
                        .build();

        HttpResponse<String> response =
                send(request);

        return read(
                response,
                responseType
        );
    }

    public <T> T get(
            String url,
            TypeReference<T> responseType
    ) throws IOException, InterruptedException {

        HttpRequest request =
                requestBuilder(url)
                        .GET()
                        .build();

        HttpResponse<String> response =
                send(request);

        validate(response);

        return mapper.readValue(
                response.body(),
                responseType
        );
    }

    public <T, R> R post(
            String url,
            T requestBody,
            Class<R> responseType
    ) throws IOException, InterruptedException {

        String json =
                mapper.writeValueAsString(
                        requestBody
                );

        HttpRequest request =
                requestBuilder(url)
                        .header(
                                "Content-Type",
                                "application/json"
                        )
                        .POST(
                                HttpRequest.BodyPublishers
                                        .ofString(json)
                        )
                        .build();

        HttpResponse<String> response =
                send(request);

        return read(
                response,
                responseType
        );
    }

    public void delete(
            String url
    ) throws IOException, InterruptedException {

        HttpRequest request =
                requestBuilder(url)
                        .DELETE()
                        .build();

        HttpResponse<String> response =
                send(request);

        validate(response);
    }

    private HttpRequest.Builder requestBuilder(
            String url
    ) {

        HttpRequest.Builder builder =
                HttpRequest.newBuilder()
                        .uri(URI.create(url))
                        .timeout(
                                Duration.ofSeconds(20)
                        )
                        .header(
                                "Accept",
                                "application/json"
                        );

        if (token != null &&
            !token.isBlank()) {

            builder.header(
                    "Authorization",
                    "Bearer " + token
            );
        }

        return builder;
    }

    private HttpResponse<String> send(
            HttpRequest request
    ) throws IOException, InterruptedException {

        try {

            return client.send(
                    request,
                    HttpResponse.BodyHandlers.ofString()
            );

        } catch (InterruptedException e) {

            Thread.currentThread()
                    .interrupt();

            throw e;
        }
    }

    private void validate(
            HttpResponse<String> response
    ) {

        int status =
                response.statusCode();

        if (status < 200 ||
            status >= 300) {

            throw new ApiException(
                    status,
                    response.body()
            );
        }
    }

    private <T> T read(
            HttpResponse<String> response,
            Class<T> responseType
    ) throws IOException {

        validate(response);

        if (response.statusCode() == 204 ||
            response.body() == null ||
            response.body().isBlank()) {

            return null;
        }

        return mapper.readValue(
                response.body(),
                responseType
        );
    }
}

And the custom exception:

public class ApiException
        extends RuntimeException {

    private final int statusCode;

    public ApiException(
            int statusCode,
            String message
    ) {

        super(message);

        this.statusCode =
                statusCode;
    }

    public int statusCode() {
        return statusCode;
    }
}

32. Using the Client

GET one object

RestClient client =
        new RestClient();

User user = client.get(
        "https://jsonplaceholder.typicode.com/users/1",
        User.class
);

System.out.println(user.name());

GET a list

List<User> users = client.get(
        "https://jsonplaceholder.typicode.com/users",
        new TypeReference<List<User>>() {}
);

Then:

users.forEach(
        user ->
                System.out.println(
                        user.name()
                )
);

POST an object

CreatePostRequest request =
        new CreatePostRequest(
                "Java REST Client",
                "Using HttpClient and Jackson",
                1
        );

Post post = client.post(
        "https://jsonplaceholder.typicode.com/posts",
        request,
        Post.class
);

System.out.println(post);

DELETE

client.delete(
        "https://jsonplaceholder.typicode.com/posts/1"
);

33. Using an Authenticated Client

If an API requires a bearer token:

String token =
        System.getenv("API_TOKEN");

RestClient client =
        new RestClient(token);

Every request created by the client will include:

Authorization: Bearer ...

This avoids repeating authentication code everywhere.

34. What About Date and Time Types?

Suppose your API returns:

{
  "id": 1,
  "createdAt": "2026-09-06T18:30:00"
}

And your model uses:

LocalDateTime

For example:

public record Event(
        int id,
        LocalDateTime createdAt
) {
}

You should add Jackson's Java Time module.

Maven:

<dependency>
    <groupId>com.fasterxml.jackson.datatype</groupId>
    <artifactId>jackson-datatype-jsr310</artifactId>
    <version>2.20.0</version>
</dependency>

Then:

ObjectMapper mapper =
        new ObjectMapper();

mapper.findAndRegisterModules();

Or explicitly:

mapper.registerModule(
        new JavaTimeModule()
);

For modern Java applications, registering the Java Time module is usually a good idea.

35. Naming Differences Between JSON and Java

Suppose the API returns:

{
  "user_name": "Alice"
}

But your Java record uses:

userName

You can map the property explicitly:

import com.fasterxml.jackson.annotation.JsonProperty;

public record User(
        @JsonProperty("user_name")
        String userName
) {
}

Now Jackson knows:

user_name
    ↓
userName

36. Ignore JSON Fields You Don't Need

Suppose the server returns:

{
  "id": 1,
  "name": "Alice",
  "internal_code": "ABC",
  "created_by": "system",
  "something_else": true
}

But your application only needs:

public record User(
        int id,
        String name
) {
}

You can configure Jackson globally:

mapper.configure(
        DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,
        false
);

Or annotate a particular type:

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

@JsonIgnoreProperties(ignoreUnknown = true)
public record User(
        int id,
        String name
) {
}

This is very useful because APIs often return more data than your application needs.

37. Don't Put API Logic Everywhere

Without a client layer, application code often becomes:

HttpClient client = ...
HttpRequest request = ...
HttpResponse<String> response = ...
ObjectMapper mapper = ...
User user = ...

inside controllers, services, UI code, scheduled jobs, and other places.

That quickly becomes messy.

Instead:

Application
    ↓
UserApi
    ↓
RestClient
    ↓
HttpClient + Jackson

For example:

public class UserApi {

    private final RestClient client;

    public UserApi(
            RestClient client
    ) {
        this.client = client;
    }

    public User getUser(
            int id
    ) throws Exception {

        return client.get(
                "https://example.com/users/" + id,
                User.class
        );
    }
}

Then application code becomes:

User user =
        userApi.getUser(10);

This is much easier to read.

38. Create API-Specific Classes

A generic RestClient is useful for infrastructure.

But your application should preferably expose methods related to the domain.

Instead of:

restClient.get(
        "https://example.com/users/10",
        User.class
);

everywhere, create:

public class UserApi {

    private final RestClient client;
    private final String baseUrl;

    public UserApi(
            RestClient client,
            String baseUrl
    ) {

        this.client = client;
        this.baseUrl = baseUrl;
    }

    public User findById(
            int id
    ) throws Exception {

        return client.get(
                baseUrl + "/users/" + id,
                User.class
        );
    }
}

Usage:

User user =
        userApi.findById(10);

Now the rest of your application doesn't need to know:

HTTP
URLs
JSON
Jackson
headers

It just works with:

User

39. A Better Architecture

A clean application might look like this:

Application / Service
        ↓
UserApi
        ↓
RestClient
        ↓
HttpClient
        +
ObjectMapper
        ↓
External REST API

Each layer has one responsibility.

`HttpClient`

Handles HTTP communication.

`ObjectMapper`

Handles JSON.

`RestClient`

Handles reusable HTTP + JSON mechanics.

`UserApi`

Knows the external API's endpoints.

Application

Works with domain objects.

This separation becomes increasingly valuable as the project grows.

40. Synchronous vs Asynchronous APIs

Everything we've built so far uses:

client.send()

which is synchronous.

But Java also supports:

client.sendAsync()

which returns:

CompletableFuture<HttpResponse<String>>

We could create:

public <T> CompletableFuture<T> getAsync(
        String url,
        Class<T> responseType
)

For example:

public <T> CompletableFuture<T> getAsync(
        String url,
        Class<T> responseType
) {

    HttpRequest request =
            requestBuilder(url)
                    .GET()
                    .build();

    return client.sendAsync(
            request,
            HttpResponse.BodyHandlers.ofString()
    ).thenApply(response -> {

        validate(response);

        try {

            return mapper.readValue(
                    response.body(),
                    responseType
            );

        } catch (IOException e) {

            throw new RuntimeException(e);
        }
    });
}

Usage:

CompletableFuture<User> future =
        client.getAsync(
                url,
                User.class
        );

future.thenAccept(
        user ->
                System.out.println(
                        user.name()
                )
);

For many applications, synchronous methods are simpler.

But async methods can be useful when multiple requests can run concurrently.

41. Quick Cheat Sheet

Java object to JSON

String json =
        mapper.writeValueAsString(object);

JSON to Java object

User user =
        mapper.readValue(
                json,
                User.class
        );

JSON array to `List<User>`

List<User> users =
        mapper.readValue(
                json,
                new TypeReference<List<User>>() {}
        );

GET request

HttpRequest request =
        HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header(
                        "Accept",
                        "application/json"
                )
                .GET()
                .build();

POST JSON

String json =
        mapper.writeValueAsString(object);

HttpRequest request =
        HttpRequest.newBuilder()
                .uri(URI.create(url))
                .header(
                        "Content-Type",
                        "application/json"
                )
                .POST(
                        HttpRequest.BodyPublishers
                                .ofString(json)
                )
                .build();

Parse response

HttpResponse<String> response =
        client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

User user =
        mapper.readValue(
                response.body(),
                User.class
        );

Bearer token

.header(
    "Authorization",
    "Bearer " + token
)

Ignore unknown JSON fields

mapper.configure(
        DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,
        false
);

42. The Mental Model

The most important thing to understand is the division of responsibilities.

HttpClient
    ↓
handles HTTP

ObjectMapper
    ↓
handles JSON

For a GET:

GET /users/1
      ↓
HttpClient
      ↓
JSON response
      ↓
ObjectMapper
      ↓
User

For a POST:

CreateUserRequest
      ↓
ObjectMapper
      ↓
JSON
      ↓
HttpClient
      ↓
POST /users
      ↓
JSON response
      ↓
ObjectMapper
      ↓
User

Once you see the flow this way, building REST clients becomes much easier.

Final Thoughts

Java's built-in HttpClient and Jackson make a very capable combination.

HttpClient gives us:

HTTP/1.1 and HTTP/2
GET
POST
PUT
DELETE
PATCH
Headers
Authentication
Timeouts
Synchronous requests
Asynchronous requests

Jackson gives us:

JSON serialization
JSON deserialization
Records support
Generic type handling
Custom property mappings
Date/time support
Flexible configuration

Together, they allow us to write application code like:

User user =
        userApi.findById(10);

instead of spreading this everywhere:

HttpClient
HttpRequest
HttpResponse
ObjectMapper
JSON
status codes
headers

That's the real goal of a good REST API client:

keep HTTP and JSON details at the boundary of your application, while the rest of your code works with normal Java objects.

A good progression is:

HttpClient basics
        ↓
HttpClient + Jackson
        ↓
Reusable RestClient
        ↓
API-specific client classes
        ↓
Authentication
        ↓
Retries / rate limits / pagination
        ↓
Production-ready API integration

The next useful step is building a production-ready Java REST client with retries, rate limiting, pagination, authentication, and custom error responses.

About the Author

Connect with me:

🌐 Portfolio
💼 LinkedIn
💻 GitHub
🎥 YouTube
✍️ Medium
🐦 X
👽 Reddit
🚀 Lake Apps
🔧 Strole Consulting

Java HTTP Requests Made Easy: A Practical Guide to java.net.http

Deividas Strole — Mon, 07 Sep 2026 03:07:44 +0000

If you're building a Java application that needs to communicate with a REST API, download data from a website, send JSON, or make HTTP requests, you don't necessarily need an external library.

Modern Java includes its own HTTP client in the java.net.http package.

In this tutorial, we'll learn how to use it to make:

GET requests
POST requests
Requests with headers
JSON requests
Asynchronous requests
Requests with query parameters
Requests with timeouts
Error handling

By the end, you'll have a reusable pattern for calling APIs directly from Java.

1. What is `java.net.http`?

The java.net.http package contains Java's built-in HTTP client API.

The three classes you'll use most often are:

HttpClient
HttpRequest
HttpResponse

They represent three different parts of an HTTP operation:

HttpClient
    ↓
HttpRequest
    ↓
Server / API
    ↓
HttpResponse

Think of them this way:

HttpClient   = sends requests
HttpRequest  = describes what you want to send
HttpResponse = contains what the server sends back

The API supports both HTTP/1.1 and HTTP/2.

2. Your First GET Request

Let's start with the simplest possible example.

Suppose we want to request:

https://jsonplaceholder.typicode.com/posts/1

We first create an HttpClient.

HttpClient client = HttpClient.newHttpClient();

Then create an HttpRequest.

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://jsonplaceholder.typicode.com/posts/1"))
        .GET()
        .build();

Finally, send the request.

HttpResponse<String> response = client.send(
        request,
        HttpResponse.BodyHandlers.ofString()
);

Here is the complete program:

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {

    public static void main(String[] args) throws Exception {

        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(
                        "https://jsonplaceholder.typicode.com/posts/1"
                ))
                .GET()
                .build();

        HttpResponse<String> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

        System.out.println(response.body());
    }
}

The response should look similar to:

{
  "userId": 1,
  "id": 1,
  "title": "sunt aut facere repellat provident occaecati excepturi optio reprehenderit",
  "body": "quia et suscipit..."
}

Notice something important:

HttpResponse<String>

We told Java that we want the response body converted into a String.

That happens because we used:

HttpResponse.BodyHandlers.ofString()

3. Reading the HTTP Status Code

Usually, you don't want to blindly trust the body.

You should first check the HTTP status code.

System.out.println(response.statusCode());

For example:

means the request was successful.

Common HTTP codes include:

200  OK
201  Created
204  No Content

400  Bad Request
401  Unauthorized
403  Forbidden
404  Not Found

500  Internal Server Error
503  Service Unavailable

You can handle the response like this:

if (response.statusCode() >= 200 &&
    response.statusCode() < 300) {

    System.out.println(response.body());

} else {

    System.out.println(
            "Request failed: " + response.statusCode()
    );
}

This is a much safer pattern than assuming every HTTP request succeeds.

4. Adding Request Headers

Real APIs often require headers.

For example:

Accept: application/json
Authorization: Bearer TOKEN
User-Agent: MyJavaApplication

You can add a header using:

.header()

Example:

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://example.com/api"))
        .header("Accept", "application/json")
        .header("User-Agent", "MyJavaApp")
        .GET()
        .build();

You can also use:

.headers()

Example:

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://example.com/api"))
        .headers(
                "Accept", "application/json",
                "User-Agent", "MyJavaApp"
        )
        .GET()
        .build();

5. Sending an Authorization Token

Many APIs use bearer-token authentication.

The HTTP header looks like:

Authorization: Bearer YOUR_TOKEN

In Java:

String token = "YOUR_TOKEN";

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://example.com/api/users"))
        .header(
                "Authorization",
                "Bearer " + token
        )
        .GET()
        .build();

For production applications, avoid hardcoding secret API keys directly into source code.

Instead, use environment variables or another secret-management mechanism.

For example:

String token = System.getenv("API_TOKEN");

6. Sending a POST Request

GET requests retrieve information.

POST requests usually send information.

Suppose we want to send this JSON:

{
  "title": "Learning Java HTTP Client",
  "body": "java.net.http is surprisingly convenient",
  "userId": 1
}

First create the JSON as a string:

String json = """
        {
          "title": "Learning Java HTTP Client",
          "body": "java.net.http is surprisingly convenient",
          "userId": 1
        }
        """;

Then construct the request:

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create(
                "https://jsonplaceholder.typicode.com/posts"
        ))
        .header("Content-Type", "application/json")
        .POST(
                HttpRequest.BodyPublishers.ofString(json)
        )
        .build();

Send it normally:

HttpResponse<String> response = client.send(
        request,
        HttpResponse.BodyHandlers.ofString()
);

Complete example:

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class PostExample {

    public static void main(String[] args) throws Exception {

        HttpClient client = HttpClient.newHttpClient();

        String json = """
                {
                  "title": "Learning Java HTTP Client",
                  "body": "java.net.http is surprisingly convenient",
                  "userId": 1
                }
                """;

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(
                        "https://jsonplaceholder.typicode.com/posts"
                ))
                .header(
                        "Content-Type",
                        "application/json"
                )
                .POST(
                        HttpRequest.BodyPublishers.ofString(json)
                )
                .build();

        HttpResponse<String> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

        System.out.println(
                "Status: " + response.statusCode()
        );

        System.out.println(response.body());
    }
}

7. What Are `BodyPublishers`?

You'll notice this code:

HttpRequest.BodyPublishers.ofString(json)

A BodyPublisher tells Java how to create the body of the HTTP request.

For a string:

HttpRequest.BodyPublishers.ofString("Hello")

For no body:

HttpRequest.BodyPublishers.noBody()

For a file:

HttpRequest.BodyPublishers.ofFile(path)

For raw bytes:

HttpRequest.BodyPublishers.ofByteArray(bytes)

A useful mental model is:

BodyPublisher = data going OUT

8. What Are `BodyHandlers`?

A BodyHandler tells Java how you want to receive the server's response.

For text:

HttpResponse.BodyHandlers.ofString()

For bytes:

HttpResponse.BodyHandlers.ofByteArray()

To save directly to a file:

HttpResponse.BodyHandlers.ofFile(path)

To ignore the body:

HttpResponse.BodyHandlers.discarding()

A useful mental model is:

BodyPublisher = request body going OUT
BodyHandler   = response body coming IN

For example:

HttpResponse<byte[]> response = client.send(
        request,
        HttpResponse.BodyHandlers.ofByteArray()
);

Now:

response.body()

returns:

byte[]

instead of a String.

9. Downloading a File

The HTTP client can also download files.

For example:

Path destination = Path.of("image.jpg");

HttpResponse<Path> response = client.send(
        request,
        HttpResponse.BodyHandlers.ofFile(destination)
);

Complete example:

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Path;

public class DownloadExample {

    public static void main(String[] args) throws Exception {

        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(
                        "https://example.com/image.jpg"
                ))
                .GET()
                .build();

        Path file = Path.of("image.jpg");

        HttpResponse<Path> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofFile(file)
        );

        System.out.println(
                "Downloaded to: " + response.body()
        );
    }
}

10. Adding a Timeout

Network requests can hang or take longer than expected.

For that reason, you should usually configure timeouts.

You can configure a connection timeout when creating the client:

HttpClient client = HttpClient.newBuilder()
        .connectTimeout(Duration.ofSeconds(10))
        .build();

And a request timeout:

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://example.com"))
        .timeout(Duration.ofSeconds(20))
        .GET()
        .build();

You will need:

import java.time.Duration;

11. HTTP/2

Java's HTTP client supports HTTP/2.

You can explicitly request it:

HttpClient client = HttpClient.newBuilder()
        .version(HttpClient.Version.HTTP_2)
        .build();

You can check which version was actually used:

System.out.println(response.version());

Possible results include:

HTTP_1_1
HTTP_2

12. Sending PUT Requests

PUT is commonly used for replacing or updating resources.

Example:

String json = """
        {
          "name": "John"
        }
        """;

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create(
                "https://example.com/users/10"
        ))
        .header("Content-Type", "application/json")
        .PUT(
                HttpRequest.BodyPublishers.ofString(json)
        )
        .build();

13. Sending DELETE Requests

DELETE is simple:

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create(
                "https://example.com/users/10"
        ))
        .DELETE()
        .build();

Then send it as usual:

HttpResponse<String> response = client.send(
        request,
        HttpResponse.BodyHandlers.ofString()
);

14. Sending PATCH Requests

HttpRequest.Builder has convenient methods for:

GET
POST
PUT
DELETE

But there isn't a dedicated .PATCH() method.

Use .method() instead:

String json = """
        {
          "email": "john@example.com"
        }
        """;

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create(
                "https://example.com/users/10"
        ))
        .header("Content-Type", "application/json")
        .method(
                "PATCH",
                HttpRequest.BodyPublishers.ofString(json)
        )
        .build();

15. GET Requests with Query Parameters

Imagine an API expects:

https://example.com/search?q=java&page=2

A simple request is:

String url =
        "https://example.com/search?q=java&page=2";

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create(url))
        .GET()
        .build();

But values containing spaces or special characters should be URL-encoded.

For example:

String search = URLEncoder.encode(
        "Java HTTP Client",
        StandardCharsets.UTF_8
);

Then:

String url =
        "https://example.com/search?q=" + search;

You will need:

import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;

16. Synchronous vs Asynchronous Requests

So far, we've been using:

client.send()

This is synchronous.

That means Java waits until the server responds.

send request
     ↓
wait
     ↓
receive response
     ↓
continue program

Example:

HttpResponse<String> response =
        client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

Java also provides:

sendAsync()

17. Making an Asynchronous Request

An asynchronous request looks like this:

client.sendAsync(
        request,
        HttpResponse.BodyHandlers.ofString()
);

Instead of returning:

HttpResponse<String>

it returns:

CompletableFuture<HttpResponse<String>>

Example:

CompletableFuture<HttpResponse<String>> future =
        client.sendAsync(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

You can process the response when it becomes available:

future.thenAccept(response -> {
    System.out.println(response.statusCode());
    System.out.println(response.body());
});

Complete example:

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class AsyncExample {

    public static void main(String[] args) {

        HttpClient client =
                HttpClient.newHttpClient();

        HttpRequest request =
                HttpRequest.newBuilder()
                        .uri(URI.create(
                                "https://jsonplaceholder.typicode.com/posts/1"
                        ))
                        .GET()
                        .build();

        client.sendAsync(
                request,
                HttpResponse.BodyHandlers.ofString()
        ).thenAccept(response -> {

            System.out.println(
                    response.statusCode()
            );

            System.out.println(
                    response.body()
            );

        }).join();
    }
}

The .join() keeps this small demo program alive until the asynchronous operation finishes.

18. Why Use `sendAsync()`?

Imagine you need data from three APIs.

With synchronous requests:

Request A ──────── finish
                   Request B ─────── finish
                                       Request C ───── finish

The total time can roughly become:

A + B + C

With asynchronous requests, they can run concurrently:

Request A ──────────
Request B ──────
Request C ─────────────

Example:

var request1 = HttpRequest.newBuilder()
        .uri(URI.create(
                "https://jsonplaceholder.typicode.com/posts/1"
        ))
        .GET()
        .build();

var request2 = HttpRequest.newBuilder()
        .uri(URI.create(
                "https://jsonplaceholder.typicode.com/posts/2"
        ))
        .GET()
        .build();

var future1 = client.sendAsync(
        request1,
        HttpResponse.BodyHandlers.ofString()
);

var future2 = client.sendAsync(
        request2,
        HttpResponse.BodyHandlers.ofString()
);

var response1 = future1.join();
var response2 = future2.join();

System.out.println(response1.body());
System.out.println(response2.body());

19. Reading Response Headers

The HTTP response contains more than just a body.

You can get all headers with:

response.headers()

Example:

System.out.println(
        response.headers().map()
);

You can retrieve one specific header:

response.headers()
        .firstValue("content-type")
        .ifPresent(System.out::println);

firstValue() returns an Optional because the header may not exist.

20. Handling Exceptions Properly

Earlier examples used:

throws Exception

That's convenient for tutorials, but production code should handle exceptions more carefully.

client.send() can throw:

IOException
InterruptedException

A better example:

try {

    HttpResponse<String> response =
            client.send(
                    request,
                    HttpResponse.BodyHandlers.ofString()
            );

    System.out.println(response.body());

} catch (IOException e) {

    System.err.println(
            "Network error: " + e.getMessage()
    );

} catch (InterruptedException e) {

    Thread.currentThread().interrupt();

    System.err.println(
            "Request was interrupted"
    );
}

Calling:

Thread.currentThread().interrupt();

restores the thread's interrupted status.

21. Network Failure Is Different from HTTP Failure

This distinction is important.

Suppose a server returns:

404 Not Found

Java does not normally throw an exception just because the server returned a 404.

You still receive an:

HttpResponse

and:

response.statusCode()

might return:

Exceptions are more likely for things such as:

DNS failure
connection failure
network interruption
timeout

So your application should handle both HTTP failures and network failures.

try {

    HttpResponse<String> response =
            client.send(
                    request,
                    HttpResponse.BodyHandlers.ofString()
            );

    if (response.statusCode() >= 200 &&
        response.statusCode() < 300) {

        System.out.println(response.body());

    } else {

        System.err.println(
                "HTTP error: " +
                response.statusCode()
        );
    }

} catch (IOException e) {

    System.err.println(
            "Network error: " + e.getMessage()
    );

} catch (InterruptedException e) {

    Thread.currentThread().interrupt();
}

22. Creating a Reusable API Method

Once you start making multiple requests, repeating the same code becomes annoying.

You can create a reusable method:

public static String get(String url)
        throws IOException, InterruptedException {

    HttpClient client =
            HttpClient.newHttpClient();

    HttpRequest request =
            HttpRequest.newBuilder()
                    .uri(URI.create(url))
                    .GET()
                    .build();

    HttpResponse<String> response =
            client.send(
                    request,
                    HttpResponse.BodyHandlers.ofString()
            );

    if (response.statusCode() >= 200 &&
        response.statusCode() < 300) {

        return response.body();
    }

    throw new IOException(
            "HTTP error: " +
            response.statusCode()
    );
}

Then calling an API becomes:

String result = get(
        "https://jsonplaceholder.typicode.com/posts/1"
);

System.out.println(result);

23. Reuse `HttpClient`

There's one improvement we should make to the previous example.

Instead of creating a new HttpClient for every request, you should generally reuse one.

public class ApiClient {

    private final HttpClient client;

    public ApiClient() {

        this.client = HttpClient.newBuilder()
                .connectTimeout(
                        Duration.ofSeconds(10)
                )
                .build();
    }

    public String get(String url)
            throws IOException, InterruptedException {

        HttpRequest request =
                HttpRequest.newBuilder()
                        .uri(URI.create(url))
                        .timeout(
                                Duration.ofSeconds(20)
                        )
                        .GET()
                        .build();

        HttpResponse<String> response =
                client.send(
                        request,
                        HttpResponse.BodyHandlers.ofString()
                );

        if (response.statusCode() >= 200 &&
            response.statusCode() < 300) {

            return response.body();
        }

        throw new IOException(
                "HTTP " +
                response.statusCode() +
                ": " +
                response.body()
        );
    }
}

Usage:

ApiClient api = new ApiClient();

String response = api.get(
        "https://jsonplaceholder.typicode.com/posts/1"
);

System.out.println(response);

This is closer to how HTTP code is usually structured in a real application.

24. But What About JSON?

One thing java.net.http does not try to be is a complete JSON library.

Suppose an API returns:

{
  "id": 1,
  "name": "John"
}

java.net.http can retrieve it:

String json = response.body();

But converting that JSON into:

User user;

is normally handled by another library.

Popular choices include:

Jackson
Gson
JSON-B

A common architecture looks like this:

java.net.http
       ↓
HTTP communication
       ↓
JSON String
       ↓
Jackson / Gson
       ↓
Java object

For example, with Jackson:

String json = response.body();

User user = objectMapper.readValue(
        json,
        User.class
);

The HTTP client handles networking.

The JSON library handles serialization and deserialization.

25. A More Realistic REST API Client

Putting everything together:

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;

public class RestClient {

    private final HttpClient client;

    public RestClient() {

        client = HttpClient.newBuilder()
                .connectTimeout(
                        Duration.ofSeconds(10)
                )
                .build();
    }

    public String get(String url)
            throws IOException, InterruptedException {

        HttpRequest request =
                HttpRequest.newBuilder()
                        .uri(URI.create(url))
                        .timeout(
                                Duration.ofSeconds(20)
                        )
                        .header(
                                "Accept",
                                "application/json"
                        )
                        .GET()
                        .build();

        return send(request);
    }

    public String post(
            String url,
            String json
    ) throws IOException, InterruptedException {

        HttpRequest request =
                HttpRequest.newBuilder()
                        .uri(URI.create(url))
                        .timeout(
                                Duration.ofSeconds(20)
                        )
                        .header(
                                "Accept",
                                "application/json"
                        )
                        .header(
                                "Content-Type",
                                "application/json"
                        )
                        .POST(
                                HttpRequest.BodyPublishers
                                        .ofString(json)
                        )
                        .build();

        return send(request);
    }

    private String send(HttpRequest request)
            throws IOException, InterruptedException {

        HttpResponse<String> response =
                client.send(
                        request,
                        HttpResponse.BodyHandlers.ofString()
                );

        int status = response.statusCode();

        if (status >= 200 && status < 300) {
            return response.body();
        }

        throw new IOException(
                "HTTP " +
                status +
                ": " +
                response.body()
        );
    }
}

Now your application code becomes very simple:

RestClient client = new RestClient();

String result = client.get(
        "https://jsonplaceholder.typicode.com/posts/1"
);

System.out.println(result);

Or:

String json = """
        {
          "title": "Hello",
          "body": "Java HTTP Client",
          "userId": 1
        }
        """;

String result = client.post(
        "https://jsonplaceholder.typicode.com/posts",
        json
);

System.out.println(result);

26. Quick Cheat Sheet

Create a client

HttpClient client =
        HttpClient.newHttpClient();

GET

HttpRequest request =
        HttpRequest.newBuilder()
                .uri(URI.create(url))
                .GET()
                .build();

POST

HttpRequest request =
        HttpRequest.newBuilder()
                .uri(URI.create(url))
                .POST(
                        HttpRequest.BodyPublishers
                                .ofString(body)
                )
                .build();

PUT

.PUT(
    HttpRequest.BodyPublishers.ofString(body)
)

DELETE

.DELETE()

PATCH

.method(
    "PATCH",
    HttpRequest.BodyPublishers.ofString(body)
)

Add a header

.header(
    "Content-Type",
    "application/json"
)

Send synchronously

HttpResponse<String> response =
        client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

Send asynchronously

client.sendAsync(
        request,
        HttpResponse.BodyHandlers.ofString()
);

Status code

response.statusCode()

Response body

response.body()

Response headers

response.headers()

27. The Mental Model

If you remember nothing else from this tutorial, remember this pattern:

HttpClient client = HttpClient.newHttpClient();

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create(url))
        .GET()
        .build();

HttpResponse<String> response = client.send(
        request,
        HttpResponse.BodyHandlers.ofString()
);

System.out.println(response.body());

Or visually:

1. Create HttpClient
        ↓
2. Build HttpRequest
        ↓
3. client.send(...)
        ↓
4. Receive HttpResponse
        ↓
5. Check statusCode()
        ↓
6. Read body()

Once that pattern makes sense, most of the API becomes easy to understand.

Final Thoughts

Java's built-in HTTP client is easy to overlook because developers often immediately reach for external dependencies.

But for many applications, java.net.http gives you everything you need:

HTTP/1.1
HTTP/2
GET
POST
PUT
DELETE
PATCH
Headers
Authentication headers
Request bodies
File downloads
Timeouts
Synchronous requests
Asynchronous requests

For simple REST API clients, scripts, desktop applications, microservices, and backend integrations, it can be more than enough.

The main thing it does not replace is a JSON serialization library such as Jackson or Gson.

A useful separation of responsibilities is:

java.net.http
    → talks to the server

Jackson / Gson
    → translates JSON

Your application
    → handles business logic

And that's often all you need to build a clean Java API client.

If you found this useful, the next logical step is combining java.net.http + Jackson to automatically convert API responses into Java records and objects.

About the Author

Connect with me:

🌐 Portfolio
💼 LinkedIn
💻 GitHub
🎥 YouTube
✍️ Medium
🐦 X
👽 Reddit
🚀 Lake Apps
🔧 Strole Consulting

Why Java Is a Great Choice for AI Development

Deividas Strole — Sun, 09 Aug 2026 19:54:41 +0000

When people think about artificial intelligence, Python is usually the first language that comes to mind. It has an enormous AI and machine learning ecosystem is simple and easy to learn.

But Python is not the only good choice.

For production applications, especially enterprise systems, Java can be an excellent language for building AI-powered software. Modern Java applications can connect to large language models, run machine learning models, build retrieval-augmented generation systems, process large amounts of data, and expose AI capabilities through scalable APIs.

In this tutorial, we’ll look at why Java works well for AI development and where it fits best.

1. Java Is Already Everywhere in Enterprise Software

One of Java’s biggest advantages is that companies already use it.

Java powers:

Backend APIs
Banking systems
E-commerce platforms
Enterprise applications
Microservices
Data-processing systems
Cloud applications

When a company wants to introduce AI into an existing Java platform, rewriting the application in Python usually doesn’t make much sense.

Instead, AI can become another capability inside the existing Java architecture.

React Frontend
      ↓
Spring Boot API
      ↓
AI Service
      ↓
OpenAI / Local Model / Vector Database

The application remains a normal Java system while AI becomes one component of it.

2. Spring Boot Makes AI Integration Natural

Java developers already have a mature framework for building production services: Spring Boot.

An AI-powered endpoint can look very similar to any other REST endpoint.

@RestController
@RequestMapping("/api/ai")
public class AiController {

    private final AiService aiService;

    public AiController(AiService aiService) {
        this.aiService = aiService;
    }

    @PostMapping("/ask")
    public String ask(@RequestBody String question) {
        return aiService.ask(question);
    }
}

Your AI functionality can then live inside a service:

@Service
public class AiService {

    public String ask(String question) {
        // Call an AI model here
        return "AI response for: " + question;
    }
}

This architecture is familiar to Java developers:

Controller
    ↓
Service
    ↓
AI Provider

You can combine AI with authentication, databases, caching, queues, logging, monitoring, and the rest of your application without creating a completely separate technology stack.

3. Spring AI Makes Java AI Development Easier

The Spring ecosystem includes Spring AI, which provides abstractions designed specifically for AI applications.

Instead of creating custom integrations for every model provider, developers can work with higher-level APIs.

A basic example might look like this:

@Service
public class ChatService {

    private final ChatClient chatClient;

    public ChatService(ChatClient.Builder builder) {
        this.chatClient = builder.build();
    }

    public String ask(String question) {
        return chatClient
                .prompt()
                .user(question)
                .call()
                .content();
    }
}

Then your controller can expose it:

@RestController
@RequestMapping("/chat")
public class ChatController {

    private final ChatService chatService;

    public ChatController(ChatService chatService) {
        this.chatService = chatService;
    }

    @GetMapping
    public String chat(@RequestParam String question) {
        return chatService.ask(question);
    }
}

Spring AI supports concepts commonly needed in modern AI applications, including:

Chat models
Embeddings
Vector stores
Prompt templates
Tool calling
Retrieval-Augmented Generation
Structured output
Model-provider abstractions

This makes Java much more attractive for developers building AI into existing Spring applications.

4. Java Is Excellent for AI APIs

Most production AI systems are not simply machine learning notebooks.

They are applications.

Consider an AI customer-support platform.

It might need to:

Authenticate the user.
Retrieve customer information.
Search internal documentation.
Generate embeddings.
Query a vector database.
Send relevant context to an LLM.
Store the conversation.
Log the request.
Return a response to the frontend.

Java is extremely well suited for this type of architecture.

User
 ↓
React
 ↓
Spring Boot
 ├── Authentication
 ├── PostgreSQL
 ├── Vector Database
 ├── Business Logic
 ├── AI Model
 └── Monitoring

The AI model is only one part of the system.

The rest is traditional software engineering—and that is where Java is very strong.

5. Java Works Well With Retrieval-Augmented Generation

One of the most useful AI architectures today is Retrieval-Augmented Generation, usually called RAG.

Instead of asking an LLM to answer purely from its training data, your application retrieves relevant information first.

The basic architecture looks like this:

Question
   ↓
Embedding Model
   ↓
Vector Search
   ↓
Relevant Documents
   ↓
LLM
   ↓
Answer

Imagine building an internal company assistant.

A user asks:

"What is our refund policy for enterprise customers?"

Your Java application can retrieve relevant documents and create a prompt:

String question = "What is our refund policy for enterprise customers?";

List<Document> documents = vectorStore.similaritySearch(question);

String context = documents.stream()
        .map(Document::getText)
        .collect(Collectors.joining("\n"));

String prompt = """
        Answer the question using the following information.

        Context:
        %s

        Question:
        %s
        """.formatted(context, question);

The final prompt can then be sent to the model.

This allows Java developers to build AI systems grounded in company-specific information.

6. Java Has Strong Concurrency Support

AI applications often involve many simultaneous operations.

For example:

Request
 ├── Database lookup
 ├── Vector search
 ├── External AI API call
 └── Logging

Java has mature concurrency capabilities and continues to improve them.

Modern Java includes virtual threads, which make handling large numbers of blocking operations much easier.

For AI services that make many external API calls, this can be especially useful.

Developers can often keep straightforward synchronous code while still supporting many concurrent requests.

7. Java Is Fast

AI development involves two different types of computation.

Model Computation

This is usually handled by:

GPUs
Specialized inference engines
Cloud AI providers
Dedicated model servers

Application Computation

This includes:

HTTP requests
Authentication
Data transformation
Database queries
Business rules
Caching
Search
Message processing

Java is very strong at the second category.

The JVM has decades of optimization behind it and performs extremely well for long-running backend services.

For production AI platforms, this matters.

8. Java Is Strongly Typed

AI APIs frequently return structured information.

For example:

{
  "symbol": "AAPL",
  "trend": "bullish",
  "confidence": 0.84
}

In Java, that can become a record:

public record StockAnalysis(
        String symbol,
        String trend,
        double confidence
) {}

Now the rest of your application can work with strongly typed data instead of loosely structured strings.

StockAnalysis analysis = aiService.analyze("AAPL");

if (analysis.confidence() > 0.8) {
    // Perform additional processing
}

Typed data provides better:

IDE support
Refactoring
Validation
Compile-time checking
Maintainability

This becomes increasingly valuable as AI systems grow.

9. Java Has a Mature Production Ecosystem

An AI demo is relatively easy to build.

A production AI platform is much harder.

You eventually need things like:

Authentication
Authorization
Database migrations
API validation
Rate limiting
Caching
Logging
Testing
Monitoring
Metrics
Retries
Circuit breakers
Deployment
Security

Java has mature libraries and frameworks for all of these problems.

For example:

Spring Boot
Spring Security
Spring Data
Hibernate
JUnit
Mockito
Resilience4j
Micrometer
Docker
Kubernetes
Kafka
PostgreSQL
Redis

This ecosystem is one of Java’s greatest advantages for AI engineering.

10. Java Can Run Machine Learning Models Too

Java does not have to call external AI APIs for everything.

There are Java-compatible machine learning and inference libraries such as:

Deep Java Library (DJL)
ONNX Runtime
TensorFlow Java
Tribuo
Smile

For example, models trained using Python frameworks can sometimes be exported to ONNX and executed in a Java production environment.

A common architecture could look like this:

Python
  ↓
Train Model
  ↓
Export ONNX
  ↓
Java Production Service
  ↓
Inference

This gives teams access to both ecosystems.

Data scientists can use Python for experimentation while Java developers integrate models into production systems.

11. Java and Python Can Work Together

Choosing Java does not mean abandoning Python.

In many organizations, the best architecture uses both.

Python
 ├── Model training
 ├── Data science
 └── Experiments

Java
 ├── Production APIs
 ├── Business logic
 ├── Authentication
 ├── Database integration
 └── Enterprise services

The systems can communicate through:

REST
gRPC
Kafka
RabbitMQ
Cloud messaging platforms

This is often more practical than trying to use one language for everything.

12. Where Java Is Especially Good for AI

Java is particularly attractive for:

AI-Powered Enterprise Applications

Examples:

CRM + AI
ERP + AI
Banking + AI
Insurance + AI
Healthcare Platform + AI

AI Microservices

Spring Boot
     ↓
LLM / Embedding Model
     ↓
REST API

Retrieval-Augmented Generation Systems

Documents
    ↓
Embeddings
    ↓
Vector Database
    ↓
Java RAG Service
    ↓
LLM

AI Features Inside Existing Java Applications

Examples include:

Document summarization
Semantic search
Recommendation systems
Fraud detection
Customer-support assistants
Market analysis
Document classification
Natural-language interfaces
Automated reporting

13. When Python May Still Be Better

Java is not automatically the best language for every AI task.

Python remains the strongest choice for many areas of AI research and model development.

If your main work involves:

Training neural networks
Experimenting with models
Data science notebooks
Computer vision research
NLP research
Building new ML algorithms

Python will usually provide the easiest ecosystem.

Libraries such as PyTorch, TensorFlow, NumPy, pandas, scikit-learn, and Hugging Face remain extremely important.

But that does not mean your entire production application has to be written in Python.

A common pattern is:

Python → Build the intelligence

Java → Build the product around it

Conclusion

Java may not be the language most strongly associated with artificial intelligence, but it has an important role in modern AI development.

Java provides:

Excellent backend performance
Strong typing
Mature enterprise frameworks
Powerful concurrency
Spring Boot integration
Growing AI tooling such as Spring AI
Access to machine learning inference libraries
Excellent infrastructure for production systems

Python will continue to dominate AI research and experimentation.

But as AI moves from notebooks into real business applications, languages used to build reliable production systems become increasingly important.

That is where Java becomes extremely interesting.

The future of AI development probably won't be Java versus Python.

It will increasingly be:

Python + Java + AI models + cloud infrastructure

with each technology doing what it does best.

About the Author

Connect with me:

🌐 Portfolio
💼 LinkedIn
💻 GitHub
🎥 YouTube
✍️ Medium
🐦 X
👽 Reddit
🚀 Lake Apps
🔧 Strole Consulting

Tags: #java #ai #artificialintelligence #springboot #springai #machinelearning #backend

Why Java Is Still Important and Relevant in 2026

Deividas Strole — Mon, 06 Jul 2026 01:11:14 +0000

Java has been around for more than 30 years, and every few years someone asks the same question:

"Is Java still relevant?"

In 2026, the answer is still YES!.

Java is not the newest or flashiest programming language, but it remains one of the most important languages in real-world software development. It powers enterprise systems, banking platforms, Android-related ecosystems, backend APIs, cloud services, microservices, data pipelines, and large-scale applications that need to be reliable and maintainable.

Java is not popular only because of legacy code. Java is still relevant because it keeps evolving.

JDK 25 reached general availability on September 16, 2025, and Java 25 is an LTS (Long-Term Support for you regular people) release, which means Java continues to receive long-term platform investment. JDK 26 reached general availability on March 17, 2026, as a non-LTS release under Java's six-month release cadence, but Java 25 remains the LTS version many enterprise teams are likely to target.

1. Java Is Still Everywhere in Enterprise Development

Many companies use Java because it is stable, mature, and proven.

Banks, insurance companies, logistics companies, healthcare systems, government platforms, and large SaaS businesses often need software that can run for many years. They care about:

Stability
Security
Performance
Long-term support
Large developer talent pool
Strong tooling
Maintainable code
Reliable backend architecture

Java fits these needs very well.

This is one reason Java remains common in backend job postings and enterprise software projects. Even when frontend trends change quickly, backend systems often need long-term reliability.

Java is especially strong for:

REST APIs
Microservices
Payment systems
Internal business tools
Authentication systems
Reporting systems
Cloud applications
Large database-backed applications

2. Java Has a Huge Ecosystem

One of Java's biggest strengths is not only the language itself. It is the ecosystem around it.

Java developers have access to mature tools and frameworks such as:

Spring Boot
Spring Framework
Hibernate
Maven
Gradle
JUnit
Mockito
Jakarta EE
Quarkus
Micronaut
Apache Kafka
Tomcat
Jetty

Spring Boot is still one of the most important Java frameworks for backend development. The official Spring Boot project describes it as a way to create stand-alone, production-grade Spring applications.

That matters because modern companies do not usually build plain Java applications from scratch. They build applications using frameworks, libraries, testing tools, security modules, database layers, and cloud integrations.

Java has all of that.

3. Java Is Modern Now

Some developers still think Java means old-style verbose code. That used to be more true, but modern Java is much cleaner than older Java.

For example, Java now supports features like records, switch expressions, text blocks, pattern matching, improved garbage collectors, better performance, and many API improvements.

Compare an older Java class:

public class User {
    private Long id;
    private String username;
    private String email;

    public User(Long id, String username, String email) {
        this.id = id;
        this.username = username;
        this.email = email;
    }

    public Long getId() {
        return id;
    }

    public String getUsername() {
        return username;
    }

    public String getEmail() {
        return email;
    }
}

With a modern Java record:

public record User(Long id, String username, String email) {
}

That is much cleaner.

Java is still strongly typed and structured, but it is no longer as heavy as many people remember.

4. Java Is Great for Learning Backend Development

If you want to understand backend development seriously, Java is a very good language to learn.

Why? Because Java teaches important concepts clearly:

Object-oriented programming
Type safety
Interfaces
Dependency injection
Layered architecture
Testing
Exception handling
Database access
API design
Build tools
Application configuration

These concepts transfer to many other languages and frameworks.

A Java Spring Boot project usually teaches you how real backend applications are structured:

Controller layer
Service layer
Repository layer
Entity/model layer
DTO layer
Configuration layer
Security layer
Test layer

Here is a minimal controller that shows several of these concepts at once: a REST endpoint, dependency injection, and delegation to a service layer.

@RestController
@RequestMapping("/api/users")
public class UserController {

    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserResponse getUser(@PathVariable Long id) {
        return userService.getUserById(id);
    }
}

That is why Java is not just useful for jobs. It is useful for learning how professional software is built.

5. Java Works Very Well With Databases

Most business applications are database applications.

They need to store users, orders, invoices, payments, messages, logs, reports, and other records.

Java has excellent database support through:

JDBC
Spring Data JPA
Hibernate
JPA
Flyway
Liquibase
PostgreSQL drivers
MySQL drivers
MongoDB drivers
Redis clients

Example Spring Data repository:

public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);
}

With this small interface, Spring Data JPA can automatically provide database operations such as save, findById, findAll, delete, and findByEmail — no implementation required.

This makes Java very productive for real-world backend development.

6. Java Is Strong for Large Applications

Some languages are great for small scripts or quick prototypes. Java can also be used for small apps, but its real strength appears in large applications.

Java is good for large codebases because it has:

Static typing
Clear package structure
Mature IDE support
Refactoring tools
Strong testing ecosystem
Build automation
Dependency management
Long-term readability

In large teams, this matters a lot.

When many developers work on the same application, the code must be understandable, testable, and safe to change. Java's structure helps with that.

For example, this kind of interface-based design is common in Java applications:

public interface PaymentService {
    PaymentResult processPayment(PaymentRequest request);
}

Then you can have different implementations:

@Service
public class StripePaymentService implements PaymentService {

    @Override
    public PaymentResult processPayment(PaymentRequest request) {
        // process payment with Stripe
        return new PaymentResult("SUCCESS");
    }
}

This style makes applications easier to test and extend.

7. Java Has Excellent Tooling

Java has some of the best developer tooling in the software world.

Popular Java tools include:

IntelliJ IDEA
Eclipse
VS Code
Maven
Gradle
JUnit
Mockito
Testcontainers
Spring Initializr
VisualVM
JProfiler
Docker
Kubernetes

A good IDE can rename classes, extract methods, generate constructors, find usages, debug applications, run tests, inspect dependencies, and help with refactoring.

This makes Java very productive, especially in large applications.

8. Java Is Cloud and Microservice Friendly

Modern Java is not only for old enterprise servers.

Java is widely used in cloud-native development with:

Docker
Kubernetes
AWS
Google Cloud
Azure
Spring Boot
Quarkus
Micronaut
Kafka
RabbitMQ
Redis
PostgreSQL
MySQL

A basic Java Spring Boot application can be containerized with Docker:

FROM eclipse-temurin:25-jdk

WORKDIR /app

COPY target/myapp.jar app.jar

EXPOSE 8080

ENTRYPOINT ["java", "-jar", "app.jar"]

Then it can run as a cloud service, microservice, or containerized backend API.

Java has adapted very well to modern backend architecture.

9. Java Is Still Popular

Java continues to appear near the top of many programming language popularity rankings. The TIOBE Index, which tracks programming language popularity based on search engine results and other signals, continues to list Java among major programming languages.

Popularity rankings are not perfect. They do not prove that one language is "better" than another. But they do show that Java is still widely discussed, searched, taught, and used.

Java also has a very large learning ecosystem:

Official documentation
Books
Courses
YouTube tutorials
Stack Overflow answers
Open-source projects
Enterprise examples
Spring guides
Dev.to articles

For a developer, this is important. When you get stuck, there is usually an answer somewhere.

10. Java Is a Good Career Investment

Java is still a practical career skill in 2026.

It is especially valuable if you want to work in:

Backend development
Full-stack development
Enterprise software
Financial technology
Insurance systems
Healthcare software
Government systems
Cloud services
Android-related ecosystems
Microservices
DevOps-heavy backend teams

Learning Java also makes it easier to learn other typed languages such as:

C#
Kotlin
Scala
TypeScript
Go

Even if you later move to another language, Java gives you a strong foundation.

11. Java and AI Development

AI tools are changing how developers write code, but they do not remove the need to understand programming fundamentals.

In fact, AI makes fundamentals more important.

If an AI tool generates Java code, you still need to know whether the code is correct, secure, efficient, and maintainable.

You need to understand:

What the code does
How dependencies work
How exceptions are handled
Whether the database query is safe
Whether the API design makes sense
Whether the test actually tests the correct behavior

AI can help generate code, but professional developers still need to review, debug, improve, and maintain that code.

Java's clear structure can actually help here because it makes generated backend code easier to inspect.

12. Putting It All Together

Here is how the pieces from the sections above — a record, a service, and a controller — combine into a small but complete Spring Boot REST endpoint.

User response record

public record UserResponse(
        Long id,
        String username,
        String email
) {
}

Service layer

@Service
public class UserService {

    public UserResponse getUserById(Long id) {
        return new UserResponse(
                id,
                "deividas",
                "deividas@example.com"
        );
    }
}

Controller layer

@RestController
@RequestMapping("/api/users")
public class UserController {

    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserResponse getUser(@PathVariable Long id) {
        return userService.getUserById(id);
    }
}

Calling GET /api/users/1 returns:

{
  "id": 1,
  "username": "deividas",
  "email": "deividas@example.com"
}

This simple example shows why Java is still useful. You can build clear, structured, production-style backend APIs with very little code.

13. When Java May Not Be the Best Choice

Java is important, but it is not always the best tool for every job.

Java may not be the best first choice for:

Small automation scripts
Very quick prototypes
Simple static websites
Data science notebooks
Small command-line experiments

For those cases, Python, JavaScript, Bash, or another tool may be faster.

But for long-term backend systems, APIs, enterprise platforms, and large applications, Java remains one of the strongest choices.

Conclusion

Java is still important in 2026 because it solves real problems.

It is stable, mature, fast, scalable, and widely used. It has a huge ecosystem, strong tooling, excellent backend frameworks, and long-term support. Modern Java is also cleaner and more developer-friendly than older versions.

Java may not always be trendy, but it is practical.

And in professional software development, practical matters.

If you want to become a backend or full-stack developer, Java is still worth learning in 2026.

Not because it is old.

Because it is still used to build serious software.

About the Author

Connect with me:

🌐 Portfolio
💼 LinkedIn
💻 GitHub
🎥 YouTube
✍️ Medium
🐦 X
👽 Reddit
🚀 Lake Apps

Three Months with Java 26: My Thoughts After Using the Latest Release

Deividas Strole — Sat, 27 Jun 2026 02:53:28 +0000

Three Months with Java 26: My Thoughts After Using the Latest Release

Java 26 was officially released on March 17, 2026, and after spending the past three months exploring its improvements, experimenting with new APIs, and using it in personal projects, I think it's a good time to share my impressions.

Unlike launch-day articles that simply list every new feature, this is a practical look at what stood out to me after having some time to work with Java 26.

Some improvements are immediately noticeable, while others continue Java's long-term evolution toward a faster, safer, and more productive platform. Although Java 26 isn't a revolutionary release, it continues the predictable six-month release cycle with meaningful refinements.

In this article, I'll share the features and improvements I found most interesting, what I like, what I'll continue using, and whether I think Java 26 is worth upgrading to.

Why Upgrade to Java 26?

Every Java release makes the platform a little better by improving:

Performance
Security
Developer productivity
Runtime reliability

Even if you don't immediately use every new API, upgrading allows you to benefit from JVM optimizations, bug fixes, and tooling improvements.

1. Real Java 26 Highlights

While Java 26 doesn't introduce sweeping new stable language features, it does deliver meaningful improvements worth knowing about.

Post-Quantum and Cryptography Improvements

Java 26 takes security seriously with several new capabilities: hybrid public key encryption (HPKE), post-quantum ready JAR signing, and updated support for Unicode 17.0 and CLDR v48. These aren't flashy, but they matter for production applications.

G1 GC Throughput Gains

One of my favorite concrete improvements in this release: G1 Garbage Collector improvements reduce synchronization overhead between application and GC threads, delivering up to 15% throughput gains in workloads with heavy object-reference modifications. That's a real, measurable win for many server-side applications.

Foreign Function & Memory API Continues to Mature

The Foreign Function & Memory (FFM) API is one of the most important recent additions to Java. Finalized in JDK 22, it provides a modern way for Java applications to interact with native libraries while offering safer and more efficient memory management than traditional JNI.

Although most developers won't use it every day, it remains an important step toward making Java interoperability with native code much simpler.

Applet API Removed

Java 26 permanently removes the Applet API, which had been deprecated since Java 9 and marked for removal since Java 17. No modern browser has supported applets for years, so this is a long-overdue cleanup that trims legacy baggage from the platform.

AOT Object Caching with Any GC

Java 26 improves Ahead-of-Time (AOT) object caching by making it compatible with any garbage collector, including ZGC. Previously, AOT caching was limited to Serial, Parallel, and G1 collectors. This expands the performance benefits of AOT to teams running latency-sensitive applications on ZGC.

2. Better Performance Behind the Scenes

One thing I appreciate about Java is that every release includes work that most developers never directly notice.

Java 26 continues refining the JVM with improvements focused on runtime performance, startup time, memory efficiency, and overall stability. Many of these optimizations happen behind the scenes, allowing existing applications to benefit without requiring code changes.

3. Pattern Matching Makes Code Cleaner

Pattern matching isn't new in Java 26, but after using it regularly across several releases, I can't imagine going back.

Instead of writing:

if (obj instanceof String) {
    String text = (String) obj;
    System.out.println(text.length());
}

You can simply write:

if (obj instanceof String text) {
    System.out.println(text.length());
}

The instanceof operator checks whether obj is actually a String. If it is, Java automatically creates the variable text, eliminating the need for an explicit cast.

It's a small change that makes everyday code much cleaner.

4. Records Continue to Be One of My Favorite Features

Records were introduced several Java releases ago, but they're still one of my favorite additions.

public record User(
    Long id,
    String name,
    String email
) {}

Instead of writing constructors, getters, equals(), hashCode(), and toString() manually, Java generates them automatically.

5. Better Developer Experience

Another thing I appreciate is how Java continues improving the overall developer experience.

Small improvements to compiler diagnostics, debugging tools, profiling, runtime monitoring, and IDE support add up over time.

6. Virtual Threads Are Becoming More Practical

Virtual Threads were introduced before Java 26, but they continue to be one of the most exciting modern Java features and are increasingly well-supported across the ecosystem.

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {

    executor.submit(() -> {
        System.out.println("Running...");
    });

}

Here, var allows Java to infer the variable type automatically, so you don't have to write the full type name.

Virtual Threads are especially useful for:

REST APIs
Microservices
Web servers
Background processing

7. Switch Expressions Make Code More Readable

String result = switch(day) {
    case MONDAY -> "Work";
    case SATURDAY, SUNDAY -> "Weekend";
    default -> "Unknown";
};

No more forgotten break statements.

8. Immutable Collections Are Simple to Create

List<String> colors = List.of(
    "Red",
    "Green",
    "Blue"
);

Creating immutable collections now takes a single line instead of several.

Should You Upgrade?

If your applications are running well on your current Java version, upgrading to Java 26 isn't a necessity. However, it's definitely worth exploring if you:

Enjoy staying up to date with the latest Java releases
Want the newest performance improvements, including G1 GC throughput gains
Like experimenting with modern APIs before they reach the next LTS
Want to prepare for future LTS releases

Final Thoughts

Java continues evolving without sacrificing backward compatibility, and that's one of the reasons it remains my favorite backend language.

After spending several months using Java 26, my biggest takeaway isn't a single headline feature. Instead, it's the continued refinement of the language and platform. Each release removes a little more boilerplate, improves performance, strengthens security, and makes development just a bit more enjoyable.

While Java 26 doesn't introduce sweeping new stable language features, it delivers real, concrete improvements: better GC throughput, continued work around native interoperability, post-quantum cryptography groundwork, and a cleaner platform overall.

If you're already developing with Java, it's definitely worth downloading and exploring.

What has been your favorite Java feature recently? Let me know in the comments!

About the Author

Connect with me:

🌐 Portfolio
💼 LinkedIn
💻 GitHub
🎥 YouTube
✍️ Medium
🐦 X
👽 Reddit
🚀 Lake Apps

How to Host Your Website on GitHub Pages for Free

Deividas Strole — Sat, 20 Jun 2026 19:38:25 +0000

GitHub Pages is one of the easiest ways to publish a website online for free. It is great for portfolios, landing pages, documentation, small business websites, and simple frontend projects. I use them all the time as all my code is stored on GitHub.

In this tutorial, I will show you how to host your website using GitHub Pages step by step.

What is GitHub Pages?

GitHub Pages is a free hosting service from GitHub that lets you publish static websites directly from a GitHub repository.

You can use it to host websites built with:

HTML
CSS
JavaScript/ TypeScript
React
Vue
Documentation sites
Portfolio websites

GitHub Pages is best for static websites. That means it does not run backend code like Java, Spring Boot, PHP, or Node.js servers. However, it is perfect for frontend projects. For my bigger projects, I still use GitHub Pages for the front-end and host the back-end somewhere else.

Step 1: Create a GitHub Account

After logging in to GitHub:

Click the New button to create a new repository.
Give your repository a name.
Make the repository Public.
Click Create repository.

For example, you can name it:

deividas-strole-website

Your website URL will look something like this:

https://your-username.github.io/deividas-strole-website/

Step 3: Add Your Website Files

Your project should include at least an index.html file.

Example project structure:

deividas-strole-website/
├── index.html
├── style.css
└── script.js

Here is a simple example:

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
  <title>Deividas Strole Website</title>
  <link rel="stylesheet" href="style.css" />
</head>
<body>
  <h1>Hello from GitHub Pages!</h1>
  <p>This website is hosted for free using GitHub Pages.</p>

  <script src="script.js"></script>
</body>
</html>

You can upload the files directly through GitHub, or you can push them using Git.

Step 4: Push Your Files to GitHub

If you are using Git from your computer, open your terminal inside your project folder and run:

git init
git add .
git commit -m "Initial website files"
git branch -M main
git remote add origin https://github.com/your-username/deividas-strole-website.git
git push -u origin main

Replace:

your-username
with your GitHub username.

Also replace:

deividas-strole-website
with your repository name.

Step 5: Enable GitHub Pages

Now go to your repository on GitHub.

Then follow these steps:

Click Settings
Click Pages in the left menu
Under Build and deployment, choose Deploy from a branch
Select the branch: main
Select the folder: /root
Click Save

GitHub will now build and publish your website.

Step 6: Open Your Live Website

After a short moment, GitHub will show you your live website URL.

It will look like this:

https://your-username.github.io/deividas-strole-website/

Open that link in your browser, and your website should be live.

Congratulations! Your website is now hosted for free.

Important: Use the Correct File Paths

When using GitHub Pages, file paths are very important.

For example, if your CSS file is in the same folder as your HTML file, use:

<link rel="stylesheet" href="style.css" />

If your image is inside an images folder, use:

<img src="images/photo.jpg" alt="My photo" />

Avoid using paths that only work on your local computer, like:

C:/Users/YourName/Desktop/project/image.jpg

That will not work online.

Common GitHub Pages Problems

Website Shows a 404 Page

This usually means GitHub Pages is not enabled correctly, or your project does not have an index.html file.

Make sure your main page is named exactly:

index.html

Not:

home.html
Index.html
index.htm

The file name must be correct.

CSS or Images Are Not Loading

Check your file paths carefully.

For example, this will only work if the image is inside an images folder:

<img src="images/logo.png" alt="Logo" />

Also make sure the file names match exactly. GitHub Pages is case-sensitive.

This means these are different:

logo.png
Logo.png
LOGO.png

Changes Are Not Showing

Sometimes GitHub Pages takes a minute to update.

You can also try:

Refreshing the page
Clearing your browser cache
Checking the GitHub Pages deployment status
Making sure your latest changes were pushed to GitHub

Can You Use a Custom Domain?

Yes. GitHub Pages allows you to connect a custom domain.

For example, instead of using:

https://your-username.github.io/deividas-strole-website/

You can use something like:

https://deividasstrole.com

You need to buy a domain separately and update your DNS settings.

When Should You Use GitHub Pages?

GitHub Pages is a good choice for:

Portfolio websites
Resume websites
Landing pages
Project demos
Documentation
Simple business websites
Frontend practice projects

It is not the best choice for websites that need a backend server, database, login system, or server-side processing.

For those, you may need services like Render, Railway, Vercel, Netlify, AWS, or a VPS.

Final Thoughts

GitHub Pages is a simple and free way to publish your website online.

If you are learning web development, building a portfolio, or sharing frontend projects, GitHub Pages is one of the best tools to start with.

You do not need complicated hosting or paid servers. You only need a GitHub account, your website files, and a few minutes to publish your project.

Happy coding!

About the Author
Deividas Strole is a Full-Stack Developer based in California, specializing in Java, Spring Boot, JavaScript, React, SQL, and AI-driven development. He writes about software engineering, modern full-stack development, and digital marketing strategies.

About the Author

Deividas Strole is a Full-Stack Developer based in California, specializing in Java, Spring Boot, JavaScript, React, SQL, and AI-driven development. He writes about software engineering, modern full-stack development, and digital marketing strategies.

Connect with me:

Build a Node.js HTTP Server From Scratch (No Frameworks Needed and Less Then 30 Lines!)

Deividas Strole — Mon, 16 Mar 2026 23:08:42 +0000

Most Node.js tutorials jump straight to Express. But before you reach for a framework, it's worth understanding what's happening underneath — because once you do, everything else clicks.

In this tutorial, Deividas Strole walks you through building a simple HTTP server using only Node's built-in modules. No Express, no npm install, no dependencies of any kind. Just the runtime doing its thing.

By the end, you'll have a working local server that serves a static HTML file — and a much clearer mental model of how the web actually works.

What You'll Learn

How the Node.js http module handles requests and responses
How to read files from disk using the fs module
How to serve a static HTML page
How to handle 404 routes cleanly
How to run everything locally in under a minute

Prerequisites

Node.js installed (nodejs.org)
Basic JavaScript knowledge
A text editor (VS Code, Vim, anything works)

No package manager needed. We're going fully built-in.

Step 1: Create the HTML File

First, create index.html. This is what your server will send to the browser.

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
  <title>My Node Server</title>
  <style>
    body {
      font-family: monospace;
      background: #0d1117;
      color: #e6edf3;
      display: flex;
      align-items: center;
      justify-content: center;
      min-height: 100vh;
      margin: 0;
    }
    h1 { color: #3fb950; }
    p  { color: #8b949e; }
  </style>
</head>
<body>
  <div>
    <h1>✓ Server is running</h1>
    <p>Served by Node.js — no frameworks needed.</p>
  </div>
</body>
</html>

Simple, clean, and it'll look great in the browser.

Step 2: Create the Server

Now create server.js. This is where the magic happens.

const http = require('http');
const fs   = require('fs');
const path = require('path');

const PORT      = process.env.PORT || 3000;
const HTML_FILE = path.join(__dirname, 'index.html');

const server = http.createServer((req, res) => {
  // Only serve the root route
  if (req.url === '/' || req.url === '/index.html') {
    fs.readFile(HTML_FILE, (err, data) => {
      if (err) {
        res.writeHead(500, { 'Content-Type': 'text/plain' });
        res.end('500 Internal Server Error');
        return;
      }
      res.writeHead(200, { 'Content-Type': 'text/html' });
      res.end(data);
    });
  } else {
    // Everything else gets a 404
    res.writeHead(404, { 'Content-Type': 'text/plain' });
    res.end('404 Not Found');
  }
});

server.listen(PORT, () => {
  console.log(`✅ Server running at http://localhost:${PORT}`);
});

That's it. 30 lines. Let's break down what each part does.

Step 3: Run It

In your terminal, navigate to your project folder and run:

node server.js

Open your browser and go to http://localhost:3000. You'll see your HTML page served by your own server.
Try visiting http://localhost:3000/anything-else — you'll get the 404 response.
To stop the server, press Ctrl + C.

Full Source Code

The complete project is on GitHub:
👉 github.com/deividas-strole/node-js-server
Drop a ⭐ if you found it useful.

About the Author

Connect with me:

Super Simple Web Scraping in Java (Jsoup)

Deividas Strole — Mon, 16 Feb 2026 00:51:43 +0000

Lets create a super-duper simple web scraper with Java! For that we will need Java, Jsoup, 5 minutes and a good mood!

Add Jsoup

<dependency> 
    <groupId>org.jsoup</groupId> 
    <artifactId>jsoup</artifactId> 
    <version>1.17.2</version> 
</dependency>

Create super-duper minimal scraper

In this our example we will print all links (text and URL) from a page:

import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;

public class SimpleScraper {
    public static void main(String[] args) throws Exception {
        String url = "https://example.com"; // change this 

        Document doc = Jsoup.connect(url).get(); 

        for (Element link : doc.select("a[href]")) {            
            System.out .println(link.text() + " -> " + link.absUrl("href")); 
        }
    }
}

Thats it!!!! You are done! No models, No JSON, and no extra libraries!

Extra credit: If you want something spacific - change the selector.

Examples:

Article titles: h1, h2, h3
Product cards: .product
Price: .price
Any element by id: #price

Example: print all <h2> titles:

for (Element h : doc.select("h2")) {
  System.out.println(h.text());
}

More extra credit: In this code, the request originates from a Java client, which many websites will identify as a bot. As a result, they may block your access. To make your scraper appear as though it is coming from a real user, include this line before .get():

.userAgent("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36")

Happy Coding!!!

About the Author

Deividas Strole is a Full-Stack Developer based in California, specializing in Java, Spring Boot, React, and AI-driven development. He writes about software engineering, modern full-stack development, and digital marketing strategies.

Connect with me:

Complete Java Tutorial: From Zero to Building Real Applications

Deividas Strole — Sun, 01 Feb 2026 18:53:14 +0000

Introduction

Java is one of the oldest and most popular programming languages in the world. It is a general-purpose programming language, which means you can do with it everything... well, maybe not everything, but almost everything :)
With Java, you can do Android Mobile Development, Enterprise Applications, Web Applications, Big Data Technologies, Cloud-Based Applications, Financial Services, Scientific Applications, Game Development, Internet of Things (IoT), and other stuff... In this tutorial, you'll learn Java fundamentals and build practical projects along the way.

What you'll learn:

Java basics and syntax
Object-Oriented Programming concepts
Working with collections and data structures
File handling and exception management
Building a real-world console application

Prerequisites: Basic computer literacy. No prior programming experience required!

Part 1: Setting Up Your Java Environment

Installing Java Development Kit (JDK)

Download the latest JDK from Oracle or OpenJDK
Install and verify by opening terminal/command prompt:

java -version
javac -version

Choosing an IDE
Go with one of these:

IntelliJ IDEA Community Edition (beginner-friendly and my favorite!)
Eclipse (lightweight)
VS Code with Java extensions (if you're already familiar with VS Code)

Part 2: Your First Java Program

Let's start now with the classic "Hello, World!" program:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Breaking it down:

public class HelloWorld - Defines a class named HelloWorld
public static void main(String[] args) - The entry point of every Java program
System.out.println() - Prints text to the console

To run:

Save as HelloWorld.java
Compile: javac HelloWorld.java
Run: java HelloWorld

Part 3: Java Fundamentals

Variables and Data Types
Java is statically typed, meaning you must declare variable types:

public class DataTypes {
    public static void main(String[] args) {
        // Primitive types
        int age = 25;
        double price = 19.99;
        boolean isActive = true;
        char grade = 'A';

        // String (reference type)
        String name = "Alice";

        // Printing variables
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
        System.out.println("Price: $" + price);
    }
}

Common data types:

int - integers (whole numbers)
double - decimal numbers
boolean - true/false
char - single character
String - text

Operators

public class Operators {
    public static void main(String[] args) {
        int a = 10, b = 3;

        // Arithmetic operators
        System.out.println("Addition: " + (a + b));       // 13
        System.out.println("Subtraction: " + (a - b));    // 7
        System.out.println("Multiplication: " + (a * b)); // 30
        System.out.println("Division: " + (a / b));       // 3
        System.out.println("Modulus: " + (a % b));        // 1

        // Comparison operators
        System.out.println("Is equal: " + (a == b));      // false
        System.out.println("Is greater: " + (a > b));     // true

        // Logical operators
        boolean x = true, y = false;
        System.out.println("AND: " + (x && y));           // false
        System.out.println("OR: " + (x || y));            // true
        System.out.println("NOT: " + (!x));               // false
    }
}

Part 4: Control Flow

If-Else Statements

public class ControlFlow {
    public static void main(String[] args) {
        int score = 85;

        if (score >= 90) {
            System.out.println("Grade: A");
        } else if (score >= 80) {
            System.out.println("Grade: B");
        } else if (score >= 70) {
            System.out.println("Grade: C");
        } else {
            System.out.println("Grade: F");
        }
    }
}

Loops

public class Loops {
    public static void main(String[] args) {
        // For loop
        System.out.println("For loop:");
        for (int i = 1; i <= 5; i++) {
            System.out.println("Count: " + i);
        }

        // While loop
        System.out.println("\nWhile loop:");
        int j = 1;
        while (j <= 5) {
            System.out.println("Count: " + j);
            j++;
        }

        // Enhanced for loop (for arrays)
        System.out.println("\nEnhanced for loop:");
        String[] fruits = {"Apple", "Banana", "Orange"};
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
    }
}

Switch Statement

public class SwitchExample {
    public static void main(String[] args) {
        String day = "Monday";

        switch (day) {
            case "Monday":
                System.out.println("Start of the work week!");
                break;
            case "Friday":
                System.out.println("Almost weekend!");
                break;
            case "Saturday":
            case "Sunday":
                System.out.println("Weekend!");
                break;
            default:
                System.out.println("Midweek day");
        }
    }
}

Part 5: Methods and Functions

Methods help organize code into reusable blocks:

public class Methods {
    // Method with no parameters and no return value
    public static void greet() {
        System.out.println("Hello!");
    }

    // Method with parameters
    public static void greetUser(String name) {
        System.out.println("Hello, " + name + "!");
    }

    // Method with return value
    public static int add(int a, int b) {
        return a + b;
    }

    // Method with multiple parameters and return value
    public static double calculateArea(double length, double width) {
        return length * width;
    }

    public static void main(String[] args) {
        greet();
        greetUser("Alice");

        int sum = add(5, 3);
        System.out.println("Sum: " + sum);

        double area = calculateArea(5.5, 3.2);
        System.out.println("Area: " + area);
    }
}

Part 6: Object-Oriented Programming (OOP)

Classes and Objects
Java is an object-oriented language. Everything revolves around objects:

// Define a class
class Car {
    // Properties (fields)
    String brand;
    String model;
    int year;

    // Constructor
    public Car(String brand, String model, int year) {
        this.brand = brand;
        this.model = model;
        this.year = year;
    }

    // Method
    public void displayInfo() {
        System.out.println(year + " " + brand + " " + model);
    }

    public void honk() {
        System.out.println("Beep beep!");
    }
}

public class OOPExample {
    public static void main(String[] args) {
        // Create objects
        Car car1 = new Car("Toyota", "Camry", 2023);
        Car car2 = new Car("Honda", "Civic", 2022);

        // Use objects
        car1.displayInfo();
        car1.honk();

        car2.displayInfo();
    }
}

Encapsulation (Getters and Setters)

class BankAccount {
    // Private fields (encapsulated)
    private String accountNumber;
    private double balance;

    public BankAccount(String accountNumber, double initialBalance) {
        this.accountNumber = accountNumber;
        this.balance = initialBalance;
    }

    // Getter methods
    public String getAccountNumber() {
        return accountNumber;
    }

    public double getBalance() {
        return balance;
    }

    // Setter with validation
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println("Deposited: $" + amount);
        } else {
            System.out.println("Invalid deposit amount");
        }
    }

    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            System.out.println("Withdrawn: $" + amount);
        } else {
            System.out.println("Invalid withdrawal amount");
        }
    }
}

public class EncapsulationDemo {
    public static void main(String[] args) {
        BankAccount account = new BankAccount("123456", 1000.0);

        System.out.println("Balance: $" + account.getBalance());
        account.deposit(500);
        account.withdraw(200);
        System.out.println("Final balance: $" + account.getBalance());
    }
}

Inheritance

// Parent class
class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    public void eat() {
        System.out.println(name + " is eating");
    }

    public void sleep() {
        System.out.println(name + " is sleeping");
    }
}

// Child class
class Dog extends Animal {
    public Dog(String name) {
        super(name);  // Call parent constructor
    }

    public void bark() {
        System.out.println(name + " says: Woof!");
    }
}

class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }

    public void meow() {
        System.out.println(name + " says: Meow!");
    }
}

public class InheritanceDemo {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy");
        dog.eat();
        dog.bark();

        Cat cat = new Cat("Whiskers");
        cat.sleep();
        cat.meow();
    }
}

Polymorphism

class Shape {
    public void draw() {
        System.out.println("Drawing a shape");
    }

    public double getArea() {
        return 0;
    }
}

class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }

    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

class Rectangle extends Shape {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a rectangle");
    }

    @Override
    public double getArea() {
        return width * height;
    }
}

public class PolymorphismDemo {
    public static void main(String[] args) {
        // Polymorphism: treating different objects through same interface
        Shape[] shapes = {
            new Circle(5),
            new Rectangle(4, 6),
            new Circle(3)
        };

        for (Shape shape : shapes) {
            shape.draw();
            System.out.println("Area: " + shape.getArea());
            System.out.println();
        }
    }
}

Part 7: Arrays and Collections

Arrays

public class ArraysDemo {
    public static void main(String[] args) {
        // Declare and initialize array
        int[] numbers = {1, 2, 3, 4, 5};

        // Access elements
        System.out.println("First element: " + numbers[0]);

        // Array length
        System.out.println("Length: " + numbers.length);

        // Iterate through array
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("numbers[" + i + "] = " + numbers[i]);
        }

        // 2D array
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };

        System.out.println("Element at [1][2]: " + matrix[1][2]); // 6
    }
}

ArrayList

import java.util.ArrayList;

public class ArrayListDemo {
    public static void main(String[] args) {
        // Create ArrayList
        ArrayList<String> fruits = new ArrayList<>();

        // Add elements
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");

        // Access elements
        System.out.println("First fruit: " + fruits.get(0));

        // Size
        System.out.println("Size: " + fruits.size());

        // Iterate
        for (String fruit : fruits) {
            System.out.println(fruit);
        }

        // Remove element
        fruits.remove("Banana");

        // Check if contains
        if (fruits.contains("Apple")) {
            System.out.println("We have apples!");
        }
    }
}

HashMap

import java.util.HashMap;

public class HashMapDemo {
    public static void main(String[] args) {
        // Create HashMap
        HashMap<String, Integer> scores = new HashMap<>();

        // Add key-value pairs
        scores.put("Alice", 95);
        scores.put("Bob", 87);
        scores.put("Charlie", 92);

        // Get value by key
        System.out.println("Alice's score: " + scores.get("Alice"));

        // Iterate through HashMap
        for (String name : scores.keySet()) {
            System.out.println(name + ": " + scores.get(name));
        }

        // Check if key exists
        if (scores.containsKey("Bob")) {
            System.out.println("Bob is in the system");
        }
    }
}

Part 8: Exception Handling

public class ExceptionHandling {
    public static void main(String[] args) {
        // Try-catch block
        try {
            int result = divide(10, 0);
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Error: Cannot divide by zero!");
        }

        // Multiple catch blocks
        try {
            String text = null;
            System.out.println(text.length());
        } catch (NullPointerException e) {
            System.out.println("Error: Null reference!");
        } catch (Exception e) {
            System.out.println("Some other error occurred");
        } finally {
            System.out.println("This always executes");
        }
    }

    public static int divide(int a, int b) {
        return a / b;
    }
}

Custom Exceptions

// Custom exception class
class InsufficientFundsException extends Exception {
    public InsufficientFundsException(String message) {
        super(message);
    }
}

class BankAccountAdvanced {
    private double balance;

    public BankAccountAdvanced(double balance) {
        this.balance = balance;
    }

    public void withdraw(double amount) throws InsufficientFundsException {
        if (amount > balance) {
            throw new InsufficientFundsException(
                "Insufficient funds. Balance: $" + balance + ", Requested: $" + amount
            );
        }
        balance -= amount;
        System.out.println("Withdrawn: $" + amount);
    }

    public double getBalance() {
        return balance;
    }
}

public class CustomExceptionDemo {
    public static void main(String[] args) {
        BankAccountAdvanced account = new BankAccountAdvanced(100);

        try {
            account.withdraw(150);
        } catch (InsufficientFundsException e) {
            System.out.println("Transaction failed: " + e.getMessage());
        }
    }
}

Part 9: File Handling

import java.io.*;
import java.util.Scanner;

public class FileHandling {

    // Writing to a file
    public static void writeToFile(String filename, String content) {
        try {
            FileWriter writer = new FileWriter(filename);
            writer.write(content);
            writer.close();
            System.out.println("Successfully wrote to file");
        } catch (IOException e) {
            System.out.println("Error writing to file: " + e.getMessage());
        }
    }

    // Reading from a file
    public static void readFromFile(String filename) {
        try {
            File file = new File(filename);
            Scanner reader = new Scanner(file);

            while (reader.hasNextLine()) {
                String line = reader.nextLine();
                System.out.println(line);
            }
            reader.close();
        } catch (FileNotFoundException e) {
            System.out.println("File not found: " + e.getMessage());
        }
    }

    public static void main(String[] args) {
        String filename = "example.txt";

        // Write to file
        writeToFile(filename, "Hello, Java!\nThis is file handling in action.");

        // Read from file
        System.out.println("Reading from file:");
        readFromFile(filename);
    }
}

Part 10: Real-World Project - Task Manager Application

Let's build a complete console-based task manager:

import java.util.ArrayList;
import java.util.Scanner;

class Task {
    private String title;
    private String description;
    private boolean completed;

    public Task(String title, String description) {
        this.title = title;
        this.description = description;
        this.completed = false;
    }

    public String getTitle() { return title; }
    public String getDescription() { return description; }
    public boolean isCompleted() { return completed; }

    public void setCompleted(boolean completed) {
        this.completed = completed;
    }

    @Override
    public String toString() {
        String status = completed ? "[✓]" : "[ ]";
        return status + " " + title + " - " + description;
    }
}

class TaskManager {
    private ArrayList<Task> tasks;

    public TaskManager() {
        tasks = new ArrayList<>();
    }

    public void addTask(String title, String description) {
        tasks.add(new Task(title, description));
        System.out.println("Task added successfully!");
    }

    public void listTasks() {
        if (tasks.isEmpty()) {
            System.out.println("No tasks found.");
            return;
        }

        System.out.println("\n===== YOUR TASKS =====");
        for (int i = 0; i < tasks.size(); i++) {
            System.out.println((i + 1) + ". " + tasks.get(i));
        }
        System.out.println("======================\n");
    }

    public void completeTask(int index) {
        if (index >= 0 && index < tasks.size()) {
            tasks.get(index).setCompleted(true);
            System.out.println("Task marked as complete!");
        } else {
            System.out.println("Invalid task number.");
        }
    }

    public void deleteTask(int index) {
        if (index >= 0 && index < tasks.size()) {
            tasks.remove(index);
            System.out.println("Task deleted!");
        } else {
            System.out.println("Invalid task number.");
        }
    }
}

public class TaskManagerApp {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        TaskManager manager = new TaskManager();
        boolean running = true;

        System.out.println("===== TASK MANAGER =====");

        while (running) {
            System.out.println("\nOptions:");
            System.out.println("1. Add Task");
            System.out.println("2. List Tasks");
            System.out.println("3. Complete Task");
            System.out.println("4. Delete Task");
            System.out.println("5. Exit");
            System.out.print("Choose an option: ");

            int choice = scanner.nextInt();
            scanner.nextLine(); // Consume newline

            switch (choice) {
                case 1:
                    System.out.print("Enter task title: ");
                    String title = scanner.nextLine();
                    System.out.print("Enter task description: ");
                    String description = scanner.nextLine();
                    manager.addTask(title, description);
                    break;

                case 2:
                    manager.listTasks();
                    break;

                case 3:
                    manager.listTasks();
                    System.out.print("Enter task number to complete: ");
                    int completeIndex = scanner.nextInt() - 1;
                    manager.completeTask(completeIndex);
                    break;

                case 4:
                    manager.listTasks();
                    System.out.print("Enter task number to delete: ");
                    int deleteIndex = scanner.nextInt() - 1;
                    manager.deleteTask(deleteIndex);
                    break;

                case 5:
                    System.out.println("Goodbye!");
                    running = false;
                    break;

                default:
                    System.out.println("Invalid option. Try again.");
            }
        }

        scanner.close();
    }
}

Best Practices and Tips

1. Naming Conventions

Classes: Use PascalCase (e.g., MyClass, BankAccount)
Methods and variables: Use camelCase (e.g., calculateTotal, userName)
Constants: Use UPPER_SNAKE_CASE (e.g., MAX_SIZE, DEFAULT_VALUE)

2. Code Organization

One public class per file
File name must match the public class name
Use packages to organize related classes

3. Comments and Documentation

/**
 * Calculates the factorial of a number
 * @param n the number to calculate factorial for
 * @return the factorial of n
 */
public static long factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

4. Always Use Try-With-Resources

// Good practice - automatically closes resources
try (Scanner scanner = new Scanner(new File("data.txt"))) {
    while (scanner.hasNextLine()) {
        System.out.println(scanner.nextLine());
    }
} catch (FileNotFoundException e) {
    e.printStackTrace();
}

What's Next?
Now that you've learned Java fundamentals, here are some paths to explore:

Web Development: Learn Spring Boot for building web applications
Android Development: Create mobile apps with Android Studio
Data Structures & Algorithms: Deepen your problem-solving skills
Design Patterns: Learn common solutions to recurring problems
Testing: Explore JUnit for unit testing

Recommended Resources

Official Java Documentation: docs.oracle.com/javase
Practice coding: LeetCode, HackerRank, Codewars
Java communities: r/learnjava, Stack Overflow

Conclusion
Congratulations! You've learned Java from the basics to building a real application. The key to mastering Java is practice, practice, practice, and practice. Try building your own projects. Start with small ones and go up in size. Also, open an account on GitHub (Free!) and put all your learning and projects there for everybody to see! Don't forget to contribute to open-source, and keep coding every day.
What will you build with Java? Drop a comment below and share your projects!
Happy coding! ☕

If you found this tutorial helpful, please give it a ❤️ and follow for more programming tutorials!

About the Author

Connect with me:

Building Your First AI Client in Java (Cerebras AI)

Deividas Strole — Sun, 18 Jan 2026 20:48:51 +0000

In this tutorial, you'll learn how to build a very simple AI chat client in Java. Because of the free tier and the speed, we will be using Cerebras AI here. The same principles though apply to other AI providers like OpenAI (ChatGPT), Claude, or Gemini. If you decide to use other AI models — just adjust the API endpoint and model names.

Prefer video? You can watch the full tutorial on YouTube above.

What You'll Need

Java 11 or higher (we'll use the modern HttpClient API)
A Cerebras AI API key
Your favorite IDE or text editor

Step 1: Get Your Cerebras API Key

First, you'll need to get an API key from Cerebras:

Visit Cerebras AI and sign up for an account
Navigate to the API section or developer dashboard
Generate a new API key
Copy the key—you'll need it in the next step

... and of course - keep your API key secure and never commit it to version control!

Step 2: Set Up Your API Key as an Environment Variable

Instead of hardcoding your API key in your source code, store it as an environment variable. This keeps your key secure and makes your code more portable.

On Windows
Open Command Prompt or PowerShell and run:
SETX CEREBRAS_API_KEY "your-api-key-here"

Replace your-api-key-here with your actual API key. You'll need to restart your IDE or terminal for the changes to take effect.

On macOS/Linux
Add this line to your ~/.bashrc, ~/.zshrc, or ~/.bash_profile:
export CEREBRAS_API_KEY="your-api-key-here"

Then reload your configuration:
bashsource ~/.bashrc # or ~/.zshrc

Step 3: Create Your Java Project

Create a new Java file called AIChat.java and add the following code:

javaimport java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class AIChat {
    public static void main(String[] args) throws IOException, InterruptedException {
        String apiKey = System.getenv("CEREBRAS_API_KEY");

        String requestBody = """
        {
            "model": "llama3.1-8b",
            "messages": [
                {"role": "user", "content": "How to win a lotto?"}
            ],
            "temperature": 0.2
        }
        """;

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.cerebras.ai/v1/chat/completions"))
                .header("Content-Type", "application/json")
                .header("Authorization", "Bearer " + apiKey)
                .POST(HttpRequest.BodyPublishers.ofString(requestBody))
                .build();

        HttpClient client = HttpClient.newHttpClient();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

Understanding the Code

Let's break down what this code does:

1. Reading the API Key
String apiKey = System.getenv("CEREBRAS_API_KEY");

This retrieves your API key from the environment variable you set earlier.

2. Building the Request Body

String requestBody = """
{
    "model": "llama3.1-8b",
    "messages": [
        {"role": "user", "content": "How to win a lotto?"}
    ],
    "temperature": 0.2
}
""";

The request body is a JSON object containing:

model: The AI model to use (Cerebras offers various Llama models)
messages: An array of message objects with roles and content
temperature: Controls randomness (0.0 = deterministic, 1.0 = creative)

3. Creating the HTTP Request

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.cerebras.ai/v1/chat/completions"))
    .header("Content-Type", "application/json")
    .header("Authorization", "Bearer " + apiKey)
    .POST(HttpRequest.BodyPublishers.ofString(requestBody))
    .build();

This builds an HTTP POST request with:

The Cerebras API endpoint
JSON content type header
Authorization header with your API key
The request body we created

4. Sending the Request

HttpClient client = HttpClient.newHttpClient();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

This creates an HTTP client, sends the request, and prints the JSON response.

Step 4: Run Your Application
Compile and run your program:

javac AIChat.java
java AIChat

You should see a JSON response containing the AI's answer!

Parsing the JSON Response

The raw JSON response isn't very user-friendly. Let's improve our code to extract just the AI's message. You can use a JSON library like Gson or Jackson, or parse it manually for simple cases:

// Add this method to extract the content
private static String extractContent(String jsonResponse) {
    int contentStart = jsonResponse.indexOf("\"content\":\"") + 11;
    int contentEnd = jsonResponse.indexOf("\"", contentStart);
    return jsonResponse.substring(contentStart, contentEnd)
        .replace("\\n", "\n");
}

// In main, replace the println with:
String aiResponse = extractContent(response.body());
System.out.println("AI Response: " + aiResponse);

Adapting to Other AI Providers

Want to use a different AI provider? Here's what you need to change:

OpenAI (ChatGPT)

Endpoint: https://api.openai.com/v1/chat/completions
Model: gpt-4 or gpt-3.5-turbo
API Key env var: OPENAI_API_KEY

Anthropic (Claude)

Endpoint: https://api.anthropic.com/v1/messages
Model: claude-sonnet-4-5-20250929
Headers: Add "x-api-key" instead of "Authorization"
API Version: Add header "anthropic-version": "2023-06-01"

Google (Gemini)

Endpoint: https://generativelanguage.googleapis.com/v1/models/gemini-pro:generateContent?key=YOUR_KEY
Different request format (check Google's documentation)

Next Steps

Now that you have a working AI client, you can:

Add user input to make it interactive
Implement conversation history by maintaining a messages array
Add error handling for network issues and API errors
Parse JSON responses properly using Gson or Jackson
Create a command-line chat interface
Experiment with different models and temperature settings

Conclusion

Congratulations - you have successfully built your first AI client in Java! Yahoo! This simple example demonstrates the core concepts you'll use regardless of which AI provider you choose. The key takeaways are understanding HTTP requests, JSON formatting, and secure API key management.

Happy coding, and enjoy exploring the world of AI integration!

About the Author

Connect with me:

AI-Powered Commit Message Generator with Sring Boot & Cerebras

Deividas Strole — Mon, 12 Jan 2026 04:29:32 +0000

I don't know anyone who likes writing proper commit messages. Everyone knows they have to write them, but most are too lazy to think a good message and compose one. I, for example, am so lazy that even for 'work in progress' I just type 'wip'... In this tutorial we will create a REST API which will take your git diff (differences between versions of your code) and automatically generate a professional commit message. Magic!

Our battle plan:

A simple Spring Boot REST API
Integration with Cerebras Cloud API
One endpoint: send a diff, get a formatted commit message

Why Cerebras?

They give free API keys if you ask nicely! Shhh... it's a secret! Also—their API is OpenAI-compatible! ;)

Prerequisites

Java 17+
Maven
A Cerebras API key (get free credits at https://cloud.cerebras.ai)
Basic Spring Boot knowledge

Project Setup

1. Create Spring Boot Project
Using Spring Initializr, create a project with these dependencies:

Spring Web
Spring WebFlux
Lombok
Validation

Or use this pom.xml:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
         https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.0</version>
    </parent>

    <groupId>com.example</groupId>
    <artifactId>commit-message-generator</artifactId>
    <version>1.0.0</version>

    <properties>
        <java.version>17</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

2. Application Configuration
Create src/main/resources/application.properties:

# Cerebras API Configuration
cerebras.api-key=${CEREBRAS_API_KEY}
cerebras.api-url=https://api.cerebras.ai/v1/chat/completions
cerebras.model=llama3.1-70b

# Server Configuration
server.port=8080

# Logging
logging.level.com.example.commitgen=INFO

Building the Application

1. Configuration Class
Create src/main/java/com/example/commitgen/config/CerebrasConfig.java:

package com.example.commitgen.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import lombok.Data;

@Configuration
@ConfigurationProperties(prefix = "cerebras")
@Data
public class CerebrasConfig {
    private String apiKey;
    private String apiUrl;
    private String model;
}

2. DTOs (Data Transfer Objects)

Create src/main/java/com/example/commitgen/dto/CommitRequest.java:

package com.example.commitgen.dto;

import jakarta.validation.constraints.NotBlank;
import lombok.Data;

@Data
public class CommitRequest {
    @NotBlank(message = "Diff cannot be empty")
    private String diff;

    private String type; // feat, fix, docs, etc. (optional)
    private String scope; // Optional scope
}

Create src/main/java/com/example/commitgen/dto/CommitResponse.java:

package com.example.commitgen.dto;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class CommitResponse {
    private String message;
    private String type;
    private String scope;
    private String description;
    private String body;
}

Create Cerebras API DTOs in src/main/java/com/example/commitgen/dto/CerebrasRequest.java:

package com.example.commitgen.dto;

import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import java.util.List;

@Data
@AllArgsConstructor
public class CerebrasRequest {
    private String model;
    private List<Message> messages;

    @JsonProperty("max_tokens")
    private Integer maxTokens;

    private Double temperature;

    @Data
    @AllArgsConstructor
    public static class Message {
        private String role;
        private String content;
    }
}

Create src/main/java/com/example/commitgen/dto/CerebrasResponse.java:

package com.example.commitgen.dto;

import lombok.Data;
import java.util.List;

@Data
public class CerebrasResponse {
    private List<Choice> choices;

    @Data
    public static class Choice {
        private Message message;

        @Data
        public static class Message {
            private String role;
            private String content;
        }
    }
}

3. Cerebras API Service

Create src/main/java/com/example/commitgen/service/CerebrasService.java:

package com.example.commitgen.service;

import com.example.commitgen.config.CerebrasConfig;
import com.example.commitgen.dto.CerebrasRequest;
import com.example.commitgen.dto.CerebrasResponse;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;

import java.util.List;

@Service
@RequiredArgsConstructor
@Slf4j
public class CerebrasService {

    private final CerebrasConfig config;
    private final WebClient.Builder webClientBuilder;

    public Mono<String> generateCompletion(String prompt) {
        WebClient webClient = webClientBuilder
            .baseUrl(config.getApiUrl())
            .defaultHeader("Authorization", "Bearer " + config.getApiKey())
            .defaultHeader("Content-Type", "application/json")
            .build();

        CerebrasRequest request = new CerebrasRequest(
            config.getModel(),
            List.of(
                new CerebrasRequest.Message("system", 
                    "You are a helpful assistant that generates conventional commit messages."),
                new CerebrasRequest.Message("user", prompt)
            ),
            500,
            0.3
        );

        return webClient.post()
            .bodyValue(request)
            .retrieve()
            .bodyToMono(CerebrasResponse.class)
            .map(response -> {
                if (response.getChoices() != null && !response.getChoices().isEmpty()) {
                    return response.getChoices().get(0).getMessage().getContent();
                }
                throw new RuntimeException("No response from Cerebras API");
            })
            .doOnError(error -> log.error("Error calling Cerebras API", error));
    }
}

4. Commit Message Service

Create src/main/java/com/example/commitgen/service/CommitMessageService.java:

package com.example.commitgen.service;

import com.example.commitgen.dto.CommitRequest;
import com.example.commitgen.dto.CommitResponse;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Mono;

@Service
@RequiredArgsConstructor
@Slf4j
public class CommitMessageService {

    private final CerebrasService cerebrasService;

    public Mono<CommitResponse> generateCommitMessage(CommitRequest request) {
        String prompt = buildPrompt(request);

        return cerebrasService.generateCompletion(prompt)
            .map(this::parseResponse)
            .onErrorResume(error -> {
                log.error("Error generating commit message", error);
                return Mono.just(createErrorResponse());
            });
    }

    private String buildPrompt(CommitRequest request) {
        StringBuilder prompt = new StringBuilder();

        prompt.append("Based on the following git diff, generate a conventional commit message.\n\n");
        prompt.append("Format:\n");
        prompt.append("<type>(<scope>): <description>\n\n");
        prompt.append("<body>\n\n");
        prompt.append("Where:\n");
        prompt.append("- type: feat, fix, docs, style, refactor, test, chore\n");
        prompt.append("- scope: optional, component/file affected\n");
        prompt.append("- description: brief summary (50 chars max)\n");
        prompt.append("- body: detailed explanation (optional)\n\n");

        if (request.getType() != null) {
            prompt.append("Preferred type: ").append(request.getType()).append("\n");
        }
        if (request.getScope() != null) {
            prompt.append("Scope: ").append(request.getScope()).append("\n");
        }

        prompt.append("\nDiff:\n");
        prompt.append(request.getDiff());
        prompt.append("\n\n");
        prompt.append("Return ONLY the commit message in the format specified above. ");
        prompt.append("Do not include any explanations or additional text.");

        return prompt.toString();
    }

    private CommitResponse parseResponse(String response) {
        // Clean up the response
        String cleaned = response.trim();

        // Parse conventional commit format
        String[] lines = cleaned.split("\n", 2);
        String firstLine = lines[0].trim();
        String body = lines.length > 1 ? lines[1].trim() : "";

        // Extract type, scope, and description
        String type = "";
        String scope = "";
        String description = firstLine;

        // Parse: type(scope): description
        if (firstLine.contains(":")) {
            String[] parts = firstLine.split(":", 2);
            String prefix = parts[0].trim();
            description = parts.length > 1 ? parts[1].trim() : "";

            if (prefix.contains("(") && prefix.contains(")")) {
                int scopeStart = prefix.indexOf("(");
                int scopeEnd = prefix.indexOf(")");
                type = prefix.substring(0, scopeStart).trim();
                scope = prefix.substring(scopeStart + 1, scopeEnd).trim();
            } else {
                type = prefix;
            }
        }

        return new CommitResponse(
            cleaned,
            type,
            scope,
            description,
            body
        );
    }

    private CommitResponse createErrorResponse() {
        return new CommitResponse(
            "chore: update files",
            "chore",
            "",
            "update files",
            "Failed to generate AI-powered commit message. Using default."
        );
    }
}

5. REST Controller

Create src/main/java/com/example/commitgen/controller/CommitController.java:

package com.example.commitgen.controller;

import com.example.commitgen.dto.CommitRequest;
import com.example.commitgen.dto.CommitResponse;
import com.example.commitgen.service.CommitMessageService;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Mono;

@RestController
@RequestMapping("/api/v1/commit")
@RequiredArgsConstructor
@CrossOrigin(origins = "*")
public class CommitController {

    private final CommitMessageService commitMessageService;

    @PostMapping("/generate")
    public Mono<ResponseEntity<CommitResponse>> generateCommitMessage(
            @Valid @RequestBody CommitRequest request) {
        return commitMessageService.generateCommitMessage(request)
            .map(ResponseEntity::ok);
    }

    @GetMapping("/health")
    public ResponseEntity<String> health() {
        return ResponseEntity.ok("Commit Message Generator is running!");
    }
}

6. Main Application

Create src/main/java/com/example/commitgen/CommitMessageGeneratorApplication.java:

package com.example.commitgen;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.reactive.function.client.WebClient;

@SpringBootApplication
public class CommitMessageGeneratorApplication {

    public static void main(String[] args) {
        SpringApplication.run(CommitMessageGeneratorApplication.class, args);
    }

    @Bean
    public WebClient.Builder webClientBuilder() {
        return WebClient.builder();
    }
}

Running the Application

1. Set Your API Key
export CEREBRAS_API_KEY=your-api-key-here

2. Start the Application
bashmvn spring-boot:run

Conclusion

You have built functional AI commit message generator in under 200 lines!!! Et voilà !

About the Author

Connect with me:

DEV Community: Deividas Strole

Production-Ready Java REST Client: Retries, Pagination, Rate Limits, and Error Handling

Production-Ready Java REST Client: Retries, Pagination, Rate Limits, and Error Handling

1. Why a Basic REST Client Is Not Enough

2. Classify Errors Before Retrying

3. Create a Custom API Exception

4. Separate API Failures from Network Failures

5. Add Request Timeouts

Connection timeout

Request timeout

6. Retry Logic: Start Simple

7. Use Exponential Backoff

8. Add Jitter

9. Respect Retry-After

10. Build a Better Retry Loop

11. Do Not Retry Every HTTP Method Blindly

12. What Is Idempotency?

13. Retrying POST Requests Safely

14. Rate Limiting

15. Rate Limit Handling Strategy

16. Don't Sleep Forever

17. Pagination: Why It Matters

18. Common Pagination Styles

Page number

Offset + limit

Cursor

Link header

19. Define a Paginated Response

20. Fetch a Single Page

21. Fetch All Pages

22. Be Careful with "Fetch Everything"

23. Cursor-Based Pagination

24. Why Cursor Pagination Can Be Better

25. Handle Empty Bodies Safely

26. Error Responses Might Not Be JSON

27. Parse Error JSON Defensively

28. Improve ApiException

29. Validate Responses in One Place

30. Centralize Sending Too

31. Generic GET

32. Generic GET for Lists and Generic Types

33. Generic POST

34. Make Retry Behavior Explicit

35. Better: Create a Request Policy

36. Production Retry Rules

37. Add a Base URL

38. Avoid Double Slashes

39. Add Default Headers

40. Log Carefully

41. Measure Request Duration

42. Beware of Retry Multiplication

43. Retries Are Not a Substitute for Resilience

44. A More Complete Client

45. One Important Improvement to the Example

46. Example: Pagination Client

47. Keep API-Specific Logic Outside the Generic Client

48. A Clean Architecture

49. Quick Retry Cheat Sheet

50. Quick Production Checklist

Final Thoughts

About the Author

Building a REST API Client with Java HttpClient + Jackson

Building a REST API Client with Java HttpClient + Jackson

1. The Problem

2. Add Jackson to Your Project

3. Create a Java Model

4. Create an ObjectMapper

5. Converting JSON into a Java Object

6. Converting a Java Object into JSON

7. Your First HttpClient + Jackson GET Request

8. Check the Status Code Before Parsing JSON

9. Create a Reusable GET Method

10. Build the API Client Class

11. Sending a Java Object with POST

12. Create a Generic POST Method

13. Complete POST Example

14. The Flow Now Looks Much Better

15. What About JSON Arrays?

16. Using TypeReference

17. Add a TypeReference GET Method

9. Respect `Retry-After`

28. Improve `ApiException`

Building a REST API Client with Java `HttpClient` + Jackson

4. Create an `ObjectMapper`

7. Your First `HttpClient` + Jackson GET Request

16. Using `TypeReference`

17. Add a `TypeReference` GET Method

18. Why `Class<T>` Works for One Object but Not `List<T>`

21. Don't Create a New `HttpClient` Per Request

22. Reuse `ObjectMapper` Too

31. A More Complete `RestClient`

`HttpClient`

`ObjectMapper`

`RestClient`

`UserApi`

JSON array to `List<User>`

1. What is `java.net.http`?

7. What Are `BodyPublishers`?

8. What Are `BodyHandlers`?

18. Why Use `sendAsync()`?

23. Reuse `HttpClient`