[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6},"actionData","errors","routes/blog-tag",{"_7":8,"_9":10},"tag",{"_31":83,"_72":84,"_35":85},"articles",{"_11":12,"_13":14,"_15":16,"_17":16,"_18":19,"_20":21,"_22":23,"_24":23,"_25":16,"_26":27},"content",[30],"pageable",{"_28":21,"_29":19},"totalElements",1,"totalPages","size",10,"number",0,"first",true,"last","numberOfElements","empty",false,"page_number","page_size",{"_31":32,"_33":34,"_35":36,"_37":38,"_11":39,"_40":-5,"_41":23,"_42":27,"_43":44,"_45":46,"_47":48,"_49":50,"_51":52,"_53":52,"_54":55,"_56":57,"_58":59,"_60":52,"_61":16,"_62":63,"_64":65,"_66":67,"_68":69,"_70":71},"id",24,"title","Modern Java Features","slug","clean-code-part-23-modern-java","excerpt","Leverage Java 17-21 features like Records, Sealed Classes, Pattern Matching, and Text Blocks to write cleaner, more expressive code.","# Advanced Clean Code Patterns Part 23: Modern Java Clean Code\n\nJava 17-21 introduced features that dramatically improve code clarity. This article covers Records, Sealed Classes, Pattern Matching, and other modern features that make clean code easier to write.\n\n## 📋 At a Glance\n\n| Feature | Java Version | Benefit |\n|---------|--------------|---------|\n| Records | 16+ | Immutable data carriers |\n| Sealed Classes | 17+ | Controlled inheritance |\n| Pattern Matching | 17-21 | Exhaustive type handling |\n| Text Blocks | 15+ | Readable multiline strings |\n| Switch Expressions | 14+ | Concise conditionals |\n\n---\n\n## 🎯 What You'll Learn\n\n- **Records** for DTOs and value objects\n- **Sealed classes** for domain modeling\n- **Pattern matching** for type-safe dispatch\n- **Text blocks** for SQL and JSON\n- **Migrating** legacy code to modern Java\n\n---\n\n## 🔬 Deep Dive\n\n### Pattern 1: Records for Value Objects\n\n```java\n// ❌ Traditional value class - 80 lines of boilerplate\npublic final class Money {\n private final BigDecimal amount;\n private final Currency currency;\n\n public Money(BigDecimal amount, Currency currency) {\n this.amount = Objects.requireNonNull(amount);\n this.currency = Objects.requireNonNull(currency);\n }\n\n public BigDecimal getAmount() { return amount; }\n public Currency getCurrency() { return currency; }\n\n @Override\n public boolean equals(Object o) {\n if (this == o) return true;\n if (o == null || getClass() != o.getClass()) return false;\n Money money = (Money) o;\n return amount.equals(money.amount) && currency == money.currency;\n }\n\n @Override\n public int hashCode() {\n return Objects.hash(amount, currency);\n }\n\n @Override\n public String toString() {\n return \"Money{amount=\" + amount + \", currency=\" + currency + \"}\";\n }\n}\n\n// ✅ Record - same functionality in 1 line\npublic record Money(BigDecimal amount, Currency currency) {\n\n // Compact constructor for validation\n public Money {\n Objects.requireNonNull(amount, \"amount required\");\n Objects.requireNonNull(currency, \"currency required\");\n if (amount.scale() > 2) {\n throw new IllegalArgumentException(\"Amount cannot have more than 2 decimal places\");\n }\n }\n\n // Factory methods\n public static Money dollars(double amount) {\n return new Money(BigDecimal.valueOf(amount), Currency.USD);\n }\n\n public static Money zero(Currency currency) {\n return new Money(BigDecimal.ZERO, currency);\n }\n\n // Business methods\n public Money add(Money other) {\n if (this.currency != other.currency) {\n throw new IllegalArgumentException(\"Cannot add different currencies\");\n }\n return new Money(this.amount.add(other.amount), this.currency);\n }\n\n public Money multiply(int quantity) {\n return new Money(amount.multiply(BigDecimal.valueOf(quantity)), currency);\n }\n}\n\n// Usage\nMoney price = Money.dollars(29.99);\nMoney total = price.multiply(3);\n```\n\n---\n\n### Pattern 2: Records for DTOs\n\n```java\n// ✅ Request/Response DTOs as Records\n\npublic record CreateOrderRequest(\n @NotNull Long customerId,\n @NotEmpty List items,\n @Valid ShippingAddress shippingAddress,\n String discountCode\n) {\n // Compact constructor for defaults\n public CreateOrderRequest {\n if (items == null) items = List.of();\n }\n}\n\npublic record OrderItemRequest(\n @NotNull Long productId,\n @Min(1) @Max(100) int quantity\n) {}\n\npublic record ShippingAddress(\n @NotBlank String street,\n @NotBlank String city,\n @NotBlank String country,\n @Pattern(regexp = \"\\\\d{5}\") String postalCode\n) {}\n\npublic record OrderResponse(\n Long orderId,\n String status,\n BigDecimal total,\n List items,\n Instant createdAt\n) {\n // Static factory from entity\n public static OrderResponse from(Order order) {\n return new OrderResponse(\n order.getId(),\n order.getStatus().name(),\n order.getTotal(),\n order.getItems().stream().map(OrderItemResponse::from).toList(),\n order.getCreatedAt()\n );\n }\n}\n\npublic record OrderItemResponse(Long productId, String productName, int quantity, BigDecimal price) {\n public static OrderItemResponse from(OrderItem item) {\n return new OrderItemResponse(\n item.getProduct().getId(),\n item.getProduct().getName(),\n item.getQuantity(),\n item.getPrice()\n );\n }\n}\n```\n\n---\n\n### Pattern 3: Sealed Classes for Domain Modeling\n\n```java\n// ✅ Sealed hierarchy for payment methods\n\npublic sealed interface PaymentMethod\n permits CreditCard, BankTransfer, DigitalWallet {\n\n String getDisplayName();\n boolean requiresVerification();\n}\n\npublic record CreditCard(\n String cardNumber,\n String expiryDate,\n String holderName,\n CardType type\n) implements PaymentMethod {\n\n public CreditCard {\n Objects.requireNonNull(cardNumber);\n // Mask all but last 4 digits\n cardNumber = \"****\" + cardNumber.substring(cardNumber.length() - 4);\n }\n\n @Override\n public String getDisplayName() {\n return type.name() + \" ending in \" + cardNumber.substring(4);\n }\n\n @Override\n public boolean requiresVerification() {\n return true;\n }\n}\n\npublic record BankTransfer(String bankName, String accountNumber) implements PaymentMethod {\n\n @Override\n public String getDisplayName() {\n return bankName + \" account\";\n }\n\n @Override\n public boolean requiresVerification() {\n return true;\n }\n}\n\npublic sealed interface DigitalWallet extends PaymentMethod\n permits PayPal, ApplePay, GooglePay {\n}\n\npublic record PayPal(String email) implements DigitalWallet {\n @Override\n public String getDisplayName() { return \"PayPal (\" + email + \")\"; }\n @Override\n public boolean requiresVerification() { return false; }\n}\n\npublic record ApplePay(String deviceId) implements DigitalWallet {\n @Override\n public String getDisplayName() { return \"Apple Pay\"; }\n @Override\n public boolean requiresVerification() { return false; }\n}\n\npublic record GooglePay(String email) implements DigitalWallet {\n @Override\n public String getDisplayName() { return \"Google Pay (\" + email + \")\"; }\n @Override\n public boolean requiresVerification() { return false; }\n}\n```\n\n---\n\n### Pattern 4: Pattern Matching with Switch\n\n```java\n// ✅ Exhaustive pattern matching\n\npublic class PaymentProcessor {\n\n public PaymentResult process(PaymentMethod method, Money amount) {\n // Compiler ensures all cases handled\n return switch (method) {\n case CreditCard card -> processCreditCard(card, amount);\n case BankTransfer transfer -> processBankTransfer(transfer, amount);\n case PayPal paypal -> processPayPal(paypal, amount);\n case ApplePay apple -> processApplePay(apple, amount);\n case GooglePay google -> processGooglePay(google, amount);\n };\n // No default needed - sealed class guarantees completeness\n }\n\n // Pattern matching with guards\n public Fee calculateFee(PaymentMethod method, Money amount) {\n return switch (method) {\n case CreditCard card when card.type() == CardType.AMEX ->\n Fee.percentage(3.5);\n case CreditCard card when amount.amount().compareTo(BigDecimal.valueOf(1000)) > 0 ->\n Fee.percentage(2.0);\n case CreditCard card ->\n Fee.percentage(2.5);\n case BankTransfer _ ->\n Fee.fixed(Money.dollars(1.00));\n case DigitalWallet _ ->\n Fee.percentage(1.5);\n };\n }\n}\n\n// Pattern matching in instanceof\npublic String describe(Object obj) {\n return switch (obj) {\n case String s when s.length() > 100 -> \"Long string: \" + s.substring(0, 100) + \"...\";\n case String s -> \"String: \" + s;\n case Integer i when i < 0 -> \"Negative: \" + i;\n case Integer i -> \"Number: \" + i;\n case List list when list.isEmpty() -> \"Empty list\";\n case List list -> \"List with \" + list.size() + \" items\";\n case null -> \"null\";\n default -> \"Unknown: \" + obj.getClass().getSimpleName();\n };\n}\n```\n\n---\n\n### Pattern 5: Text Blocks for Queries and Templates\n\n```java\n// ✅ Text blocks for SQL\n\npublic class OrderRepository {\n\n private static final String FIND_BY_CUSTOMER = \"\"\"\n SELECT o.id, o.status, o.total, o.created_at\n FROM orders o\n WHERE o.customer_id = :customerId\n AND o.status IN (:statuses)\n AND o.created_at >= :since\n ORDER BY o.created_at DESC\n LIMIT :limit\n \"\"\";\n\n private static final String INSERT_ORDER = \"\"\"\n INSERT INTO orders (customer_id, status, total, created_at)\n VALUES (:customerId, :status, :total, :createdAt)\n RETURNING id\n \"\"\";\n\n public List findByCustomer(Long customerId, Set statuses,\n LocalDateTime since, int limit) {\n return jdbcTemplate.query(FIND_BY_CUSTOMER,\n Map.of(\n \"customerId\", customerId,\n \"statuses\", statuses.stream().map(Enum::name).toList(),\n \"since\", since,\n \"limit\", limit\n ),\n orderRowMapper);\n }\n}\n\n// ✅ Text blocks for JSON templates\npublic class JsonTemplates {\n\n public String errorResponse(String code, String message) {\n return \"\"\"\n {\n \"error\": {\n \"code\": \"%s\",\n \"message\": \"%s\",\n \"timestamp\": \"%s\"\n }\n }\n \"\"\".formatted(code, message, Instant.now());\n }\n\n // With String templates (preview in Java 21)\n // String json = STR.\"\"\"\n // {\n // \"orderId\": \\{order.getId()},\n // \"total\": \\{order.getTotal()}\n // }\n // \"\"\";\n}\n\n// ✅ Text blocks for HTML templates\npublic class EmailTemplates {\n\n public String orderConfirmation(Order order) {\n return \"\"\"\n \n \n \n \n \n \n

Order Confirmation

Order #%d has been confirmed.

Total: $%.2f

\n \n \n \"\"\".formatted(order.getId(), order.getTotal());\n }\n}\n```\n\n---\n\n### Pattern 6: Enhanced Switch Expressions\n\n```java\n// ✅ Switch expressions - return values\n\npublic class OrderStateMachine {\n\n public OrderStatus nextStatus(OrderStatus current, OrderEvent event) {\n return switch (current) {\n case PENDING -> switch (event) {\n case PAYMENT_RECEIVED -> OrderStatus.PAID;\n case CANCELLED -> OrderStatus.CANCELLED;\n default -> current;\n };\n case PAID -> switch (event) {\n case SHIPPED -> OrderStatus.SHIPPED;\n case REFUND_REQUESTED -> OrderStatus.REFUNDING;\n default -> current;\n };\n case SHIPPED -> switch (event) {\n case DELIVERED -> OrderStatus.DELIVERED;\n case RETURNED -> OrderStatus.RETURNED;\n default -> current;\n };\n case DELIVERED, CANCELLED, RETURNED, REFUNDING -> current; // Terminal states\n };\n }\n\n // Switch with yield for complex logic\n public String getStatusMessage(OrderStatus status) {\n return switch (status) {\n case PENDING -> \"Awaiting payment\";\n case PAID -> \"Payment received, preparing shipment\";\n case SHIPPED -> {\n // Complex logic\n String carrier = getCarrier();\n String tracking = getTrackingNumber();\n yield \"Shipped via \" + carrier + \" (Tracking: \" + tracking + \")\";\n }\n case DELIVERED -> \"Order delivered successfully\";\n case CANCELLED -> \"Order was cancelled\";\n case RETURNED -> \"Order was returned\";\n case REFUNDING -> \"Refund in progress\";\n };\n }\n}\n```\n\n---\n\n### Pattern 7: Virtual Threads (Java 21)\n\n```java\n// ✅ Virtual threads for concurrent I/O\n\npublic class ModernConcurrency {\n\n // Before: Platform threads (limited to ~10,000)\n public void processOrdersOld(List orders) {\n ExecutorService executor = Executors.newFixedThreadPool(100);\n try {\n orders.forEach(order ->\n executor.submit(() -> processOrder(order)));\n } finally {\n executor.shutdown();\n }\n }\n\n // After: Virtual threads (millions possible)\n public void processOrders(List orders) {\n try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {\n orders.forEach(order ->\n executor.submit(() -> processOrder(order)));\n }\n // Automatically waits for all tasks to complete\n }\n\n // Structured concurrency (preview)\n public OrderDetails fetchOrderDetails(Long orderId) throws Exception {\n try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {\n\n Supplier order = scope.fork(() -> orderService.findById(orderId));\n Supplier customer = scope.fork(() -> customerService.findByOrderId(orderId));\n Supplier> payments = scope.fork(() -> paymentService.findByOrderId(orderId));\n\n scope.join(); // Wait for all\n scope.throwIfFailed(); // Propagate errors\n\n return new OrderDetails(order.get(), customer.get(), payments.get());\n }\n }\n}\n```\n\n---\n\n### Pattern 8: Migrating to Records\n\n```java\n// Before: POJO with Lombok\n@Data\n@AllArgsConstructor\n@NoArgsConstructor\npublic class CustomerDto {\n private Long id;\n private String name;\n private String email;\n private LocalDateTime createdAt;\n}\n\n// After: Record (if immutability is acceptable)\npublic record CustomerDto(\n Long id,\n String name,\n String email,\n LocalDateTime createdAt\n) {\n // For Jackson deserialization, add @JsonProperty to canonical constructor\n // or use jackson-module-parameter-names\n}\n\n// When you need mutability (builders, setters)\n// Keep using classes, but consider:\n// 1. Wither methods: return new instance with one field changed\n// 2. Builder pattern: construct step by step\n// 3. Keep mutable internally, expose immutable interface\n\npublic record CustomerDto(Long id, String name, String email, LocalDateTime createdAt) {\n\n // Wither methods\n public CustomerDto withName(String newName) {\n return new CustomerDto(id, newName, email, createdAt);\n }\n\n public CustomerDto withEmail(String newEmail) {\n return new CustomerDto(id, name, newEmail, createdAt);\n }\n\n // Builder for complex construction\n public static Builder builder() {\n return new Builder();\n }\n\n public static class Builder {\n private Long id;\n private String name;\n private String email;\n private LocalDateTime createdAt;\n\n public Builder id(Long id) { this.id = id; return this; }\n public Builder name(String name) { this.name = name; return this; }\n public Builder email(String email) { this.email = email; return this; }\n public Builder createdAt(LocalDateTime createdAt) { this.createdAt = createdAt; return this; }\n\n public CustomerDto build() {\n return new CustomerDto(id, name, email, createdAt);\n }\n }\n}\n```\n\n---\n\n## 🐛 Debug This: The Leaky Record\n\nA developer converted their DTOs to Java records for \"guaranteed immutability.\" But integration tests are failing with mysterious state changes. \"Records are immutable! How can the order items be changing?\"\n\n```java\n// The \"immutable\" record\npublic record OrderDto(\n Long id,\n String customerName,\n List items,\n BigDecimal total\n) {\n public OrderDto {\n Objects.requireNonNull(id, \"id required\");\n Objects.requireNonNull(items, \"items required\");\n }\n}\n\npublic record OrderItemDto(Long productId, String name, int quantity) {}\n\n// The service using it\npublic class OrderService {\n\n private final OrderCache cache = new OrderCache();\n\n public OrderDto getOrder(Long orderId) {\n OrderDto cached = cache.get(orderId);\n if (cached != null) {\n return cached;\n }\n\n Order order = orderRepository.findById(orderId);\n OrderDto dto = toDto(order);\n cache.put(orderId, dto);\n return dto;\n }\n\n private OrderDto toDto(Order order) {\n List items = order.getItems().stream()\n .map(item -> new OrderItemDto(\n item.getProduct().getId(),\n item.getProduct().getName(),\n item.getQuantity()\n ))\n .collect(Collectors.toList()); // Mutable list!\n\n return new OrderDto(\n order.getId(),\n order.getCustomer().getName(),\n items,\n order.getTotal()\n );\n }\n}\n\n// The problematic client code\npublic class OrderPrinter {\n\n public void printWithDiscount(OrderDto order) {\n // \"Helpful\" modification for display\n order.items().add(new OrderItemDto(0L, \"DISCOUNT APPLIED\", -1));\n\n printOrder(order);\n\n // Remove the discount line after printing\n order.items().remove(order.items().size() - 1);\n }\n}\n```\n\n**The cached OrderDto is getting corrupted. Tests fail intermittently. What's wrong?**\n\n---\n\n**✅ Solution:**\n\nThe record contains a mutable `List` - records only make their *component references* final, not the contents of those references!\n\n**Problem:**\n\n```java\n.collect(Collectors.toList()); // Creates mutable ArrayList!\n```\n\nThe `List` inside the record can be modified by anyone who has a reference to it:\n\n```java\norder.items().add(...) // Mutates the list inside the \"immutable\" record!\n```\n\nSince the same `OrderDto` is cached, modifications by `OrderPrinter` corrupt the cached instance for all subsequent users.\n\n**Correct implementation:**\n\n```java\npublic record OrderDto(\n Long id,\n String customerName,\n List items,\n BigDecimal total\n) {\n // Compact constructor with defensive copy\n public OrderDto {\n Objects.requireNonNull(id, \"id required\");\n Objects.requireNonNull(items, \"items required\");\n // Make list immutable!\n items = List.copyOf(items);\n }\n}\n\n// In the service - toList() returns unmodifiable in Java 16+\nprivate OrderDto toDto(Order order) {\n List items = order.getItems().stream()\n .map(item -> new OrderItemDto(\n item.getProduct().getId(),\n item.getProduct().getName(),\n item.getQuantity()\n ))\n .toList(); // Java 16+ returns unmodifiable list!\n\n return new OrderDto(\n order.getId(),\n order.getCustomer().getName(),\n items,\n order.getTotal()\n );\n}\n\n// The client code now fails fast\npublic void printWithDiscount(OrderDto order) {\n // This throws UnsupportedOperationException!\n order.items().add(new OrderItemDto(0L, \"DISCOUNT APPLIED\", -1));\n}\n\n// Correct approach - create new list for modified version\npublic void printWithDiscount(OrderDto order) {\n List displayItems = new ArrayList<>(order.items());\n displayItems.add(new OrderItemDto(0L, \"DISCOUNT APPLIED\", -1));\n\n OrderDto forDisplay = new OrderDto(\n order.id(),\n order.customerName(),\n displayItems,\n order.total()\n );\n printOrder(forDisplay);\n}\n```\n\n**The lesson:** Records make component *references* immutable, not the objects they reference. Always use `List.copyOf()` or `List.of()` in record constructors for true immutability.\n\n---\n\n## 💻 Exercises\n\n### Exercise 1: Convert to Record\n⭐ Difficulty: Easy | ⏱️ Time: 10 minutes\n\n**Task:** Convert this POJO to a proper record with validation.\n\n```java\npublic class UserDto {\n private final String id;\n private final String email;\n private final String name;\n private final Set roles;\n\n public UserDto(String id, String email, String name, Set roles) {\n this.id = id;\n this.email = email;\n this.name = name;\n this.roles = roles;\n }\n\n public String getId() { return id; }\n public String getEmail() { return email; }\n public String getName() { return name; }\n public Set getRoles() { return roles; }\n\n // equals, hashCode, toString...\n}\n```\n\n**Requirements:** Validate required fields, ensure roles is immutable.\n\n**✅ Solution:**\n\n```java\npublic record UserDto(\n String id,\n String email,\n String name,\n Set roles\n) {\n // Compact constructor for validation and defensive copy\n public UserDto {\n Objects.requireNonNull(id, \"id is required\");\n Objects.requireNonNull(email, \"email is required\");\n\n // Email format validation\n if (!email.contains(\"@\")) {\n throw new IllegalArgumentException(\"Invalid email format\");\n }\n\n // Name defaults to email prefix if null\n if (name == null || name.isBlank()) {\n name = email.substring(0, email.indexOf('@'));\n }\n\n // Defensive copy for immutability\n roles = roles == null ? Set.of() : Set.copyOf(roles);\n }\n\n // Convenience factory methods\n public static UserDto of(String id, String email) {\n return new UserDto(id, email, null, Set.of());\n }\n\n public static UserDto withRoles(String id, String email, String... roles) {\n return new UserDto(id, email, null, Set.of(roles));\n }\n\n // Wither method for role changes\n public UserDto withRole(String role) {\n Set newRoles = new HashSet<>(roles);\n newRoles.add(role);\n return new UserDto(id, email, name, newRoles);\n }\n\n public boolean hasRole(String role) {\n return roles.contains(role);\n }\n}\n\n// Usage\nUserDto user = UserDto.of(\"123\", \"john@example.com\");\nUserDto admin = user.withRole(\"ADMIN\");\n```\n\n---\n\n### Exercise 2: Sealed Class Hierarchy\n⭐⭐ Difficulty: Medium | ⏱️ Time: 15 minutes\n\n**Task:** Model a notification system using sealed classes.\n\n```java\n// Requirements:\n// - Notifications can be: Email, SMS, Push, InApp\n// - Email and SMS are \"external\" (need delivery confirmation)\n// - Push and InApp are \"internal\" (instant delivery)\n// - Each type has different fields\n```\n\n**✅ Solution:**\n\n```java\n// Sealed hierarchy with two sealed subtypes\npublic sealed interface Notification permits ExternalNotification, InternalNotification {\n String recipient();\n String message();\n Instant createdAt();\n}\n\n// Sealed for external notifications\npublic sealed interface ExternalNotification extends Notification\n permits EmailNotification, SmsNotification {\n\n boolean requiresDeliveryConfirmation();\n}\n\n// Sealed for internal notifications\npublic sealed interface InternalNotification extends Notification\n permits PushNotification, InAppNotification {\n\n boolean isRead();\n}\n\n// Concrete record implementations\npublic record EmailNotification(\n String recipient,\n String message,\n Instant createdAt,\n String subject,\n List attachmentUrls\n) implements ExternalNotification {\n\n public EmailNotification {\n if (!recipient.contains(\"@\")) {\n throw new IllegalArgumentException(\"Invalid email\");\n }\n attachmentUrls = attachmentUrls == null ? List.of() : List.copyOf(attachmentUrls);\n }\n\n @Override\n public boolean requiresDeliveryConfirmation() {\n return true;\n }\n}\n\npublic record SmsNotification(\n String recipient,\n String message,\n Instant createdAt\n) implements ExternalNotification {\n\n public SmsNotification {\n if (!recipient.matches(\"\\\\+?\\\\d{10,15}\")) {\n throw new IllegalArgumentException(\"Invalid phone number\");\n }\n if (message.length() > 160) {\n throw new IllegalArgumentException(\"SMS too long\");\n }\n }\n\n @Override\n public boolean requiresDeliveryConfirmation() {\n return true;\n }\n}\n\npublic record PushNotification(\n String recipient,\n String message,\n Instant createdAt,\n String deviceToken,\n Map data,\n boolean read\n) implements InternalNotification {\n\n public PushNotification {\n data = data == null ? Map.of() : Map.copyOf(data);\n }\n\n @Override\n public boolean isRead() {\n return read;\n }\n}\n\npublic record InAppNotification(\n String recipient,\n String message,\n Instant createdAt,\n String actionUrl,\n boolean read\n) implements InternalNotification {\n\n @Override\n public boolean isRead() {\n return read;\n }\n}\n\n// Usage with exhaustive pattern matching\npublic class NotificationService {\n\n public void send(Notification notification) {\n switch (notification) {\n case EmailNotification email -> sendEmail(email);\n case SmsNotification sms -> sendSms(sms);\n case PushNotification push -> sendPush(push);\n case InAppNotification inApp -> saveInApp(inApp);\n }\n // No default needed - compiler guarantees all cases covered\n }\n\n public String getDeliveryChannel(Notification notification) {\n return switch (notification) {\n case ExternalNotification _ -> \"EXTERNAL_GATEWAY\";\n case InternalNotification _ -> \"INTERNAL_QUEUE\";\n };\n }\n}\n```\n\n---\n\n### Exercise 3: Pattern Matching Switch\n⭐⭐ Difficulty: Medium | ⏱️ Time: 15 minutes\n\n**Task:** Implement a payment fee calculator using pattern matching.\n\n```java\n// Requirements:\n// - Credit cards: 2.5% fee, but 3.5% for AMEX\n// - Debit cards: 1.5% fee\n// - Bank transfer: flat $1.00 fee\n// - Crypto: 1% fee, but 0% for amounts over $1000\n// - Apply 10% discount on any fee for premium customers\n```\n\n**✅ Solution:**\n\n```java\npublic sealed interface PaymentMethod\n permits CreditCard, DebitCard, BankTransfer, CryptoWallet {}\n\npublic record CreditCard(String number, CardNetwork network) implements PaymentMethod {}\npublic record DebitCard(String number, String bankCode) implements PaymentMethod {}\npublic record BankTransfer(String accountNumber, String routingNumber) implements PaymentMethod {}\npublic record CryptoWallet(String address, CryptoType type) implements PaymentMethod {}\n\npublic enum CardNetwork { VISA, MASTERCARD, AMEX, DISCOVER }\npublic enum CryptoType { BITCOIN, ETHEREUM, USDC }\n\npublic class FeeCalculator {\n\n public BigDecimal calculateFee(PaymentMethod method, BigDecimal amount, boolean isPremium) {\n BigDecimal baseFee = calculateBaseFee(method, amount);\n\n // Apply premium discount\n if (isPremium) {\n baseFee = baseFee.multiply(new BigDecimal(\"0.90\")); // 10% off\n }\n\n return baseFee.setScale(2, RoundingMode.HALF_UP);\n }\n\n private BigDecimal calculateBaseFee(PaymentMethod method, BigDecimal amount) {\n return switch (method) {\n // Credit cards with AMEX special case\n case CreditCard(_, CardNetwork.AMEX) ->\n amount.multiply(new BigDecimal(\"0.035\")); // 3.5%\n\n case CreditCard _ ->\n amount.multiply(new BigDecimal(\"0.025\")); // 2.5%\n\n // Debit cards\n case DebitCard _ ->\n amount.multiply(new BigDecimal(\"0.015\")); // 1.5%\n\n // Bank transfer - flat fee\n case BankTransfer _ ->\n new BigDecimal(\"1.00\");\n\n // Crypto with high-value discount\n case CryptoWallet _ when amount.compareTo(new BigDecimal(\"1000\")) > 0 ->\n BigDecimal.ZERO; // Free for large amounts\n\n case CryptoWallet _ ->\n amount.multiply(new BigDecimal(\"0.01\")); // 1%\n };\n }\n\n // Alternative: Record pattern with deconstruction\n public String describePayment(PaymentMethod method) {\n return switch (method) {\n case CreditCard(String num, CardNetwork network) ->\n \"%s card ending in %s\".formatted(network, num.substring(num.length() - 4));\n\n case DebitCard(String num, String bank) ->\n \"Debit from %s ending in %s\".formatted(bank, num.substring(num.length() - 4));\n\n case BankTransfer(String acc, String routing) ->\n \"Bank transfer (routing: %s)\".formatted(routing);\n\n case CryptoWallet(String addr, CryptoType type) ->\n \"%s wallet %s...%s\".formatted(type, addr.substring(0, 6), addr.substring(addr.length() - 4));\n };\n }\n}\n\n// Tests\n@Test\nvoid calculateFee_amexCard_charges3point5Percent() {\n var amex = new CreditCard(\"378282246310005\", CardNetwork.AMEX);\n BigDecimal fee = calculator.calculateFee(amex, new BigDecimal(\"100.00\"), false);\n assertEquals(new BigDecimal(\"3.50\"), fee);\n}\n\n@Test\nvoid calculateFee_cryptoOverThousand_noFee() {\n var btc = new CryptoWallet(\"1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa\", CryptoType.BITCOIN);\n BigDecimal fee = calculator.calculateFee(btc, new BigDecimal(\"1500.00\"), false);\n assertEquals(BigDecimal.ZERO.setScale(2), fee);\n}\n\n@Test\nvoid calculateFee_premiumCustomer_gets10PercentOff() {\n var visa = new CreditCard(\"4111111111111111\", CardNetwork.VISA);\n BigDecimal regularFee = calculator.calculateFee(visa, new BigDecimal(\"100.00\"), false);\n BigDecimal premiumFee = calculator.calculateFee(visa, new BigDecimal(\"100.00\"), true);\n\n assertEquals(new BigDecimal(\"2.50\"), regularFee);\n assertEquals(new BigDecimal(\"2.25\"), premiumFee); // 10% off\n}\n```\n\n---\n\n### Exercise 4: Text Block SQL Repository\n⭐⭐⭐ Difficulty: Medium-Hard | ⏱️ Time: 20 minutes\n\n**Task:** Refactor this repository to use text blocks and modern Java features.\n\n```java\n// Before: String concatenation mess\npublic class OldProductRepository {\n public List searchProducts(String name, BigDecimal minPrice,\n BigDecimal maxPrice, List categories) {\n StringBuilder sql = new StringBuilder();\n sql.append(\"SELECT p.id, p.name, p.price, p.category \");\n sql.append(\"FROM products p \");\n sql.append(\"WHERE 1=1 \");\n if (name != null) {\n sql.append(\"AND p.name ILIKE '%\" + name + \"%' \");\n }\n if (minPrice != null) {\n sql.append(\"AND p.price >= \" + minPrice + \" \");\n }\n if (maxPrice != null) {\n sql.append(\"AND p.price <= \" + maxPrice + \" \");\n }\n if (categories != null && !categories.isEmpty()) {\n sql.append(\"AND p.category IN (\");\n for (int i = 0; i < categories.size(); i++) {\n sql.append(\"'\" + categories.get(i) + \"'\");\n if (i < categories.size() - 1) sql.append(\", \");\n }\n sql.append(\") \");\n }\n sql.append(\"ORDER BY p.name\");\n // SQL injection vulnerability!\n return jdbcTemplate.query(sql.toString(), productMapper);\n }\n}\n```\n\n**Requirements:** Use text blocks, named parameters, and prevent SQL injection.\n\n**✅ Solution:**\n\n```java\npublic class ModernProductRepository {\n\n private final NamedParameterJdbcTemplate jdbcTemplate;\n\n private static final String BASE_QUERY = \"\"\"\n SELECT p.id, p.name, p.price, p.category, p.created_at\n FROM products p\n WHERE 1=1\n \"\"\";\n\n private static final String NAME_FILTER = \"\"\"\n AND p.name ILIKE :namePattern\n \"\"\";\n\n private static final String PRICE_RANGE_FILTER = \"\"\"\n AND p.price BETWEEN :minPrice AND :maxPrice\n \"\"\";\n\n private static final String MIN_PRICE_FILTER = \"\"\"\n AND p.price >= :minPrice\n \"\"\";\n\n private static final String MAX_PRICE_FILTER = \"\"\"\n AND p.price <= :maxPrice\n \"\"\";\n\n private static final String CATEGORY_FILTER = \"\"\"\n AND p.category IN (:categories)\n \"\"\";\n\n private static final String ORDER_BY = \"\"\"\n ORDER BY p.name ASC\n \"\"\";\n\n public List searchProducts(ProductSearchCriteria criteria) {\n var sql = new StringBuilder(BASE_QUERY);\n var params = new MapSqlParameterSource();\n\n criteria.name().ifPresent(name -> {\n sql.append(NAME_FILTER);\n params.addValue(\"namePattern\", \"%\" + name + \"%\");\n });\n\n if (criteria.minPrice().isPresent() && criteria.maxPrice().isPresent()) {\n sql.append(PRICE_RANGE_FILTER);\n params.addValue(\"minPrice\", criteria.minPrice().get());\n params.addValue(\"maxPrice\", criteria.maxPrice().get());\n } else {\n criteria.minPrice().ifPresent(min -> {\n sql.append(MIN_PRICE_FILTER);\n params.addValue(\"minPrice\", min);\n });\n criteria.maxPrice().ifPresent(max -> {\n sql.append(MAX_PRICE_FILTER);\n params.addValue(\"maxPrice\", max);\n });\n }\n\n criteria.categories().filter(cats -> !cats.isEmpty()).ifPresent(cats -> {\n sql.append(CATEGORY_FILTER);\n params.addValue(\"categories\", cats);\n });\n\n sql.append(ORDER_BY);\n\n return jdbcTemplate.query(sql.toString(), params, this::mapProduct);\n }\n\n // Clean record for search criteria\n public record ProductSearchCriteria(\n Optional name,\n Optional minPrice,\n Optional maxPrice,\n Optional> categories\n ) {\n public ProductSearchCriteria {\n name = name == null ? Optional.empty() : name;\n minPrice = minPrice == null ? Optional.empty() : minPrice;\n maxPrice = maxPrice == null ? Optional.empty() : maxPrice;\n categories = categories == null ? Optional.empty() : categories;\n }\n\n // Builder for fluent construction\n public static ProductSearchCriteria empty() {\n return new ProductSearchCriteria(\n Optional.empty(), Optional.empty(),\n Optional.empty(), Optional.empty()\n );\n }\n\n public ProductSearchCriteria withName(String name) {\n return new ProductSearchCriteria(\n Optional.ofNullable(name), minPrice, maxPrice, categories);\n }\n\n public ProductSearchCriteria withPriceRange(BigDecimal min, BigDecimal max) {\n return new ProductSearchCriteria(\n name, Optional.ofNullable(min), Optional.ofNullable(max), categories);\n }\n\n public ProductSearchCriteria withCategories(List cats) {\n return new ProductSearchCriteria(\n name, minPrice, maxPrice, Optional.ofNullable(cats));\n }\n }\n\n private Product mapProduct(ResultSet rs, int rowNum) throws SQLException {\n return new Product(\n rs.getLong(\"id\"),\n rs.getString(\"name\"),\n rs.getBigDecimal(\"price\"),\n rs.getString(\"category\"),\n rs.getTimestamp(\"created_at\").toInstant()\n );\n }\n}\n\n// Usage\nvar criteria = ProductSearchCriteria.empty()\n .withName(\"laptop\")\n .withPriceRange(new BigDecimal(\"500\"), new BigDecimal(\"2000\"))\n .withCategories(List.of(\"Electronics\", \"Computers\"));\n\nList results = repository.searchProducts(criteria);\n```\n\n---\n\n### Exercise 5: Virtual Threads with Structured Concurrency\n⭐⭐⭐⭐ Difficulty: Hard | ⏱️ Time: 25 minutes\n\n**Task:** Implement a product enrichment service using virtual threads and structured concurrency.\n\n```java\n// Requirements:\n// - Fetch product details from multiple sources in parallel\n// - Sources: inventory, pricing, reviews, recommendations\n// - If any source fails, use fallback/default\n// - Complete within 2 second timeout\n// - Return partial results if some sources timeout\n```\n\n**✅ Solution:**\n\n```java\npublic class ProductEnrichmentService {\n\n private final InventoryClient inventoryClient;\n private final PricingClient pricingClient;\n private final ReviewClient reviewClient;\n private final RecommendationClient recommendationClient;\n private final Duration timeout = Duration.ofSeconds(2);\n\n public record EnrichedProduct(\n Product baseProduct,\n Optional inventory,\n Optional pricing,\n Optional reviews,\n Optional> recommendations\n ) {}\n\n // Using virtual threads with structured concurrency\n public EnrichedProduct enrich(Product product) {\n try (var scope = new StructuredTaskScope.ShutdownOnSuccess()) {\n\n // Fork all enrichment tasks as virtual threads\n var inventoryTask = forkWithFallback(scope,\n () -> inventoryClient.getInventory(product.id()),\n \"inventory\");\n\n var pricingTask = forkWithFallback(scope,\n () -> pricingClient.getPricing(product.id()),\n \"pricing\");\n\n var reviewsTask = forkWithFallback(scope,\n () -> reviewClient.getReviewSummary(product.id()),\n \"reviews\");\n\n var recommendationsTask = forkWithFallback(scope,\n () -> recommendationClient.getRecommendations(product.id()),\n \"recommendations\");\n\n // Wait for all with timeout\n try {\n scope.joinUntil(Instant.now().plus(timeout));\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n throw new ServiceException(\"Enrichment interrupted\", e);\n }\n\n // Collect results (each is Optional - empty if failed/timeout)\n return new EnrichedProduct(\n product,\n getResult(inventoryTask),\n getResult(pricingTask),\n getResult(reviewsTask),\n getResult(recommendationsTask)\n );\n }\n }\n\n // Fork with built-in error handling\n private StructuredTaskScope.Subtask> forkWithFallback(\n StructuredTaskScope scope,\n Supplier task,\n String taskName) {\n\n return scope.fork(() -> {\n try {\n return Optional.of(task.get());\n } catch (Exception e) {\n log.warn(\"Enrichment task {} failed: {}\", taskName, e.getMessage());\n return Optional.empty();\n }\n });\n }\n\n private Optional getResult(StructuredTaskScope.Subtask> task) {\n return switch (task.state()) {\n case SUCCESS -> task.get();\n case FAILED, UNAVAILABLE -> Optional.empty();\n };\n }\n\n // Alternative: Custom scope for partial results\n public EnrichedProduct enrichWithPartialResults(Product product) {\n try (var scope = new PartialResultScope()) {\n\n var inventory = scope.fork(\"inventory\",\n () -> inventoryClient.getInventory(product.id()));\n var pricing = scope.fork(\"pricing\",\n () -> pricingClient.getPricing(product.id()));\n var reviews = scope.fork(\"reviews\",\n () -> reviewClient.getReviewSummary(product.id()));\n var recommendations = scope.fork(\"recommendations\",\n () -> recommendationClient.getRecommendations(product.id()));\n\n scope.joinWithTimeout(timeout);\n\n return new EnrichedProduct(\n product,\n scope.getResultOrEmpty(inventory),\n scope.getResultOrEmpty(pricing),\n scope.getResultOrEmpty(reviews),\n scope.getResultOrEmpty(recommendations)\n );\n }\n }\n\n // Custom structured concurrency scope for partial results\n private static class PartialResultScope implements AutoCloseable {\n private final ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();\n private final Map> tasks = new ConcurrentHashMap<>();\n private final Map results = new ConcurrentHashMap<>();\n private final Map errors = new ConcurrentHashMap<>();\n\n public String fork(String name, Callable task) {\n tasks.put(name, executor.submit(() -> {\n try {\n results.put(name, task.call());\n } catch (Exception e) {\n errors.put(name, e);\n }\n }));\n return name;\n }\n\n public void joinWithTimeout(Duration timeout) {\n Instant deadline = Instant.now().plus(timeout);\n for (var entry : tasks.entrySet()) {\n try {\n long remaining = Duration.between(Instant.now(), deadline).toMillis();\n if (remaining > 0) {\n entry.getValue().get(remaining, TimeUnit.MILLISECONDS);\n }\n } catch (TimeoutException e) {\n log.warn(\"Task {} timed out\", entry.getKey());\n entry.getValue().cancel(true);\n } catch (Exception e) {\n log.warn(\"Task {} failed: {}\", entry.getKey(), e.getMessage());\n }\n }\n }\n\n @SuppressWarnings(\"unchecked\")\n public Optional getResultOrEmpty(String name) {\n if (results.containsKey(name)) {\n return Optional.of((T) results.get(name));\n }\n return Optional.empty();\n }\n\n public Map getErrors() {\n return Map.copyOf(errors);\n }\n\n @Override\n public void close() {\n executor.close();\n }\n }\n}\n\n// Tests\n@Test\nvoid enrich_allSourcesSucceed_returnsFullResult() {\n when(inventoryClient.getInventory(any())).thenReturn(mockInventory);\n when(pricingClient.getPricing(any())).thenReturn(mockPricing);\n when(reviewClient.getReviewSummary(any())).thenReturn(mockReviews);\n when(recommendationClient.getRecommendations(any())).thenReturn(mockRecs);\n\n EnrichedProduct result = service.enrich(testProduct);\n\n assertTrue(result.inventory().isPresent());\n assertTrue(result.pricing().isPresent());\n assertTrue(result.reviews().isPresent());\n assertTrue(result.recommendations().isPresent());\n}\n\n@Test\nvoid enrich_someSourcesFail_returnsPartialResult() {\n when(inventoryClient.getInventory(any())).thenReturn(mockInventory);\n when(pricingClient.getPricing(any())).thenThrow(new RuntimeException(\"Service down\"));\n when(reviewClient.getReviewSummary(any())).thenReturn(mockReviews);\n when(recommendationClient.getRecommendations(any())).thenThrow(new RuntimeException(\"Timeout\"));\n\n EnrichedProduct result = service.enrich(testProduct);\n\n assertTrue(result.inventory().isPresent());\n assertFalse(result.pricing().isPresent()); // Failed\n assertTrue(result.reviews().isPresent());\n assertFalse(result.recommendations().isPresent()); // Failed\n}\n\n@Test\nvoid enrich_slowSources_timesOut() {\n when(inventoryClient.getInventory(any())).thenAnswer(inv -> {\n Thread.sleep(5000); // 5 seconds - exceeds timeout\n return mockInventory;\n });\n\n EnrichedProduct result = service.enrich(testProduct);\n\n assertFalse(result.inventory().isPresent()); // Timed out\n}\n```\n\n---\n\n## 📝 Summary\n\n| Feature | Use When |\n|---------|----------|\n| Records | Immutable data (DTOs, value objects) |\n| Sealed Classes | Fixed set of subtypes |\n| Pattern Matching | Type-based dispatch |\n| Text Blocks | SQL, JSON, HTML, multiline strings |\n| Switch Expressions | Returning values from conditionals |\n| Virtual Threads | High-concurrency I/O |\n\n---\n\n## 📅 Review Schedule for This Article\n\n| Day | Task | Time |\n|-----|------|------|\n| Day 1 | Review Records vs Classes decision table | 5 min |\n| Day 3 | Redo Exercise 1 (Convert to Record) | 10 min |\n| Day 7 | Convert one DTO in your codebase to a record | 15 min |\n| Day 14 | Redo Debug This (The Leaky Record) | 10 min |\n| Day 30 | Design a sealed class hierarchy for a domain in your project | 25 min |\n\n---\n\n*Next: [Part 24: Clean Code in Spring Boot]*\n","featuredImage","isPublished","isFeatured","subscriptionType","BASIC","publishedAt","2026-06-10T07:19:24.941654Z","createdAt","2026-06-10T07:19:24.942467Z","updatedAt","2026-06-16T21:26:56.086200Z","readingTimeMinutes",19,"estimatedReadingTime","authorId",3,"authorUsername","tomasz_main","categoryName","Java","readingTime","seriesId","seriesOrder",23,"author",{"_31":55,"_102":57,"_103":104,"_105":106,"_107":-5,"_108":-5,"_109":-5,"_110":-5,"_111":-5},"category",{"_31":98,"_72":59,"_35":99,"_75":100,"_101":-5},"tags",[78,79,80,81,82],"series",{"_31":16,"_72":73,"_35":74,"_75":76,"_77":23},"name","Advanced Clean Code Patterns: From Principles to Production Mastery","advanced-clean-code-patterns","description","A comprehensive 26-part series covering enterprise-grade clean code patterns for Java developers. From SOLID principles and code smells through refactoring patterns, error handling, validation, to legacy modernization and modern Java 21+ features. Includes real production stories, mental models, exercises, and 150+ interview questions.","isActive",{"_31":95,"_72":96,"_35":97},{"_31":92,"_72":93,"_35":94},{"_31":89,"_72":90,"_35":91},{"_31":86,"_72":87,"_35":88},{"_31":83,"_72":84,"_35":85},106,"Sealed Classes","sealed-classes",105,"Records","records",107,"Pattern Matching","pattern-matching",103,"Modern Java","modern-java",104,"Java 21","java-21",5,"java","Category for Java","colorHex","username","firstName","Tomasz","lastName","Jarosz","profilePicture","bio","website","githubUrl","linkedinUrl"]