Java 21 cho code nghiệp vụ: record, sealed class và pattern matching

- Published on
- 12 mins read
Project đã chạy trên JDK 21 từ lâu. Nhưng mở package dto ra vẫn thấy @Data, @AllArgsConstructor xếp hàng trên mỗi class, còn tầng service thì đầy những chuỗi if (x instanceof A) { A a = (A) x; ... } else if (x instanceof B) .... Runtime mới, code vẫn kiểu Java 8.
Từ Java 17 tới Java 21, ngôn ngữ có thêm mấy thứ cắt đúng vào phần "tiếng ồn" đó: record, sealed class, pattern matching, cùng vài tiện ích nhỏ hơn. Nếu bạn làm Clean Architecture hay Event Sourcing, chúng giúp code tập trung vào domain hơn hẳn. Ví dụ trong bài thiên về Spring Boot. (Java 25, bản LTS tiếp theo, ra tháng 9/2025; mọi thứ trong bài vẫn dùng nguyên được, chỉ có String Templates ở cuối bài là đã bị rút lại.)
# records (java 16+, finalized)
Lâu nay ta hay dùng Lombok (@Data, @Value) để đỡ phải viết code rập khuôn. Giờ record là cấu trúc dữ liệu có sẵn của ngôn ngữ, và nó Immutable (bất biến), điều rất quan trọng để giữ dữ liệu toàn vẹn trong hệ thống phân tán và xử lý đồng thời. Có điều đó là bất biến "nông": các field là final, nhưng nếu một field là List có thể sửa được thì nội dung list vẫn bị đổi từ bên ngoài. Muốn chắc thì copy lại trong compact constructor, ví dụ items = List.copyOf(items);.
// Trình biên dịch tự động lo liệu: constructor, getters, equals, hashCode, toString
public record UserDTO(UUID id, String name, String email) {}
// Tích hợp Validation ngay từ vòng gửi xe với Compact Constructor
public record CreateOrderRequest(
@NotNull UUID productId,
@Positive int quantity,
@NotBlank String shippingAddress
) {
// Compact constructor — validation logic
public CreateOrderRequest {
if (quantity > 1000) throw new IllegalArgumentException("Max 1000 per order");
}
}
// Biến Record thành một Value Object trong DDD
public record Money(BigDecimal amount, String currency) {
public Money add(Money other) {
if (!this.currency.equals(other.currency)) throw new IllegalArgumentException("Currency mismatch");
return new Money(this.amount.add(other.amount), this.currency);
}
public boolean isPositive() {
return amount.compareTo(BigDecimal.ZERO) > 0;
}
}
// Spring integration
@RestController
public class UserController {
@GetMapping("/users/{id}")
public UserDTO getUser(@PathVariable UUID id) {
return new UserDTO(id, "John", "john@example.com");
}
}Khi nào dùng Records vs Lombok @Data:
| Records | Lombok @Data |
|---|---|
| Immutable (no setters) | Mutable (setters) |
| Simple DTOs, responses, events | JPA entities (cần no-arg constructor) |
| Rất hợp cho Value Objects trong DDD | Hợp với object cần Builder phức tạp (dù Record vẫn có thể custom Builder) |
| Không hỗ trợ extends (chỉ implements) | Hỗ trợ kế thừa hoàn toàn |
# sealed classes (java 17+)
Kiểm soát chặt hệ thống phân cấp class giúp Domain không bị phá bởi những implementation ngoài ý muốn. Khi trình biên dịch biết chính xác có bao nhiêu subtype trong danh sách permits, bạn bỏ luôn được nhánh default trong switch: sau này ai thêm một trạng thái mới (chẳng hạn PaymentRefunded), mọi chỗ switch thiếu case đó sẽ báo lỗi ngay lúc compile thay vì âm thầm lọt vào default lúc chạy thật. Lưu ý: sealed có từ Java 17, nhưng kiểu switch theo type như ví dụ dưới (pattern matching for switch) phải tới Java 21 mới chính thức.
// Khai báo rõ ràng: Chỉ Circle, Rectangle, Triangle mới được phép kế thừa Shape
public sealed interface Shape permits Circle, Rectangle, Triangle {}
public record Circle(double radius) implements Shape {}
public record Rectangle(double width, double height) implements Shape {}
public record Triangle(double base, double height) implements Shape {}
// Exhaustive Switch: Không cần "default" vì Compiler đã nắm rõ mọi ngả đường
public double area(Shape shape) {
return switch (shape) {
case Circle c -> Math.PI * c.radius() * c.radius();
case Rectangle r -> r.width() * r.height();
case Triangle t -> 0.5 * t.base() * t.height();
};
}
// Domain modeling
public sealed interface PaymentResult permits PaymentSuccess, PaymentFailed, PaymentPending {}
public record PaymentSuccess(String transactionId, Instant timestamp) implements PaymentResult {}
public record PaymentFailed(String errorCode, String message) implements PaymentResult {}
public record PaymentPending(String referenceId) implements PaymentResult {}
// Usage
public ResponseEntity<?> handleResult(PaymentResult result) {
return switch (result) {
case PaymentSuccess s -> ResponseEntity.ok(s);
case PaymentFailed f -> ResponseEntity.badRequest().body(f);
case PaymentPending p -> ResponseEntity.accepted().body(p);
};
}# pattern matching
# instanceof pattern (java 16+)
Hết cảnh ép kiểu (casting) thừa. Code đọc thuận hơn nhiều.
// Ngày xưa: Khai báo rồi ép kiểu
if (obj instanceof String) {
String s = (String) obj;
return s.length();
}
// Java 16+: Binding biến ngay lập tức
if (obj instanceof String s && s.length() > 5) {
return s.substring(0, 5);
}# switch pattern matching (java 21)
Kết hợp switch với instanceof, và cho phép phân tách dữ liệu (destructuring).
// Phân loại kết hợp Guard Clauses (when)
public String classify(Shape shape) {
return switch (shape) {
case Circle c when c.radius() > 100 -> "Vòng tròn cỡ lớn";
case Circle c -> "Vòng tròn tiêu chuẩn";
case Rectangle r when r.width() == r.height() -> "Hình vuông";
case Rectangle r -> "Hình chữ nhật";
case Triangle t -> "Hình tam giác";
};
}
// Phân rã Record (Destructuring) - Trực tiếp lấy biến từ bên trong Record
public double calculateArea(Shape shape) {
return switch (shape) {
case Circle(var radius) -> Math.PI * radius * radius;
case Rectangle(var w, var h) -> w * h;
case Triangle(var b, var h) -> 0.5 * b * h;
};
}# practical: exception handling
Đặt vào tầng @RestControllerAdvice hay bộ xử lý lỗi tập trung, pattern matching gom các nhánh bắt exception về một biểu thức switch gọn gàng:
public APIResponse<?> handleException(Exception ex) {
return switch (ex) {
case NotFoundException e -> APIResponse.error("NOT_FOUND", e.getMessage());
case ValidationException e -> APIResponse.error("VALIDATION", e.getErrors());
case AccessDeniedException e -> APIResponse.error("FORBIDDEN", "Access denied");
case TimeoutException e -> APIResponse.error("TIMEOUT", "Service unavailable");
default -> APIResponse.error("INTERNAL", "Unexpected error");
};
}# text blocks (java 15+)
Không còn phải nối chuỗi bằng + và escape \n làm rối code. Text Blocks giữ nguyên định dạng như bạn viết.
// Multi-line strings
String sql = """
SELECT u.id, u.name, u.email
FROM users u
WHERE u.status = :status
AND u.created_date > :since
ORDER BY u.name
""";
// JSON template
String json = """
{
"name": "%s",
"email": "%s",
"role": "USER"
}
""".formatted(name, email);
// SQL in @Query
@Query(value = """
SELECT p.* FROM products p
JOIN categories c ON c.id = p.category_id
WHERE c.name = :category
AND p.price BETWEEN :min AND :max
ORDER BY p.created_at DESC
""", nativeQuery = true)
List<Product> findByCategoryAndPrice(String category, BigDecimal min, BigDecimal max);# sequenced collections (java 21)
Bao năm nay lấy phần tử cuối của một danh sách phải viết list.get(list.size() - 1) khá vụng, còn muốn lấy phần tử đầu của LinkedHashSet thì phải tạo iterator().next(). Bộ interface SequencedCollection, SequencedSet và SequencedMap thống nhất các thao tác đầu/cuối này. Đáng chú ý là reversed() trả về một view nhìn ngược vào collection gốc chứ không copy sang mảng mới, nên duyệt ngược rất nhẹ bộ nhớ.
// Interface hierarchy: SequencedCollection, SequencedSet, SequencedMap
List<String> list = List.of("a", "b", "c");
// First/Last access (no more list.get(0), list.get(list.size()-1))
String first = list.getFirst(); // "a"
String last = list.getLast(); // "c"
// Reversed view
List<String> reversed = list.reversed(); // ["c", "b", "a"]
// Works with LinkedHashSet, TreeSet, LinkedHashMap
SequencedMap<String, Integer> map = new LinkedHashMap<>();
map.putFirst("key1", 1);
map.putLast("key2", 2);
Map.Entry<String, Integer> firstEntry = map.firstEntry();
Map.Entry<String, Integer> lastEntry = map.lastEntry();# enhanced switch expressions (java 14+)
Trước khi có pattern matching ở Java 21, bản thân câu lệnh switch đã được nâng cấp thành biểu thức (expression) trả về giá trị từ Java 14, dùng mũi tên -> không lo trôi nhánh (fall-through) do quên break, và dùng từ khoá yield khi nhánh xử lý có nhiều dòng:
// Arrow syntax — no fall-through
String label = switch (status) {
case ACTIVE -> "Active";
case INACTIVE -> "Inactive";
case SUSPENDED -> "Suspended";
};
// Multiple values per case
int numDays = switch (month) {
case JANUARY, MARCH, MAY, JULY, AUGUST, OCTOBER, DECEMBER -> 31;
case APRIL, JUNE, SEPTEMBER, NOVEMBER -> 30;
case FEBRUARY -> isLeapYear ? 29 : 28;
};
// Block with yield
String description = switch (errorCode) {
case 404 -> "Not Found";
case 500 -> {
log.error("Internal server error");
yield "Internal Error";
}
default -> "Unknown Error (%d)".formatted(errorCode);
};# unnamed patterns & variables (preview ở java 21, chính thức từ java 22)
Những chỗ bắt buộc phải khai báo biến theo cú pháp (như khối catch, lambda hai tham số hay khi destructuring record) mà thực tế không dùng tới biến đó, giờ bạn thay bằng dấu gạch dưới _ để báo rõ cho người đọc lẫn IDE khỏi cảnh báo biến thừa:
// Underscore for unused variables (Java 22+, hoặc Java 21 với --enable-preview)
try {
process();
} catch (IOException _) {
// don't need the exception variable
return fallback();
}
// In enhanced for
for (var _ : collection) {
count++;
}
// In lambda
map.forEach((_, value) -> process(value));# string templates (preview, java 21)
// STR processor (preview, requires --enable-preview)
String name = "World";
String greeting = STR."Hello, \{name}!";
// Expression interpolation
String info = STR."User \{user.getName()} has \{user.getOrders().size()} orders";
// Multi-line
String html = STR."""
<div class="user">
<span>\{user.getName()}</span>
<span>\{user.getEmail()}</span>
</div>
""";
// Note: preview ở Java 21-22, bị rút khỏi JDK 23 và chưa có bản thay thế
// Hiện tại dùng String.formatted() hoặc MessageFormat
String safe = "User %s has %d orders".formatted(name, count);String Templates là preview ở Java 21 (JEP 430) và 22, rồi bị rút hẳn khỏi JDK 23 để thiết kế lại; tới nay chưa có bản mới. Đừng dùng nó trong code thật, vì code dùng --enable-preview chỉ chạy được trên đúng bản JDK đó.
# practical combinations
Tính năng ngôn ngữ chỉ phát huy khi đặt vào đúng bài toán. Thử xem cách kết hợp Records + Sealed Interfaces + Pattern Matching để giải một bài toán phức tạp hơn.
# domain modeling with records + sealed + pattern matching
// Giới hạn rạch ròi các Event có thể xảy ra trong Domain Order
public sealed interface DomainEvent permits
OrderPlaced, OrderConfirmed, OrderShipped, OrderCancelled {}
public record OrderPlaced(UUID orderId, UUID customerId, List<LineItem> items, Instant at)
implements DomainEvent {}
public record OrderConfirmed(UUID orderId, String paymentRef, Instant at)
implements DomainEvent {}
public record OrderShipped(UUID orderId, String trackingNumber, Instant at)
implements DomainEvent {}
public record OrderCancelled(UUID orderId, String reason, Instant at)
implements DomainEvent {}
// Event handler
public Order apply(Order current, DomainEvent event) {
return switch (event) {
case OrderPlaced e -> Order.create(e.orderId(), e.customerId(), e.items());
case OrderConfirmed e -> current.confirm(e.paymentRef());
case OrderShipped e -> current.ship(e.trackingNumber());
case OrderCancelled e -> current.cancel(e.reason());
};
}# result type (railway-oriented)
Thay vì ném Exception khắp các layer, ta bọc kết quả trả về trong kiểu Result, để luồng Thành công/Thất bại hiện rõ ngay trên method signature.
public sealed interface Result<T> permits Result.Success, Result.Failure {
record Success<T>(T value) implements Result<T> {}
record Failure<T>(String error, String code) implements Result<T> {}
static <T> Result<T> ok(T value) { return new Success<>(value); }
static <T> Result<T> fail(String error, String code) { return new Failure<>(error, code); }
}
// Usage
public Result<User> findUser(UUID id) {
return userRepo.findById(id)
.<Result<User>>map(Result::ok)
.orElse(Result.fail("User not found", "USER_404"));
}
// Handle in controller
public ResponseEntity<?> getUser(UUID id) {
return switch (userService.findUser(id)) {
case Result.Success<User>(var user) -> ResponseEntity.ok(user);
case Result.Failure<User>(var msg, var code) -> ResponseEntity.status(404).body(msg);
};
}# migration tips
| Old Pattern | Java 21 Replacement |
|---|---|
| Lombok @Value DTO | record |
| Visitor pattern | Sealed + switch pattern matching |
instanceof + cast | Pattern binding variable |
| String concatenation | Text blocks + .formatted() |
Collections.unmodifiableList(list) | List.copyOf(list) |
list.get(list.size()-1) | list.getLast() |
| Enum with abstract method | Sealed interface + records |
Vài dòng trong bảng không phải thay thế 1-1. Collections.unmodifiableList trả về một view (list gốc đổi thì view đổi theo), còn List.copyOf tạo bản copy và ném NullPointerException nếu có phần tử null. Enum có abstract method vẫn là lựa chọn tốt khi các giá trị là hằng số không mang dữ liệu riêng; sealed + records chỉ đáng đổi khi mỗi biến thể cần các field khác nhau.
# lời kết
Đừng refactor cả codebase một lần. Thử hai việc nhỏ trong sprint tới:
- Chọn một DTO đang dùng Lombok
@Valuehoặc@Datamà không cần setter, đổi sangrecord, chạy lại test (nhất là phần serialize JSON). - Tìm một chỗ có chuỗi
instanceofdài nhất, gom các kiểu đó dưới mộtsealed interfacerồi viết lại bằngswitchpattern matching. Từ giờ thêm một kiểu mới mà quên xử lý là compiler báo ngay.
Record còn vài chi tiết đáng biết (compact constructor, serialization, dùng với JPA) nằm ở bài Java Records.
Chỉ là những ghi chép cá nhân với hy vọng mang lại chút giá trị. Nếu thấy hữu ích, đừng ngại chia sẻ cho bạn bè & đồng nghiệp nhé!
Happy coding 😎 👍🏻 🚀 🔥.
On this page
- # records (java 16+, finalized)
- # sealed classes (java 17+)
- # pattern matching
- # instanceof pattern (java 16+)
- # switch pattern matching (java 21)
- # practical: exception handling
- # text blocks (java 15+)
- # sequenced collections (java 21)
- # enhanced switch expressions (java 14+)
- # unnamed patterns & variables (preview ở java 21, chính thức từ java 22)
- # string templates (preview, java 21)
- # practical combinations
- # domain modeling with records + sealed + pattern matching
- # result type (railway-oriented)
- # migration tips
- # lời kết