Skip to content
TungDaDev's Blog

Optional trong Java: bẫy orElse, 6 anti-pattern và chi phí trên heap

Java optional.webp
Published on
13 mins read

userRepository.findByEmail(email).orElse(authService.createDefaultUser(email)). Đọc lên nghe rất hợp lý: tìm user, không có thì tạo mặc định. Chạy thật thì createDefaultUser bị gọi ở mọi request, kể cả khi user đã có sẵn trong DB. Bảng user bắt đầu lẫn bản ghi rác mà không ai hiểu từ đâu ra.

Đó là một trong những kiểu dùng sai java.util.Optional<T> hay gặp nhất. Optional vào Java 8 để đỡ khổ vì NullPointerException (NPE), thứ mà chính Sir Tony Hoare, người phát minh ra null reference trong ALGOL W năm 1965, từng gọi là "sai lầm tỷ đô" của đời ông (QCon London 2009). Có điều sau hơn chục năm, Optional đang bị lạm dụng ở rất nhiều codebase: bọc vào cả tham số hàm lẫn field của Entity, cấp phát thêm hàng đống vỏ bọc trong vòng lặp nóng, và nhiều khi làm code rối hơn cả kiểm tra != null truyền thống.

Chính Brian Goetz (Java Language Architect ở Oracle) từng phải nói rõ trên StackOverflow: "Our intention was to provide a limited mechanism for library method return types where there needed to be a clear way to represent "no result", and using null for such was overwhelmingly likely to cause errors." Javadoc của Optional cũng ghi đúng ý đó: nó sinh ra chủ yếu cho kiểu trả về của method. Dùng ra ngoài phạm vi đó là bắt đầu trả giá, cả về bộ nhớ lẫn độ rõ ràng của code.


# bên trong JVM: Optional tốn bộ nhớ & GC ra sao

Nhiều người nghĩ bọc một object vào Optional là "miễn phí". Với JVM thì chẳng có gì miễn phí cả.

Một Optional là một object bình thường, nằm trên heap:

# một Optional instance chiếm bao nhiêu

Trên JVM 64-bit với cấu hình mặc định, một instance Optional mang theo 12 bytes Object Header (gồm 8 bytes Mark Word và 4 bytes Klass Word nhờ -XX:+UseCompressedClassPointers) cộng với 4 bytes Field Reference cho con trỏ value (được nén nhờ -XX:+UseCompressedOops khi heap dưới khoảng 32GB). Tổng cộng 12 + 4 = 16 bytes vừa tròn bội số của 8 nên không cần byte đệm (padding), tức là mỗi vỏ Optional ngốn thêm 16 bytes RAM chưa tính object thật nằm bên trong. Nếu heap vượt 32GB làm tắt compressed oops thì con trỏ nở ra 8 bytes và kích thước vọt lên 24 bytes; còn từ Java 25, bật compact object headers (-XX:+UseCompactObjectHeaders, JEP 519) giúp thu gọn header xuống 8 bytes nhưng do căn chỉnh bội số 8 nên Optional vẫn chiếm 16 bytes. Bạn có thể tự kiểm chứng con số này bằng công cụ JOL (java -jar jol-cli.jar internals java.util.Optional).

# boxing với kiểu nguyên thuỷ còn tệ hơn

Nếu bạn viết:

Optional<Integer> count = Optional.of(1_000);

Thì cái giá là:

  1. Tạo 1 object java.lang.Integer (autoboxing): 16 bytes. Riêng các số từ -128 tới 127 thì Integer.valueOf lấy từ cache dựng sẵn, không cấp phát mới.
  2. Tạo 1 object java.util.Optional: 16 bytes.
  3. → Mất 32 bytes chỉ để chứa một số int 4 byte.

Cách tránh: với primitive thì dùng mấy class riêng OptionalInt, OptionalLong, OptionalDouble, khỏi phải tạo thêm wrapper ở giữa.

# ảnh hưởng tới garbage collector (gc pressure)

Giả sử hệ thống chạy 50.000 requests/giây mà trong mấy vòng lặp xử lý cứ tạo ra vài trăm nghìn Optional sống ngắn, thì vùng Young Generation (Eden Space) đầy nhanh hơn và Minor GC chạy dày hơn.

Nhưng cũng đừng phóng đại. Cấp phát trong Eden rất rẻ (chỉ là tăng con trỏ trong TLAB), và chi phí Minor GC tỉ lệ với số object còn sống chứ không phải số object đã chết. Hơn nữa, JIT có escape analysis: Optional tạo ra rồi dùng ngay trong một method, không thoát ra ngoài, thường được scalar replacement xoá hẳn, không cấp phát gì trên heap. Vì vậy với code thông thường, Optional ở kiểu trả về hầu như không đáng lo. Chỉ nên tối ưu khi profiler (JFR, async-profiler) chỉ ra allocation thật sự nằm ở đó.


# mấy anti-pattern nên bỏ khi dùng Optional

# anti-pattern 1: dùng Optional làm tham số method (method parameter)

// SAI LẦM KIẾN TRÚC:
public void sendInvoice(Customer customer, Optional<DiscountCode> discount) {
    // Phức tạp hóa lời gọi hàm!
}

Cách khai báo này trước hết làm khổ người gọi: mỗi lần gọi hàm đều phải tự gói dữ liệu thành sendInvoice(customer, Optional.of(code)) hoặc sendInvoice(customer, Optional.empty()), vừa dài dòng vừa tốn thêm một lần cấp phát. Tệ hơn nữa, nó chẳng hề giúp hàm an toàn hơn, vì một ngày đẹp trời ai đó truyền thẳng sendInvoice(customer, null) thì câu lệnh discount.isPresent() bên trong vẫn nổ NullPointerException như thường. Thay vì bọc tham số vào Optional, hãy dùng nạp chồng phương thức (method overloading) hoặc gắn annotation @Nullable:

public void sendInvoice(Customer customer) {
    sendInvoice(customer, null);
}
public void sendInvoice(Customer customer, @Nullable DiscountCode discount) {
    if (discount != null) { ... }
}

# anti-pattern 2: dùng Optional làm field trong JPA Entity

// NGUY HIỂM: Phá vỡ chuẩn JPA & Serialization!
@Entity
public class Employee {
    @Id
    private Long id;
 
    // SAI LẦM:
    private Optional<String> middleName;
}

Thiết kế có chủ đích của JDK là Optional không implements java.io.Serializable để ngăn lập trình viên biến nó thành trường lưu trữ lâu dài; hễ đặt làm field là các thư viện tuần tự hoá hay cache phân tán (Redis Session, Hazelcast, RMI) sẽ báo lỗi ngay. Bản thân đặc tả JPA và Hibernate cũng không coi Optional là kiểu thuộc tính hợp lệ để ánh xạ xuống cột bảng. Nếu muốn nhắc người đọc code rằng trường đó có thể trống, cách làm chuẩn là giữ nguyên field private String middleName; cho Hibernate làm việc bình thường, còn hàm getter thì trả về Optional.ofNullable(middleName).

# anti-pattern 3: bọc collection bên trong Optional (Optional<list<t>>)

// SAI LẦM: Bọc 2 tầng vô nghĩa!
public Optional<List<Order>> getOrdersByCustomer(Long customerId) { ... }

Bản thân các kiểu tập hợp (List, Set, Map) đã diễn tả rất rõ trạng thái "không có phần tử nào" bằng một tập rỗng (List.of() hoặc Collections.emptyList()). Bọc thêm Optional ra ngoài chỉ bắt người gọi phải mở hai lớp hộp vô ích; đừng bao giờ trả về Optional<List<T>> hay null, cứ trả thẳng một collection rỗng.

# anti-pattern 4: khác biệt quan trọng: orelse() vs orelseget()

Lỗi này làm chậm hệ thống một cách âm thầm, và rất hay gặp:

// NGUY HIỂM CHẾT NGƯỜI VỀ HIỆU NĂNG:
User user = userRepository.findByEmail(email)
    .orElse(authService.createDefaultUser(email)); // authService luôn luôn bị thực thi!

Khác nhau nằm ở chỗ Java tính tham số lúc nào. Với orElse(T other) (eager evaluation), biểu thức truyền vào là một tham số hàm thông thường nên JVM luôn luôn chạy nó trước rồi mới gọi orElse, bất kể bên trong Optional đã có sẵn User hay chưa; nếu biểu thức đó gọi xuống database, bắn HTTP request hay chạy thuật toán nặng thì bạn đang đốt tài nguyên (thậm chí ghi dữ liệu rác) ở mọi request. Ngược lại, orElseGet(Supplier<? extends T> supplier) (lazy evaluation) chỉ nhận vào một hàm lambda và chỉ kích hoạt Supplier đó khi chiếc hộp Optional thật sự rỗng:

// CHUẨN XÁC: Chỉ chạy khi không tìm thấy User
User user = userRepository.findByEmail(email)
    .orElseGet(() -> authService.createDefaultUser(email));

Còn giá trị mặc định là hằng số hoặc biến có sẵn (orElse("N/A"), orElse(DEFAULT_CONFIG)) thì cứ dùng orElse, chẳng tốn gì thêm.

Hai anti-pattern cuối ngắn hơn nên gom luôn ở đây. Gọi get() không kiểm tra thì chẳng khác gì dùng null: rỗng là ăn NoSuchElementException thay vì NPE. Từ Java 10 có orElseThrow() không tham số, làm đúng việc của get() nhưng tên gọi nói rõ là có thể ném exception, nên dùng nó thay get(). Trả null từ method kiểu Optional thì phá luôn lời hứa của kiểu trả về: người gọi viết findX().map(...) và nhận NPE ngay tại chỗ tưởng an toàn nhất. Không có gì thì trả Optional.empty().


# dùng Optional theo kiểu functional: monadic pipeline

Thay vì viết kiểu imperative với if (opt.isPresent()), có thể dùng map, flatMap, filter của Optional (cùng ý tưởng với Stream, dân functional gọi đây là kiểu monad) để biến đổi dữ liệu cho an toàn:

# luồng xử lý thanh toán không bao giờ ném npe

@RequiredArgsConstructor
public class PaymentProcessingService {
 
    private final PaymentGateway paymentGateway;
    private final FraudDetector fraudDetector;
 
    public String processPayment(PaymentRequest request) {
        return Optional.ofNullable(request)
            // 1. Kiểm tra điều kiện đầu vào
            .filter(req -> req.amount().compareTo(BigDecimal.ZERO) > 0)
            // 2. Chặn các giao dịch nghi vấn gian lận
            .filter(req -> !fraudDetector.isFlagged(req.cardNumber()))
            // 3. FlatMap: Gọi phương thức trả về Optional khác mà không bị lồng Optional<Optional<T>>
            .flatMap(req -> paymentGateway.charge(req.cardNumber(), req.amount()))
            // 4. Biến đổi dữ liệu đầu ra
            .map(Receipt::transactionId)
            // 5. Thất bại: mọi nhánh rỗng ở trên đều đổ về đây
            .orElseThrow(() -> new PaymentProcessingException("Giao dịch bị từ chối hoặc dữ liệu không hợp lệ"));
    }
}

Pipeline này gọn, nhưng có hai chỗ cần biết. Thứ nhất, nó chỉ chống được request null; req.amount() mà null thì compareTo vẫn ném NPE ngay trong filter. Thứ hai, số tiền không hợp lệ, thẻ bị gắn cờ gian lận và cổng thanh toán từ chối đều thành cùng một exception, cùng một message, nên log và client không biết thật ra hỏng ở bước nào. Khi các nhánh lỗi cần xử lý khác nhau thì kiểm tra tuần tự với exception riêng cho từng trường hợp vẫn rõ ràng hơn.

# mấy method có thêm từ Java 9+

Từ Java 9 tới Java 11, API của Optional được bổ sung thêm vài mảnh ghép rất tiện để nối chuỗi không bị đứt mạch: ifPresentOrElse(Consumer, Runnable) giúp xử lý gọn cả nhánh có dữ liệu lẫn nhánh rỗng trong một lời gọi; or(Supplier<Optional<T>>) cho phép nối tiếp sang một nguồn dự phòng khác cũng trả về Optional (rất hợp khi tìm trong cache không thấy thì tìm tiếp dưới DB); còn stream() biến một Optional thành Stream gồm 0 hoặc 1 phần tử để nhét thẳng vào Stream.flatMap(Optional::stream) nhằm lọc sạch các kết quả rỗng. Bên cạnh đó là orElseThrow() không tham số (Java 10) thay cho get(), và isEmpty() (Java 11) đối xứng với isPresent().


# sắp tới: null-safety với JSpecify & project valhalla

Với Java sau này, Optional không còn là cách duy nhất để kiểm soát null. Về phía Valhalla, JEP 401 (Value Objects) đã được tích hợp cho JDK 28 dưới dạng preview, và Optional, OptionalInt... nằm trong nhóm class được khai báo lại thành value class. Value object không có identity nên JVM được phép làm phẳng hoặc giữ nó trong thanh ghi thay vì cấp phát trên heap, nhưng đó là cho phép chứ không phải cam kết, và phải bật --enable-preview mới dùng được.

# chuẩn hoá với JSpecify

Thay vì cái gì cũng bọc vào Optional, nhiều người khuyên dùng chuẩn JSpecify (bản 1.0 ra tháng 7/2024, Spring Framework 7 đã chuyển sang dùng) cùng công cụ phân tích tĩnh NullAway của Uber. Bản thân javac không hiểu mấy annotation này; NullAway chạy như một plugin của Error Prone trong lúc biên dịch, nên build fail khi có chỗ dùng giá trị nullable mà chưa kiểm tra:

import org.jspecify.annotations.NonNull;
import org.jspecify.annotations.Nullable;
 
public class CustomerService {
    // NullAway (chạy lúc build) bắt người gọi phải kiểm tra null trước khi dùng
    public @Nullable Customer findCustomer(@NonNull String nationalId) {
        // ...
    }
}

Dev mà dùng kết quả khi chưa kiểm tra null là IDE (IntelliJ đã hiểu JSpecify) và NullAway báo lỗi ngay, còn lúc runtime thì không tốn thêm gì cả. Thực tế thường gắn @NullMarked ở mức package hoặc class để mặc định mọi thứ là non-null, khi đó chỉ cần ghi @Nullable ở chỗ có thể null, khỏi rải @NonNull khắp nơi.


# checklist trước khi lên production

  • 1. Chỉ dùng làm return type: Optional chỉ nên là kiểu trả về của những method nghiệp vụ có thể không có kết quả. Không dùng làm tham số hay field.
  • 2. Không bao giờ return null: method trả về Optional thì đừng viết return null;. Luôn trả Optional.empty().
  • 3. Phân biệt orElse và orElseGet: chỗ nào gọi orElse() mà bên trong có gọi hàm hay tính toán thì đổi hết sang orElseGet().
  • 4. Primitive specialization: dùng OptionalInt, OptionalLong, OptionalDouble cho kiểu nguyên thuỷ để khỏi autoboxing.
  • 5. Không bọc collection: method nào trả về List, Set, Map thì trả collection rỗng, không trả Optional.

# lời kết

Một thử nghiệm mười phút: search .orElse( trong codebase và đọc từng tham số truyền vào. Chỗ nào là lời gọi method (nhất là repository, service, client HTTP) thay vì hằng số hay biến có sẵn, đổi sang orElseGet(() -> ...). Theo mình đây là anti-pattern đáng sửa trước nhất: sửa một dòng là bớt hẳn một lỗi.

Sau đó, nếu dự án đang dùng Error Prone hoặc sắp lên Spring Framework 7, thử gắn @NullMarked cho một package nhỏ và bật NullAway. Số cảnh báo đầu tiên sẽ cho bạn biết codebase đang dựa vào null nhiều tới đâu, trước khi quyết định bọc thêm Optional ở chỗ nào.


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 😎 👍🏻 🚀 🔥.