Generics: một Repository dùng cho Order, Payment, Customer

shop-backend có 3 entity: Order, Payment, Customer. Mỗi cái cần một cache nhỏ trong bộ nhớ và các hàm tiện ích như "tính tổng tiền". Bài này cho thấy generics giúp viết một lần, dùng cho mọi kiểu, mà vẫn type-safe.

1. Bài toán: cache dùng Object

public class SimpleCache {
    private final Map<String, Object> map = new HashMap<>();
    public void put(String id, Object value) { map.put(id, value); }
    public Object get(String id) { return map.get(id); }
}

Order o = (Order) cache.get("c-1");    // thực ra là Customer → ClassCastException lúc chạy

2. Vấn đề

• Phải cast ở mọi chỗ gọi.
• Bỏ nhầm kiểu vào không ai báo; lỗi nổ lúc runtime, có khi trên production.
• Viết 3 class OrderCache, PaymentCache, CustomerCache thì copy-paste.

3. Giải pháp: type parameter

Khai báo <T> như một "biến kiểu". Compiler kiểm tra kiểu lúc compile và tự chèn cast. Lỗi chuyển từ runtime sang compile time.

4. Code từng bước

Bước 1: Generic class với bounded type

public interface Identifiable { String getId(); }

public class InMemoryCache<T extends Identifiable> {      // bounded: T phải có getId()
    private final Map<String, T> map = new ConcurrentHashMap<>();
    public void put(T item) { map.put(item.getId(), item); }
    public Optional<T> get(String id) { return Optional.ofNullable(map.get(id)); }
}

InMemoryCache<Order> orders = new InMemoryCache<>();
orders.put(customer);       // ❌ compile error: Customer không phải Order
Order o = orders.get("o-1").orElseThrow();   // không cần cast

Bước 2: Generic method

public static <T, K> Map<K, List<T>> groupBy(List<T> items, Function<T, K> key) {
    Map<K, List<T>> result = new HashMap<>();
    for (T item : items) result.computeIfAbsent(key.apply(item), k -> new ArrayList<>()).add(item);
    return result;
}

Map<OrderStatus, List<Order>> byStatus = groupBy(orders, Order::getStatus);  // T, K tự suy ra

Bước 3: Wildcard cho hàm tính tổng

public interface Payable { BigDecimal amount(); }
// Order và Payment đều implement Payable

static BigDecimal total(List<? extends Payable> items) {      // nhận List<Order>, List<Payment>
    return items.stream().map(Payable::amount).reduce(BigDecimal.ZERO, BigDecimal::add);
}

5. Cách hoạt động: type erasure

Source:   InMemoryCache<Order>     Order o = cache.get(id).orElseThrow();
             │ compile
Bytecode: InMemoryCache (T → Identifiable)   Order o = (Order) cache.get(id)...
             │
Runtime:  JVM không biết T là Order. List<Order> và List<Customer> cùng class List.

6. So sánh

7. Khi nào nên dùng / không nên dùng

• Nên: container, repository, util (groupBy), response wrapper ApiResponse<T>.
• Nên: wildcard ở tham số của API public để linh hoạt cho caller.
• Không nên: wildcard ở kiểu trả về (bắt caller xử lý ?); generic lồng 3 tầng khó đọc.
• Không nên: raw type List (không có <>), mất toàn bộ kiểm tra.

Đúng là trực giác bảo "phải được", nhưng nếu cho phép thì sẽ phá type-safety. Generics trong Java là invariant:

List<Order> orders = new ArrayList<>();
List<Payable> payables = orders;      // giả sử được phép
payables.add(new Payment(...));       // hợp lệ với List<Payable>
Order o = orders.get(0);              // 💥 thực ra là Payment

Mảng thì ngược lại, covariant: Payable[] arr = new Order[1]; compile được, nhưng arr[0] = new Payment() ném ArrayStoreException lúc chạy. Generics chọn chặn từ lúc compile.

Wildcard là cách nói "mình chỉ đọc": List<? extends Payable> nhận List<Order> nhưng cấm add, nên không thể xảy ra tình huống trên. Tương tự List<Object> không nhận List<String>.

Có: PECS = Producer Extends, Consumer Super. Nhìn tham số từ góc của method:

• List cho ra dữ liệu để mình đọc (producer) → ? extends T.
• List nhận vào dữ liệu mình ghi (consumer) → ? super T.

// đọc từ src, ghi vào dst: đúng chữ ký của Collections.copy
static <T> void copy(List<? super T> dst, List<? extends T> src) {
    for (T item : src) dst.add(item);
}

List<Order> paidOrders = ...;
List<Payable> toReconcile = new ArrayList<>();
copy(toReconcile, paidOrders);         // T = Order

// Comparator là consumer: nhận T để so sánh
orders.sort(Comparator.comparing(Payable::amount));   // sort(Comparator<? super Order>)

Vì sort nhận Comparator<? super E>, một comparator viết cho Payable dùng chung cho cả list Order và list Payment.

Không được, cả hai đều là hệ quả của type erasure:

public <T> T fromJson(String json, Class<T> type) {      // truyền Class để biết kiểu lúc chạy
    return objectMapper.readValue(json, type);
}
// List<Order> thì Class không đủ → Jackson dùng TypeReference
List<Order> list = objectMapper.readValue(json, new TypeReference<List<Order>>() {});

TypeReference là anonymous subclass, và kiểu generic của superclass được lưu trong bytecode, nên đọc lại được bằng reflection. Spring dùng cùng mẹo này với ParameterizedTypeReference để biết bạn inject List<PaymentGateway>.

Câu 1: Generics để làm gì?

🇻🇳 Tiếng Việt:

Generics cho phép tham số hóa kiểu để viết code tái sử dụng mà vẫn type-safe: compiler kiểm tra kiểu lúc compile, bỏ cast thủ công và chặn ClassCastException lúc chạy. Ví dụ một InMemoryCache<T extends Identifiable> dùng chung cho Order, Payment, Customer.

🇬🇧 English:

Generics parameterize types so code can be reused while staying type-safe: the compiler checks types at compile time, removes manual casts and prevents ClassCastException at runtime. For example one InMemoryCache<T extends Identifiable> serves orders, payments and customers.

Câu 2: ? extends và ? super khác gì?

🇻🇳 Tiếng Việt:

Generics là invariant nên List<Order> không phải List<Payable>. ? extends T dùng khi chỉ đọc (producer), ? super T khi ghi vào (consumer): quy tắc PECS. Ví dụ Collections.copy(List<? super T>, List<? extends T>).

🇬🇧 English:

Generics are invariant, so List<Order> is not a List<Payable>. Use ? extends T when you only read from it (producer) and ? super T when you write into it (consumer): PECS. Collections.copy(List<? super T>, List<? extends T>) is the classic example.

Câu 3: Type erasure là gì, hệ quả?

🇻🇳 Tiếng Việt:

Compiler xóa thông tin kiểu generic, thay bằng bound (hoặc Object) và chèn cast, để tương thích code trước Java 5. Hệ quả: không new T(), không instanceof List<Order>, không mảng generic, không primitive làm type argument, không overload chỉ khác type argument. Cách vòng: truyền Class<T> hoặc dùng TypeReference.

🇬🇧 English:

The compiler erases generic type information, replacing it with the bound or Object and inserting casts, for backward compatibility with pre-Java 5 code. As a result you can't call new T(), check instanceof List<Order>, create generic arrays, use primitives as type arguments, or overload methods that differ only by type argument. Workarounds are passing a Class<T> or using a TypeReference.

Cách nhớ ngắn gọn

• Generics = lỗi kiểu chuyển từ runtime sang compile time.
• Invariant: List<Order> ≠ List<Payable>; mảng thì covariant.
• PECS: đọc dùng extends, ghi dùng super.
• Erasure: runtime không biết T → truyền Class<T>.