Java Modern Skill

Java 21+ language features and how to use them in Quarkus applications.

When to Use

• Building new Quarkus applications (default to modern features)
• Modernizing/refactoring existing Java code
• User asks about records, sealed classes, pattern matching, virtual threads

Records (Java 16+)

DTOs

// ✅ Records for request/response DTOs
public record ProductRequest(
    @NotBlank String name,
    @DecimalMin("0.0") BigDecimal price
) {}

public record ProductResponse(
    Long id,
    String name,
    BigDecimal price,
    LocalDateTime createdAt
) {
    public static ProductResponse from(Product entity) {
        return new ProductResponse(
            entity.id,
            entity.name,
            entity.price,
            entity.createdAt
        );
    }
}

Configuration Mappings

// ✅ Interfaces for type-safe config (Quarkus @ConfigMapping)
@ConfigMapping(prefix = "app.notification")
public interface NotificationProperties {
    boolean enabled();
    String fromEmail();
    Duration timeout();
    Retry retry();

    interface Retry {
        int maxAttempts();
        Duration delay();
    }
}

// Usage - injected like any CDI bean
@ApplicationScoped
public class NotificationService {
    @Inject
    NotificationProperties properties;
}

When NOT to use records

• JPA/Panache entities (Hibernate needs mutable objects, no-arg constructor)
• Classes that need inheritance
• Objects with mutable state

Sealed Classes (Java 17+)

Domain Modeling

// ✅ Restrict payment types at compile time
public sealed interface PaymentResult
    permits PaymentSuccess, PaymentFailure, PaymentPending {
}

public record PaymentSuccess(String transactionId, BigDecimal amount)
    implements PaymentResult {}

public record PaymentFailure(String errorCode, String message)
    implements PaymentResult {}

public record PaymentPending(String referenceId)
    implements PaymentResult {}

// Usage in service
public PaymentResult processPayment(PaymentRequest request) {
    try {
        String txId = gateway.charge(request);
        return new PaymentSuccess(txId, request.amount());
    } catch (InsufficientFundsException e) {
        return new PaymentFailure("INSUFFICIENT_FUNDS", e.getMessage());
    }
}

Event Hierarchies

public sealed interface OrderEvent
    permits OrderCreated, OrderShipped, OrderCancelled {

    Long orderId();
    LocalDateTime timestamp();
}

public record OrderCreated(Long orderId, LocalDateTime timestamp, Long customerId)
    implements OrderEvent {}

public record OrderShipped(Long orderId, LocalDateTime timestamp, String trackingNumber)
    implements OrderEvent {}

public record OrderCancelled(Long orderId, LocalDateTime timestamp, String reason)
    implements OrderEvent {}

Pattern Matching

instanceof (Java 16+)

// ❌ Old style
if (obj instanceof String) {
    String s = (String) obj;
    return s.length();
}

// ✅ Pattern matching
if (obj instanceof String s) {
    return s.length();
}

switch (Java 21+)

// ✅ Exhaustive switch with sealed types - compiler enforces all cases
public String handlePayment(PaymentResult result) {
    return switch (result) {
        case PaymentSuccess s -> "Paid: " + s.transactionId();
        case PaymentFailure f -> "Failed: " + f.message();
        case PaymentPending p -> "Pending: " + p.referenceId();
    };
}

// ✅ Guarded patterns
public BigDecimal calculateDiscount(Order order) {
    return switch (order) {
        case Order o when o.getTotal().compareTo(new BigDecimal("100")) > 0 ->
            o.getTotal().multiply(new BigDecimal("0.10"));
        case Order o when o.isLoyaltyMember() ->
            o.getTotal().multiply(new BigDecimal("0.05"));
        default -> BigDecimal.ZERO;
    };
}

In Service Logic

// Replacing if-else chains with pattern matching
public String processNotification(Object event) {
    return switch (event) {
        case OrderCreated o when o.total().compareTo(BigDecimal.valueOf(1000)) > 0 ->
            sendPriorityNotification(o);
        case OrderCreated o -> sendStandardNotification(o);
        case OrderCancelled c -> sendCancellationNotification(c);
        case PaymentReceived p -> sendPaymentConfirmation(p);
        default -> throw new IllegalArgumentException("Unknown event: " + event);
    };
}

// Pattern matching with instanceof — no more casting
public BigDecimal calculateShipping(Address address) {
    if (address instanceof DomesticAddress d) {
        return d.isExpressZone() ? DOMESTIC_EXPRESS : DOMESTIC_STANDARD;
    } else if (address instanceof InternationalAddress i) {
        return BASE_INTERNATIONAL.multiply(i.distanceFactor());
    }
    throw new IllegalArgumentException("Unknown address type");
}

In JAX-RS Exception Mappers

@Provider
public class GlobalExceptionMapper implements ExceptionMapper<Exception> {

    @Override
    public Response toResponse(Exception ex) {
        return switch (ex) {
            case EntityNotFoundException e ->
                Response.status(404).entity(new ErrorResponse(e.getMessage())).build();
            case ConstraintViolationException e ->
                Response.status(400).entity(new ErrorResponse(e.getMessage())).build();
            default ->
                Response.status(500).entity(new ErrorResponse("Unexpected error")).build();
        };
    }
}

Virtual Threads (Java 21 + Quarkus)

Unlike frameworks that offer a single global switch, Quarkus offloads execution to a virtual thread per endpoint/method via @RunOnVirtualThread.

import io.smallrye.common.annotation.RunOnVirtualThread;

@Path("/api/v1/reports")
@ApplicationScoped
public class ReportResource {

    private final OrderRepository orderRepository;

    @RestClient
    CustomerApiClient customerApi;

    public ReportResource(OrderRepository orderRepository) {
        this.orderRepository = orderRepository;
    }

    @GET
    @Path("/{customerId}")
    @RunOnVirtualThread
    public Report generate(@PathParam("customerId") Long customerId) {
        // Both blocking calls - running on a virtual thread, so blocking is cheap
        List<Order> orders = orderRepository.find("customerId", customerId).list();
        CustomerData data = customerApi.getCustomer(customerId);
        return new Report(orders, data);
    }
}

@RunOnVirtualThread only works on methods that are already considered blocking (it cannot be combined with a reactive/non-blocking return type like Uni<T>).

Do NOT use with virtual threads:

• synchronized blocks holding across blocking calls (use ReentrantLock instead)
• Thread-local heavy frameworks (check compatibility first)

Text Blocks (Java 15+)

// ✅ JPQL queries
public List<Product> findActiveInPriceRange(BigDecimal min, BigDecimal max) {
    return getEntityManager().createQuery("""
        SELECT p FROM Product p
        WHERE p.active = true
          AND p.price BETWEEN :minPrice AND :maxPrice
        ORDER BY p.name
        """, Product.class)
        .setParameter("minPrice", min)
        .setParameter("maxPrice", max)
        .getResultList();
}

// ✅ JSON in tests (RestAssured)
given()
    .contentType(ContentType.JSON)
    .body("""
        {
            "name": "Widget",
            "price": 10.00
        }
        """)
    .when().post("/api/v1/products")
    .then().statusCode(201);

Sequenced Collections (Java 21)

SequencedCollection adds getFirst(), getLast(), and reversed() to ordered collections.

// ❌ Before Java 21
String first = list.get(0);
String last = list.get(list.size() - 1);

// ✅ Java 21+
String first = list.getFirst();
String last = list.getLast();

// Reversed view (no copy)
for (var item : list.reversed()) {
    process(item);
}

// Works with all ordered collections: List, Deque, SortedSet, LinkedHashSet, LinkedHashMap
List<User> users = userRepository.find("order by createdAt desc").list();
User newest = users.getFirst();
User oldest = users.getLast();

Quick Decision Guide