Future-Proof Enterprise Java: From Jakarta EE to Quarkus and AI Integration

Overview

Adam Bien, a veteran in the Java enterprise space, champions a philosophy of building “boring” systems — systems that are simple, standards-based, and deliberately avoid exotic dependencies. This approach, he argues, is the key to long-term maintainability and adaptability. In this tutorial, you’ll learn how to apply Bien’s principles to create future-proof enterprise applications, starting with Jakarta EE (formerly Java EE), then migrating to Quarkus for cloud-native efficiency, and finally integrating Large Language Models (LLMs) via standard APIs. By sticking to well-established patterns and minimizing third-party libraries, you can build systems that survive technology shifts and remain easy to evolve.

Prerequisites

Before diving in, ensure you have the following:

• Java 17 or later installed (preferably OpenJDK).
• Maven 3.8+ for project build and dependency management.
• Basic understanding of Jakarta EE concepts (CDI, JAX-RS, JPA).
• Familiarity with Quarkus (or willingness to learn).
• An API key for an LLM provider (e.g., OpenAI) — or a local model endpoint.
• A code editor (VS Code, IntelliJ IDEA) with Java support.

Step-by-Step Instructions

Step 1: Embrace Standards – Build with Jakarta EE

The foundation of Bien’s playbook is zero non-standard dependencies. Instead of pulling in Spring or Hibernate-specific features, rely on Jakarta EE specifications. Start with a simple REST service using JAX-RS and CDI.

Example: A boring product service

// Product.java
import jakarta.persistence.Entity;
import jakarta.persistence.Id;

@Entity
public class Product {
    @Id
    private Long id;
    private String name;
    // Getters and setters
}

// ProductResource.java
import jakarta.inject.Inject;
import jakarta.ws.rs.*;
import jakarta.ws.rs.core.MediaType;
import java.util.List;

@Path("/products")
@Produces(MediaType.APPLICATION_JSON)
public class ProductResource {
    @Inject
    ProductRepository repository;

    @GET
    public List<Product> list() {
        return repository.findAll();
    }
}

Notice: no Spring annotations, no framework-specific imports. The code is portable across Jakarta EE-compatible runtimes.

Step 2: Zero Dependencies Principle

Avoid pulling in utility libraries (like Apache Commons, Guava) unless absolutely necessary. Use only what Jakarta EE provides. For example, instead of Guava‘s Preconditions, write simple Java checks:

if (product.getName() == null || product.getName().isBlank()) {
    throw new IllegalArgumentException("Product name required");
}

This reduces the risk of dependency conflicts and makes your code easier to upgrade.

Step 3: Migrate to Quarkus for Cloud-Native Readiness

Quarkus is a Jakarta EE-compatible framework that compiles GraalVM native images for fast startup and low memory — ideal for containers. Migration is straightforward as it natively supports JAX-RS, CDI, JPA, etc.

Steps to migrate:

1. Generate a Quarkus project via mvn io.quarkus:quarkus-maven-plugin:create.
2. Replace your old Jakarta EE server (e.g., WildFly) with Quarkus’s built-in Undertow (or Vert.x).
3. Copy your existing entities and resources — they work as-is.
4. Add Quarkus Maven plugin and configure application.properties for your database.

Example application.properties:

quarkus.datasource.db-kind=postgresql
quarkus.datasource.username=myuser
quarkus.datasource.password=mypass
quarkus.hibernate-orm.database.generation=update

Now your boring system runs with sub-second startup and minimal memory footprint.

Step 4: Integrate AI Models (LLMs) Using Standard APIs

Bien’s future‑proofing extends to AI: treat LLM calls like any other HTTP endpoint — no custom SDKs or heavy dependencies. Use Jakarta’s HttpClient (available since Java 11) or the JAX-RS client. Below is an example using the OpenAI API.

// AiService.java
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.ws.rs.client.Client;
import jakarta.ws.rs.client.ClientBuilder;
import jakarta.ws.rs.client.Entity;
import jakarta.ws.rs.core.MediaType;

@ApplicationScoped
public class AiService {
    private static final String OPENAI_URL = "https://api.openai.com/v1/chat/completions";
    private static final String API_KEY = System.getenv("OPENAI_API_KEY");

    public String ask(String prompt) {
        try (Client client = ClientBuilder.newClient()) {
            ChatRequest request = new ChatRequest("gpt-3.5-turbo", prompt);
            ChatResponse response = client
                .target(OPENAI_URL)
                .request(MediaType.APPLICATION_JSON)
                .header("Authorization", "Bearer " + API_KEY)
                .post(Entity.json(request), ChatResponse.class);
            return response.choices().get(0).message().content();
        }
    }
}

You define ChatRequest and ChatResponse as simple POJOs. No external JSON library needed — JAX-RS handles marshalling.

Step 5: Test and Deploy

Write unit tests using JUnit 5 and Arquillian (for embedded integration tests). Then package as a native executable:

mvn package -Pnative -Dquarkus.native.container-build=true

Deploy the resulting binary in a Docker image or directly to Kubernetes.

Common Mistakes

• Over‑relying on frameworks: Adding Spring Boot just for convenience when Jakarta EE suffices. This adds baggage and locks you into a specific ecosystem.
• Ignoring standards: Using proprietary annotation processors or libraries that don’t follow Jakarta standards. This makes migration to a different runtime painful.
• Not testing for portability: Assuming your code works only on one server. Test on at least two Jakarta EE runtimes (e.g., Quarkus and Payara).
• Tightly coupled AI integration: Writing code that directly depends on OpenAI’s SDK. Use the generic HTTP client approach to switch providers (e.g., Azure OpenAI, Ollama).

Summary

Adam Bien’s boring‑systems philosophy is a proven strategy for building enterprise applications that stand the test of time. By sticking to Jakarta EE standards, eliminating unnecessary dependencies, and migrating to Quarkus when cloud‑native features are needed, you future‑proof your work. Integrating AI via standard HTTP clients keeps the system flexible. Start simple, stay boring, and your codebase will thank you when the next big paradigm shift arrives.