The State of Modern Java: Jakarta EE 11, JDK 23, and Ecosystem Evolution

Introduction: The Renaissance of the Java Ecosystem

Section 1: Jakarta EE 11-M2 and the Era of Modern Enterprise Java

Practical Implementation: Jakarta REST with Records

package com.example.jakarta.rest;

import jakarta.ws.rs.GET;
import jakarta.ws.rs.POST;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.Consumes;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;

// A Java Record acting as a DTO. 
// Jakarta JSON Binding (JSON-B) handles serialization automatically.
public record UserDto(
    @NotNull String id, 
    @NotNull @Size(min = 3, max = 50) String username, 
    String email
) {}

@Path("/users")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
public class UserResource {

    // Simulating a repository
    private static final ConcurrentHashMap userStore = new ConcurrentHashMap<>();

    @GET
    public List getAllUsers() {
        return userStore.values().stream().toList();
    }

    @POST
    public Response createUser(UserDto user) {
        // In Jakarta EE 11, validation on records is first-class
        if (userStore.containsKey(user.id())) {
            return Response.status(Response.Status.CONFLICT)
                           .entity("User already exists").build();
        }
        
        userStore.put(user.id(), user);
        
        return Response.status(Response.Status.CREATED)
                       .entity(user).build();
    }
}

Updates in CDI and Validation

Section 2: JDK 23 Targets and Stream Gatherers

Exploring Stream Gatherers

package com.example.jdk23.features;

import java.util.List;
import java.util.stream.Gatherers;
import java.util.stream.Stream;

public class LogProcessor {

    record LogEvent(String timestamp, String message, String severity) {}

    public static void main(String[] args) {
        List events = List.of(
            new LogEvent("10:00", "System Start", "INFO"),
            new LogEvent("10:01", "Connection Init", "INFO"),
            new LogEvent("10:02", "Timeout", "ERROR"),
            new LogEvent("10:03", "Retry", "WARN"),
            new LogEvent("10:04", "Success", "INFO")
        );

        // Using the built-in windowFixed gatherer (Preview in JDK 22/23)
        // This transforms the stream into a stream of Lists, each size 2
        List> batches = events.stream()
            .gather(Gatherers.windowFixed(2))
            .toList();

        System.out.println("Processing Batches:");
        batches.forEach(batch -> {
            System.out.println("--- Batch Start ---");
            batch.forEach(System.out::println);
            // Simulate batch insert to DB
            System.out.println("--- Batch End ---");
        });
    }
    
    // Example of a hypothetical custom logic integration
    public void processWithVirtualThreads() {
        // Connecting Project Loom news with Stream improvements
        try (var scope = java.util.concurrent.Executors.newVirtualThreadPerTaskExecutor()) {
            scope.submit(() -> {
                System.out.println("Processing logs on virtual thread: " + Thread.currentThread());
            });
        }
    }
}

Project Loom and Structured Concurrency

Section 3: Spring Boot, Hibernate, and the AI Frontier

Building an AI-Enhanced Service with Spring

package com.example.spring.ai;

import org.springframework.stereotype.Service;
import org.springframework.web.client.RestClient;
import org.springframework.http.MediaType;

@Service
public class AiAssistantService {

    private final RestClient restClient;

    public AiAssistantService(RestClient.Builder builder) {
        this.restClient = builder.baseUrl("https://api.openai.com/v1").build();
    }

    public String summarizeText(String complexText) {
        // Constructing a request using the modern RestClient
        // This replaces the older RestTemplate
        String prompt = """
            {
                "model": "gpt-4",
                "messages": [
                    {"role": "system", "content": "You are a helpful assistant."},
                    {"role": "user", "content": "Summarize this: %s"}
                ]
            }
            """.formatted(complexText.replace("\n", " "));

        return restClient.post()
                .uri("/chat/completions")
                .header("Authorization", "Bearer YOUR_API_KEY")
                .contentType(MediaType.APPLICATION_JSON)
                .body(prompt)
                .retrieve()
                .body(String.class); // In a real app, map to a proper Response Record
    }
    
    // A tip from "Java wisdom tips news":
    // Always use constructor injection (as shown above) for testability.
}

Hibernate 6 and Records

// HQL with Records in Hibernate 6
// "select new com.example.UserSummary(u.id, u.username) from User u where u.active = true"

Section 4: Best Practices, Tooling, and Security

Testing and Mocking

package com.example.testing;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

import java.util.Optional;

@ExtendWith(MockitoExtension.class)
class UserServiceTest {

    @Mock
    UserRepository userRepository;

    @Test
    void testFindUserSafe() {
        // Setup: Return an empty Optional instead of null
        // This adheres to modern Java wisdom tips news regarding null safety
        when(userRepository.findById("999")).thenReturn(Optional.empty());

        UserService service = new UserService(userRepository);
        User result = service.findUserOrReturnDefault("999");

        assertNotNull(result);
        assertEquals("Guest", result.getName());
        
        verify(userRepository).findById("999");
    }
}

Performance Considerations

JavaFX and Client-Side Java

Conclusion