java-modern

Java Modern Skill

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

When to Use

• Building new Spring Boot 4.x 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.getId(),
            entity.getName(),
            entity.getPrice(),
            entity.getCreatedAt()
        );
    }
}

Configuration Properties

// ✅ Records for config properties (Spring Boot 4.x)
@ConfigurationProperties(prefix = "app.notification")
public record NotificationProperties(
    boolean enabled,
    String fromEmail,
    Duration timeout,
    Retry retry
) {
    public record Retry(int maxAttempts, Duration delay) {}
}

When NOT to use records

• JPA 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 Exception Handlers

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handle(Exception ex) {
        return switch (ex) {
            case EntityNotFoundException e ->
                ResponseEntity.status(404).body(new ErrorResponse(e.getMessage()));
            case DataIntegrityViolationException e ->
                ResponseEntity.status(409).body(new ErrorResponse("Duplicate entry"));
            case ConstraintViolationException e ->
                ResponseEntity.badRequest().body(new ErrorResponse(e.getMessage()));
            default ->
                ResponseEntity.internalServerError().body(new ErrorResponse("Unexpected error"));
        };
    }
}

---

Virtual Threads (Java 21 + Spring Boot 4.x)

# application.yml - enables virtual threads for all request handling
spring:
  threads:
    virtual:
      enabled: true

This single property:

• Runs each HTTP request on a virtual thread (Tomcat)
• Makes @Async methods use virtual threads
• Allows blocking I/O (JDBC, RestClient) to scale like reactive code

// ✅ Blocking code scales with virtual threads - no code changes needed
@Service
@Transactional(readOnly = true)
public class ReportService {
    private final OrderRepository orderRepository;
    private final RestClient externalApi;

    public ReportService(OrderRepository orderRepository, RestClient externalApi) {
        this.orderRepository = orderRepository;
        this.externalApi = externalApi;
    }

    public Report generate(Long customerId) {
        // Both blocking calls - on virtual threads this scales to thousands of concurrent requests
        List<Order> orders = orderRepository.findByCustomerId(customerId);
        CustomerData data = externalApi.get()
            .uri("/customers/{id}", customerId)
            .retrieve()
            .body(CustomerData.class);
        return new Report(orders, data);
    }
}

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
@Query("""
    SELECT p FROM Product p
    WHERE p.active = true
      AND p.price BETWEEN :minPrice AND :maxPrice
    ORDER BY p.name
    """)
List<Product> findActiveInPriceRange(
    @Param("minPrice") BigDecimal min,
    @Param("maxPrice") BigDecimal max);

// ✅ JSON in tests
mockMvc.perform(post("/api/v1/products")
    .contentType(MediaType.APPLICATION_JSON)
    .content("""
        {
            "name": "Widget",
            "price": 10.00
        }
        """))
    .andExpect(status().isCreated());

---

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
SortedSet<User> users = userRepository.findTopByOrderByCreatedAtDesc();
User newest = users.getFirst();
User oldest = users.getLast();

---

Quick Decision Guide

Feature	Use For	Avoid When
Records	DTOs, config, value objects	JPA entities, mutable state
Sealed classes	Closed type hierarchies, domain events	Open extension needed
Pattern matching switch	Handling sealed types, replacing if-else chains	Simple equality checks
Virtual threads	High-concurrency blocking I/O	CPU-bound work, synchronized over I/O
Text blocks	JPQL queries, JSON test data, SQL	Single-line strings
SequencedCollections	First/last access on ordered collections	Unordered sets/maps