Cụm bài Enum và nested class: 1. Enum là một class · 2. Enum ở production · 3. Nested class và lambda
Trong một JVM, enum gần như không thể dùng sai; rắc rối đến khi giá trị enum rời JVM để xuống database, ra JSON, sang client khác. Đọc xong, bạn chọn đúng EnumSet/EnumMap, viết enum singleton, lưu enum với JPA mà không hỏng dữ liệu cũ, và thêm hằng vào API mà không làm chết client. Nên đọc phần 1 trước (enum là một class, values/valueOf/ordinal).
Sơ đồ tóm tắt:
flowchart TD
E[Enum] --> DB{Lưu DB thế nào?}
DB -->|ORDINAL| O["Chèn hằng: dữ liệu sai"]
DB -->|STRING| S["An toàn sắp xếp, gắn tên"]
DB -->|AttributeConverter| AC["Mã ổn định, thêm code"]
E --> API[API]
API --> CL["Client: UNKNOWN + @JsonEnumDefaultValue"]
API --> SV["Server: 400 cho giá trị lạ"]
E --> COL["EnumSet / EnumMap: nhanh"]
E --> SG["Một hằng: singleton"]
1. EnumSet và EnumMap
Ý chính: khi phần tử hay key là enum, dùng EnumSet/EnumMap thay cho HashSet/HashMap. Chúng dựa trên ordinal nên chỉ là phép toán bit và truy cập mảng.
enum Permission { READ, WRITE, DELETE, ADMIN }
Set<Permission> editor = EnumSet.of(Permission.READ, Permission.WRITE);
Set<Permission> others = EnumSet.complementOf(EnumSet.copyOf(editor)); // [DELETE, ADMIN]
Set<Permission> upToWrite = EnumSet.range(Permission.READ, Permission.WRITE);
Map<PaymentMethod, Long> totals = new EnumMap<>(PaymentMethod.class);
totals.merge(PaymentMethod.CARD, 100L, Long::sum);
EnumSet |
EnumMap |
|
|---|---|---|
| Bên trong | bit vector (dãy bit): mỗi hằng một bit ở vị trí ordinal |
mảng đánh chỉ số bằng ordinal |
| Thao tác | contains/add/remove là phép bit; containsAll/retainAll giữa hai EnumSet là AND/OR giữa các long |
không tính hash, không collision, không tạo Entry cho mỗi phần tử |
- Cả hai duyệt theo thứ tự khai báo của enum, ổn định và dễ đoán (khác
HashMap). - Cả hai không nhận
null(NullPointerException) và không thread-safe; cần thì bọcCollections.synchronizedMaphoặc dùngConcurrentHashMap. EnumSetthay hoàn toàn kiểu “bit flags” của C (int flags = READ | WRITE): cùng hiệu năng nhưng có kiểu, in ra đọc được.
2. Enum singleton
Ý chính: enum có đúng một hằng là cách viết singleton Effective Java khuyên dùng, vì JVM lo hộ khởi tạo, reflection và serialization.
public enum IdGenerator {
INSTANCE;
private final AtomicLong sequence = new AtomicLong();
public long next() { return sequence.incrementAndGet(); }
}
long id = IdGenerator.INSTANCE.next();
So với singleton tự viết (private static final + constructor private):
- Thread-safe khi khởi tạo miễn phí: JVM khởi tạo class đúng một lần dù nhiều thread cùng truy cập. Không cần double-checked locking.
- Chống reflection:
Constructor.newInstancetrên enum némIllegalArgumentException: Cannot reflectively create enum objects. Với class thường,setAccessible(true)là tạo được instance thứ hai. - Chống serialization: deserialize luôn trả về đúng instance đang có. Singleton thường phải tự viết
readResolve().
Nhược điểm: không lazy riêng được (khởi tạo khi enum load lần đầu, thường là đủ), không kế thừa class khác, và như mọi singleton tĩnh, khó thay trong test. Trong Spring, singleton thường là bean scope singleton do container quản lý (xem IoC và DI); enum singleton hợp với tiện ích không có dependency và code ngoài container.
3. Enum ở biên hệ thống: database, API, serialization
Ý chính: khi giá trị enum rời JVM, tên và thứ tự hằng trở thành hợp đồng với dữ liệu cũ và với client. Đổi chúng phải đi qua migration hoặc quy trình tiến hoá API.
3.1. JPA: ORDINAL, STRING hay mã ổn định
Ý chính: đừng dùng ORDINAL (mặc định của @Enumerated). Dùng STRING, hoặc AttributeConverter với mã riêng khi muốn tên hằng đổi tự do. Bài ORM và JPA đã nhắc dùng STRING; đây là lý do chi tiết.
STRING gắn tên hằng Java với dữ liệu: đổi E_WALLET thành WALLET cho đẹp là phải migrate, và mọi service đọc chung bảng cũng phải đổi theo. Cách tách hẳn là cho enum một mã ổn định và dùng converter (AttributeConverter — lớp JPA dịch giá trị Java sang giá trị cột và ngược lại):
public enum PaymentMethod {
CARD("C"), BANK_TRANSFER("B"), E_WALLET("W");
private final String code;
PaymentMethod(String code) { this.code = code; }
public String code() { return code; }
private static final Map<String, PaymentMethod> BY_CODE =
Arrays.stream(values()).collect(Collectors.toUnmodifiableMap(PaymentMethod::code, m -> m));
public static PaymentMethod fromCode(String code) {
PaymentMethod m = BY_CODE.get(code);
if (m == null) throw new IllegalArgumentException("Unknown payment method code: " + code);
return m;
}
}
@Converter(autoApply = true)
public class PaymentMethodConverter implements AttributeConverter<PaymentMethod, String> {
@Override
public String convertToDatabaseColumn(PaymentMethod m) { return m == null ? null : m.code(); }
@Override
public PaymentMethod convertToEntityAttribute(String code) {
return code == null ? null : PaymentMethod.fromCode(code);
}
}
Thêm hằng mới vào Java thì migration DB phải đi trước bản deploy ghi hằng đó. Phía DB cũng nên tự giữ tập giá trị hợp lệ (CHECK constraint), không chỉ trông vào enum Java.
Hibernate 6 tự sinh CHECK constraint, và ví dụ schema address component
Khi để Hibernate 6 tự sinh schema, cột enum thường kèm CHECK constraint liệt kê các giá trị (hoặc kiểu ENUM native trên MySQL). Thêm hằng mới vào Java mà chưa chạy migration sửa constraint thì INSERT lỗi. Ở production, schema nên quản lý bằng Flyway/Liquibase, và migration này phải đi trước bản deploy dùng hằng mới.
Schema của address component trong bài Tài liệu kiến trúc phần 2: ADR và ví dụ address component là một ví dụ DB tự giữ tập giá trị: capture_method, verify_status, channel là cột text lưu tên hằng, và hai cột đầu có CHECK (... IN (...)). Giá trị lạ bị từ chối ngay khi insert, kể cả khi ghi từ script SQL không đi qua code Java. Thêm một giá trị enum lúc đó là thêm một migration sửa CHECK.
3.2. Enum trong API và việc tiến hoá
Ý chính: đổi tên hay xoá hằng trong API là breaking change rõ ràng; thêm hằng cũng có thể là breaking change. Server chỉ thêm và báo trước, client đọc dễ dãi, request đầu vào thì validate chặt.
Xem thêm thiết kế và version API ở thiết kế REST API.
3.3. Serialization của enum
Ý chính: cả Java serialization lẫn Jackson chỉ ghi tên hằng (name()), nên đổi tên hay xoá hằng làm dữ liệu cũ không đọc lại được. Muốn JSON dùng mã riêng thì dùng @JsonValue + @JsonCreator.
- Java serialization: ghi tên, đọc lại bằng
Enum.valueOf, nên ra đúng instance đang có. Field của hằng không được ghi. Đổi tên hay xoá hằng thì dữ liệu cũ némInvalidObjectException. - Jackson: mặc định ghi
name()(không phảitoString(), trừ khi bậtWRITE_ENUMS_USING_TO_STRING). Mã riêng:@JsonValuetrên method trả về mã, và static factory có@JsonCreatorđể đọc lại. hashCode()của enum là identity hash, khác nhau giữa các lần chạy JVM. Đừng dùng nó để chia partition, tính shard hay lưu xuống đâu; cần giá trị ổn định thì dùngname().hashCode()hoặc mã riêng.
Java serialization bỏ qua những gì của enum
- Field của hằng enum không được serialize. Nếu (dù không nên) enum có field mutable, giá trị sau khi deserialize là giá trị hiện tại trong JVM nhận, không phải giá trị lúc ghi.
serialVersionUIDkhai báo trong enum bị bỏ qua (luôn là0L); các methodreadObject,writeObject,readResolvetự viết cũng bị bỏ qua.
Bài tập
1. Phương thức thanh toán với mã ổn định cho DB và báo cáo
Đề: enum phương thức thanh toán phải lưu xuống DB bằng mã một ký tự cố định (để đổi tên hằng trong code không ảnh hưởng dữ liệu), báo lỗi rõ ràng khi gặp mã lạ, và tính tổng tiền theo từng phương thức từ danh sách giao dịch.
Lời giải Bài 1: mã ổn định và tổng bằng EnumMap
Enum PaymentMethod và PaymentMethodConverter ở mục 3.1. Tổng theo phương thức dùng EnumMap:
record Txn(PaymentMethod method, long amount) {}
static Map<PaymentMethod, Long> totals(List<Txn> txns) {
return txns.stream().collect(Collectors.groupingBy(
Txn::method,
() -> new EnumMap<>(PaymentMethod.class),
Collectors.summingLong(Txn::amount)));
}
// {CARD=150, BANK_TRANSFER=10} (luôn theo thứ tự khai báo)
toUnmodifiableMap khi dựng BY_CODE ném IllegalStateException nếu hai hằng trùng mã, nên lỗi khai báo lộ ra ngay lúc enum load. Thêm một unit test duyệt values() và kiểm tra fromCode(m.code()) == m để khoá hợp đồng này.
2. Phân quyền bằng EnumSet và lưu xuống DB dạng bitmask
Đề: hệ thống có các quyền (đọc, ghi, xoá, xuất file, quản trị) và các vai trò, mỗi vai trò là một tập quyền. Viết hàm kiểm tra một người dùng (có thể có nhiều vai trò) có một quyền nào đó không, và lưu tập quyền hiệu lực của họ xuống một cột số nguyên BIGINT, đọc lại được.
Lời giải Bài 2: EnumSet, bit cố định và giới hạn của bitmask
import java.util.*;
public class Perms {
enum Permission {
READ(0), WRITE(1), DELETE(2), EXPORT(3), ADMIN(4);
private final int bit; // vị trí bit cố định, không dùng ordinal()
Permission(int bit) { this.bit = bit; }
private static final Map<Integer, Permission> BY_BIT = new HashMap<>();
static {
for (Permission p : values()) {
if (BY_BIT.put(p.bit, p) != null) throw new IllegalStateException("duplicate bit " + p.bit);
}
}
static long toMask(Set<Permission> perms) {
long mask = 0;
for (Permission p : perms) mask |= 1L << p.bit;
return mask;
}
static EnumSet<Permission> fromMask(long mask) {
EnumSet<Permission> result = EnumSet.noneOf(Permission.class);
for (int bit = 0; bit < Long.SIZE; bit++) {
if ((mask & (1L << bit)) == 0) continue;
Permission p = BY_BIT.get(bit);
if (p == null) throw new IllegalArgumentException("unknown permission bit " + bit);
result.add(p);
}
return result;
}
}
enum Role {
VIEWER(EnumSet.of(Permission.READ)),
EDITOR(EnumSet.of(Permission.READ, Permission.WRITE, Permission.EXPORT)),
ADMIN(EnumSet.allOf(Permission.class));
private final Set<Permission> permissions;
Role(EnumSet<Permission> permissions) { this.permissions = Collections.unmodifiableSet(permissions); }
Set<Permission> permissions() { return permissions; }
}
static boolean can(Set<Role> roles, Permission needed) {
return roles.stream().anyMatch(r -> r.permissions().contains(needed));
}
public static void main(String[] args) {
Set<Role> user = EnumSet.of(Role.VIEWER, Role.EDITOR);
System.out.println(can(user, Permission.EXPORT)); // true
System.out.println(can(user, Permission.DELETE)); // false
EnumSet<Permission> effective = EnumSet.noneOf(Permission.class);
user.forEach(r -> effective.addAll(r.permissions()));
long mask = Permission.toMask(effective);
System.out.println(effective + " -> " + mask); // [READ, WRITE, EXPORT] -> 11
System.out.println(Permission.fromMask(mask)); // [READ, WRITE, EXPORT]
try {
Permission.fromMask(1L << 9);
} catch (IllegalArgumentException e) {
System.out.println(e.getMessage()); // unknown permission bit 9
}
}
}
- Mỗi vai trò giữ một
EnumSetbọcCollections.unmodifiableSet, vì hằng enum là singleton dùng chung toàn JVM; để set sửa được là tạo global mutable state. - Bitmask dùng field
bitkhai báo tường minh, không dùngordinal(). Đây đúng là bẫy củaEnumType.ORDINAL: chèn quyền mới vào giữa enum sẽ đổi nghĩa mọi mask đã lưu. - Khối
statickiểm tra trùng bit ngay khi enum load;fromMaskgặp bit lạ (do bản code mới hơn ghi) thì ném lỗi rõ ràng thay vì lặng lẽ bỏ qua.
Góc nhìn senior: bitmask gọn nhưng khó query bằng SQL (WHERE perms & 8 <> 0 không dùng được index), khó đọc khi debug, và giới hạn 64 quyền với long. Cần lọc người dùng theo quyền thì dùng bảng nối role_permission. Trong Spring Security, quyền thường là chuỗi GrantedAuthority; enum chỉ là nguồn sinh ra các chuỗi đó.
Ghi nhớ
- Giải thích được vì sao
EnumSet/EnumMapnhanh hơnHashSet/HashMap, và giới hạn của chúng (null, thread-safety). - Kể được ba lý do enum singleton tốt hơn singleton tự viết, và khi nào nên dùng bean Spring thay thế.
- Giải thích được vì sao
ORDINALlàm hỏng dữ liệu, và chọn được giữaSTRINGvới converter + mã ổn định. - Biết vì sao thêm một hằng vào response API có thể làm client chết, và phía server, client, request mỗi bên làm gì.
- Biết serialization của enum ghi gì, bỏ qua gì, và vì sao không lưu
hashCode()của enum.
Câu hỏi phỏng vấn
Mid
Vì sao EnumMap và EnumSet nhanh hơn HashMap/HashSet khi key là enum?
Vì chúng dựa trên ordinal: EnumSet là bit vector, EnumMap là mảng, nên không tính hash và không collision.
EnumSet của enum tối đa 64 hằng chỉ là một long, mỗi hằng một bit, nên thêm/kiểm tra/hợp/giao là phép bit. EnumMap đánh chỉ số mảng bằng ordinal, không tạo Entry cho mỗi phần tử. Cả hai duyệt theo thứ tự khai báo. Đổi lại chúng không nhận null và không thread-safe.
Bạn lưu một EnumSet xuống database dạng bitmask. Cần chú ý những gì?
Mỗi hằng cần một vị trí bit cố định khai báo tường minh, không dùng ordinal(); và biết rằng bitmask khó query.
Dùng ordinal() thì chèn hay sắp xếp lại hằng sẽ đổi nghĩa mọi mask đã lưu. Kiểm tra trùng bit khi enum load; khi đọc gặp bit lạ thì báo lỗi hoặc log rõ ràng (có thể do bản code mới hơn ghi). long chỉ chứa 64 quyền. Bitmask khó query (perms & 8 <> 0 không dùng index) và khó đọc khi debug; cần lọc theo quyền thì bảng nối hoặc cột mảng chuỗi thường tốt hơn.
Jackson serialize enum thế nào? Muốn JSON dùng mã riêng thay vì tên hằng thì làm sao?
Mặc định Jackson ghi name() và đọc lại theo đúng tên; muốn mã riêng thì @JsonValue để ghi và @JsonCreator để đọc.
Gặp giá trị lạ, Jackson ném InvalidFormatException. Có thể bật WRITE_ENUMS_USING_TO_STRING/READ_ENUMS_USING_TO_STRING để dùng toString(). Mã riêng ổn định: @JsonValue trên method trả về mã, và static factory có @JsonCreator. Client cần chịu được giá trị mới thì thêm hằng UNKNOWN có @JsonEnumDefaultValue và bật READ_UNKNOWN_ENUM_VALUES_USING_DEFAULT_VALUE.
Senior
Bạn lưu enum xuống database thế nào, và tiến hoá enum đó ra sao khi hệ thống đã có dữ liệu?
Lưu bằng STRING hoặc converter với mã ổn định, không bao giờ ORDINAL; tiến hoá theo kiểu migration trước, code sau, đổi tên bằng expand/contract.
ORDINAL: chèn hay xoá hằng làm lệch số thứ tự, dữ liệu cũ đọc sai mà không có lỗi.STRINGan toàn với sắp xếp lại nhưng gắn tên hằng Java với dữ liệu; cần tách hẳn thì cho enum mã ổn định và dùngAttributeConverter.- Thêm hằng: chạy migration (sửa CHECK constraint hoặc kiểu ENUM của DB) trước khi deploy code ghi giá trị mới, và đảm bảo bản code cũ chạy song song (rolling deploy) không chết khi đọc giá trị mới.
- Đổi tên: thêm giá trị mới, migrate dữ liệu, rồi mới bỏ giá trị cũ. Không bao giờ xoá hằng khi còn dữ liệu dùng nó.
Vì sao enum được coi là cách tốt nhất để viết singleton? Nó có nhược điểm gì?
Vì JVM đảm bảo đúng một instance trước cả đa luồng, reflection và serialization; nhược điểm là global state khó thay trong test.
Hằng enum được tạo đúng một lần khi class khởi tạo, nên thread-safe mà không cần lock. Reflection không tạo thêm được instance. Deserialize luôn trả đúng instance hiện có vì enum chỉ được serialize bằng tên. Nhược điểm: không kế thừa class khác, khởi tạo khi enum load, và là global state khó thay trong test. Trong Spring, singleton nên là bean do container quản lý để inject và mock được; enum singleton hợp với tiện ích không có dependency.
Bạn thêm một giá trị mới vào enum đang được trả về trong REST API. Đây có phải breaking change không? Bạn thiết kế thế nào?
Có thể có: client chưa biết giá trị mới có thể chết khi parse, nên hợp đồng phải nói enum mở rộng được và client phải đọc dễ dãi.
- Client dùng Jackson mặc định ném
InvalidFormatException; client có switch exhaustive hay code generate từ OpenAPI có thể hỏng logic. - Hợp đồng API ghi rõ enum có thể mở rộng; client áp dụng tolerant reader (
UNKNOWNvới@JsonEnumDefaultValuevàREAD_UNKNOWN_ENUM_VALUES_USING_DEFAULT_VALUE). - Server chỉ thêm, không đổi tên hay xoá; có thể bật giá trị mới sau khi client chính đã nâng cấp hoặc theo version API.
- Request đầu vào vẫn validate chặt và trả 400 cho giá trị lạ.
Từ vựng tiếng Anh
| Term | Phát âm | Nghĩa | Ví dụ câu dùng khi phỏng vấn |
|---|---|---|---|
| bit vector | /bɪt ˈvektər/ | vector bit | “EnumSet is backed by a bit vector, so set operations are just bitwise ops.” |
| backward compatible | /ˈbækwərd kəmˈpætəbl/ | tương thích ngược | “Adding an enum value isn’t always backward compatible for API clients.” |
| tolerant reader | /ˈtɑːlərənt ˈriːdər/ | bên đọc dễ dãi với dữ liệu lạ | “Clients should be tolerant readers and map unknown values to UNKNOWN.” |
| singleton | /ˈsɪŋɡltən/ | chỉ có một instance | “An enum singleton is safe against reflection and serialization.” |
| attribute converter | /ˈætrɪbjuːt kənˈvɜːrtər/ | bộ chuyển đổi cột của JPA | “An attribute converter maps the enum to a stable one-letter code.” |
| bitmask | /ˈbɪtmæsk/ | mặt nạ bit | “We store the permission set as a bitmask in a BIGINT column.” |
| breaking change | /ˈbreɪkɪŋ tʃeɪndʒ/ | thay đổi làm vỡ client | “Renaming an enum constant in the API is a breaking change.” |
| schema migration | /ˈskiːmə maɪˈɡreɪʃn/ | migration cấu trúc DB | “The schema migration that widens the check constraint must ship first.” |
Ghi chép dựa trên tài liệu Java Core của Hỏi Dân IT và kiến thức tự tìm hiểu, viết lại theo cách hiểu của mình.