Đến nội dung chính
notes.vinhnq.com

Tìm kiếm

Java CoreJunior16 phút đọc

Exception trong Java: checked/unchecked, try-catch-finally và call stack

Ôn 14 thẻ
Trong bài này

Cụm bài Exception và xử lý lỗi: 1. Exception trong Java · 2. Custom exception và xử lý lỗi trong Spring Boot

Chương trình nào cũng gặp lỗi: file không có, mạng chập chờn, dữ liệu sai, chia cho 0. Bài này là phần Java core: cây Throwable, checked vs unchecked, throw/throws, try-catch-finally, try-with-resources, đường đi qua call stack và chi phí của exception. Phần 2 đi tiếp sang custom exception và Spring Boot: @RestControllerAdvice, ProblemDetail và validate DTO.

1. Exception là gì

Ý chính: exception là một object mô tả sự cố lúc chạy. Nó tách phần phát hiện lỗi khỏi phần xử lý lỗi.

Vì là object nên nó có class, field (message, cause, stack trace) và kế thừa được, nên ta tự định nghĩa được exception riêng. Luồng cơ bản:

  • Method bị gọi (callee) phát hiện lỗi, tạo exception và ném bằng throw.
  • Method gọi nó (caller) bắt (catch) và xử lý, hoặc để exception bay tiếp lên trên.
  • Không ai bắt: exception lên tới đỉnh stack, JVM in stack trace và thread đó dừng (app console thì cả chương trình chết).

Lợi ích: code nghiệp vụ không bị trộn với hàng loạt if (errorCode != 0) kiểu C. Chỗ phát hiện lỗi thường không biết nên retry, báo người dùng hay rollback; chỗ xử lý thì biết.

2. Cây kế thừa Throwable

Ý chính: mọi thứ ném được đều là Throwable. Error là JVM gặp nạn (đừng bắt), Exception là lỗi app xử lý được, RuntimeException thường là bug.

flowchart LR
  Object --> Throwable
  Throwable --> Exception
  Throwable --> Error
  Exception --> IOException
  Exception --> SQLException
  Exception --> ClassNotFoundException
  Exception --> RuntimeException
  RuntimeException --> NullPointerException
  RuntimeException --> IllegalArgumentException
  RuntimeException --> ArithmeticException
  RuntimeException --> IndexOutOfBoundsException
  IllegalArgumentException --> NumberFormatException
  Error --> OutOfMemoryError
  Error --> StackOverflowError
  Error --> LinkageError
  • Throwable: gốc; chỉ object là Throwable (hoặc con) mới throw được.
  • Error: sự cố mức JVM/môi trường (OutOfMemoryError, StackOverflowError, NoClassDefFoundError). App thường không nên bắt và cố “chữa”.
  • Exception: lỗi app dự liệu và xử lý được.
  • RuntimeException: con của Exception, thường là lỗi lập trình hoặc đầu vào sai điều kiện.

Checked vs unchecked

Chọn checked hay unchecked trong code ứng dụng (vì sao checked lan throws qua mọi tầng, không hợp với lambda, và cách bọc exception của thư viện tại boundary kèm cause) được bàn ở Clean code: xử lý lỗi, boundary và refactor.

3. Ném exception: throw và throws

Ý chính: throw là câu lệnh ném một instance ngay lúc này. throws là một phần chữ ký method, liệt kê checked exception để caller biết mà xử lý.

public class AccountService {

    // Checked: caller bắt buộc phải xử lý hoặc khai báo tiếp
    public String readStatement(Path file) throws IOException {
        return Files.readString(file);
    }

    // Unchecked: không cần khai báo, nhưng nên ghi vào Javadoc
    public void withdraw(Account account, long amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("amount must be positive, got " + amount);
        }
        if (account.balance() < amount) {
            throw new InsufficientBalanceException(account.id(), amount);
        }
        // ...
    }
}

Luật khi override: method ghi đè không được ném thêm checked exception rộng hơn method cha. Interface khai báo void run() không throws thì implementation không ném được IOException.

4. Bắt exception: try-catch

Ý chính: các catch được xét từ trên xuống và chỉ handler khớp đầu tiên chạy. Vì thế lớp con phải đứng trước lớp cha.

try {
    String content = Files.readString(path);
    int value = Integer.parseInt(content.trim());
    process(value);
} catch (NoSuchFileException e) {          // cụ thể nhất trước
    log.warn("Config file missing: {}", path);
} catch (NumberFormatException | IllegalStateException e) {  // multi-catch
    log.warn("Bad config content", e);
} catch (IOException e) {                   // tổng quát hơn sau
    throw new UncheckedIOException(e);
}
  • Đặt catch (IOException) trước catch (NoSuchFileException) thì compiler báo “exception has already been caught”, vì block sau không bao giờ tới được.
  • Multi-catch catch (A | B e): A và B không được là cha con (compile error); biến e là effectively final.
  • Không muốn xử lý ở đây thì để nó bay lên (checked thì khai báo throws).

Exception lan truyền qua call stack

main gọi method1, method1 gọi method2, method2 gọi method3. Mỗi tầng bắt một loại riêng (Ex1, Ex2, Ex3), và method3 ném:

sequenceDiagram
  participant M as main (catch Ex1)
  participant A as method1 (catch Ex2)
  participant B as method2 (catch Ex3)
  participant C as method3
  M->>A: gọi
  A->>B: gọi
  B->>C: gọi
  C--)B: ném exception
  Note over B: Có phải Ex3? Có thì xử lý, chạy tiếp code sau try-catch của method2
  B--)A: Không khớp: frame method2 bị pop, ném tiếp lên
  Note over A: Có phải Ex2? Có thì xử lý, phần còn lại của method2 bị bỏ qua
  A--)M: Không khớp: frame method1 bị pop
  Note over M: Có phải Ex1? Không khớp thì thread kết thúc, in stack trace
  • Ex3: method2 bắt. Phần còn lại trong try của nó bị bỏ, nhưng code sau khối try-catch chạy bình thường. method1 và main không biết có lỗi.
  • Ex2: frame method2 bị bỏ, method1 xử lý rồi chạy tiếp code sau try-catch của nó.
  • Ex1: đi tới tận main.
  • Không khớp ở đâu: thread chết, UncaughtExceptionHandler mặc định in stack trace.
Bên trong JVM: exception table và stack unwinding

Mỗi method có một exception table trong bytecode, mỗi dòng gồm khoảng lệnh from..to, target (chỗ nhảy tới) và type. Khi có exception, JVM tra bảng của frame hiện tại. Không có dòng nào khớp thì pop frame và tra tiếp frame của caller; quá trình gỡ dần từng frame này gọi là stack unwinding.

5. finally

Ý chính: finally chạy dù try xong bình thường, ném exception hay return giữa chừng. Dùng để dọn dẹp; với resource thì try-with-resources tốt hơn.

try {
    step1();
    step2();        // có thể ném exception
    step3();
} catch (BusinessException e) {
    recover();
} finally {
    cleanup();      // (*)
}
afterAll();         // (**)
Tình huống step3 recover cleanup (*) afterAll (**)
Không có exception chạy không chạy chạy
step2 ném BusinessException bỏ qua chạy chạy chạy
step2 ném loại khác (không khớp catch) bỏ qua không chạy không: exception bay lên caller
recover() lại ném exception chạy không

“finally luôn chạy” có ngoại lệ: System.exit(), JVM crash/bị kill -9, thread treo vô hạn trong try, daemon thread khi JVM tắt.

Bẫy với finally

try-with-resources (Java 7+)

6. Khi nào nên dùng exception

Ý chính: ném khi method không giữ được contract và caller mới đủ ngữ cảnh để quyết định. Bắt ở nơi xử lý được; không thì ném lại, luôn kèm cause.

Bọc thành exception nghiệp vụ, giữ cause để stack trace còn nguyên:

try {
    paymentGateway.charge(order);
} catch (IOException e) {
    throw new PaymentUnavailableException("Gateway unreachable for order " + order.id(), e); // giữ cause
}

Những điều không làm:

  • Dùng exception cho luồng điều khiển thường (vd. bắt NumberFormatException để kiểm tra chuỗi là số trong vòng lặp nóng): tạo exception tốn vì fillInStackTrace() đi qua cả stack.
  • Nuốt exception: catch (Exception e) {} sinh ra bug mất cả ngày để tìm. Tối thiểu log kèm stack trace, hoặc ném lại.
  • Ném Exception chung (throw new Exception("Error")): caller buộc phải catch (Exception e), và khối đó vô tình bắt cả bug (NPE, index sai). Ném loại cụ thể (IllegalArgumentException, IllegalStateException) hoặc custom exception nghiệp vụ.
  • Bắt Throwable/Error, trừ ở biên ngoài cùng (top-level handler, framework).

Bắt InterruptedException mà không ném lại thì phải gọi Thread.currentThread().interrupt() để khôi phục cờ interrupt.

Đi sâu hơn: chi phí và hiệu năng

Chi phí lớn nhất là chụp stack trace khi khởi tạo, không phải ở throw/catch. Stack càng sâu (Spring + Hibernate dễ có 100+ frame) càng tốn.

Tắt stack trace và OmitStackTraceInFastThrow

Exception nghiệp vụ tần suất cao, không cần stack trace: dùng constructor Throwable(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) với writableStackTrace = false.

Checked exception và lambda

Function, Supplier… không khai báo throws, nên lambda không ném checked exception được. Cách sửa: bọc vào unchecked (UncheckedIOException) trong lambda, hoặc tự định nghĩa functional interface có throws. Đây là một lý do Spring, Hibernate chuyển hẳn sang unchecked.

Bài tập

Bài 1: Sửa lỗi compile

Đề (diễn đạt lại): một method nhận số nguyên và ném new Exception("...") khi giá trị nhỏ hơn một ngưỡng, nhưng không khai báo gì. Hãy làm nó compile được.

Lời giải Bài 1

Nguyên nhân: Exception là checked, method ném ra mà không catch cũng không khai báo throws.

// Cách 1: khai báo throws, đẩy trách nhiệm cho caller
public void check(int value) throws Exception {
    if (value < 40) {
        throw new Exception("value is too small");
    }
}

// Cách 2 (nên dùng): đây là lỗi đầu vào, dùng unchecked đúng ngữ nghĩa
public void check(int value) {
    if (value < 40) {
        throw new IllegalArgumentException("value must be >= 40, got " + value);
    }
}

Cách 1 compile được nhưng throws Exception quá rộng, ép mọi caller xử lý một thứ chung chung. Cách 2 nói đúng bản chất: caller truyền sai tham số.

Bài 2: Trường hợp nào ném exception?

Đề (diễn đạt lại): sáu đoạn main ngắn (chia cho 0, index sai, ép kiểu sai, gọi method trên null…). Đoán đoạn nào ném exception lúc chạy và giải thích.

Lời giải Bài 2
Đoạn code Kết quả Giải thích
In 1 / 0 ArithmeticException: / by zero Chia số nguyên cho 0
Mảng 5 phần tử, đọc list[5] ArrayIndexOutOfBoundsException Index hợp lệ là 0..4
"abc".charAt(3) StringIndexOutOfBoundsException Index hợp lệ là 0..2
(String) new Object() ClassCastException Object thật không phải String; compiler cho qua vì là downcast hợp lệ về kiểu
Object o = null; o.toString() NullPointerException Gọi method trên null
In 1.0 / 0 Không ném, in Infinity Số thực theo IEEE 754: chia cho 0 ra Infinity/NaN

Năm exception đầu đều unchecked (RuntimeException), nên compiler không bắt khai báo và chúng chỉ lộ ra lúc chạy.

Bài 3: Câu hỏi về finally

Đề: với try { s1; s2; s3; } catch (Ex1 e) { s4; } finally { s5; } s6; và s2 có thể ném, những câu nào chạy trong từng trường hợp?

Lời giải Bài 3
  • Không có exception: s1, s2, s3, s5, s6.
  • Exception là Ex1: s1, s2(ném), s4, s5, s6.
  • Exception không phải Ex1: s1, s2(ném), s5, rồi exception bay lên caller; s6 không chạy.

Bài 4: Kiểm tra điểm với throw và finally

Đề (diễn đạt lại): viết checkScore(int score) ném IllegalArgumentException khi điểm ngoài khoảng 0–10, ngược lại in điểm. main đọc một số nguyên từ bàn phím, gọi checkScore trong try, in lỗi nếu có, và luôn in dòng kết thúc trong finally.

Lời giải Bài 4
import java.util.InputMismatchException;
import java.util.Scanner;

public class ScoreCheck {
    static void checkScore(int score) {
        if (score < 0 || score > 10) {
            throw new IllegalArgumentException("Điểm không hợp lệ: phải từ 0 đến 10, nhận được " + score);
        }
        System.out.println("Điểm của bạn là: " + score);
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        try {
            System.out.print("Nhập điểm: ");
            checkScore(in.nextInt());
        } catch (IllegalArgumentException e) {
            System.out.println("Lỗi: " + e.getMessage());
        } catch (InputMismatchException e) {
            System.out.println("Lỗi: hãy nhập một số nguyên");
        } finally {
            System.out.println("Kết thúc chương trình.");
        }
    }
}

Chạy thử với 8, 11 và abc:

Nhập điểm: 8
Điểm của bạn là: 8
Kết thúc chương trình.

Nhập điểm: 11
Lỗi: Điểm không hợp lệ: phải từ 0 đến 10, nhận được 11
Kết thúc chương trình.

Nhập điểm: abc
Lỗi: hãy nhập một số nguyên
Kết thúc chương trình.
  • IllegalArgumentException là unchecked nên checkScore không cần throws. Message nên kèm giá trị sai (nhận được 11) để đọc log là biết ngay.
  • Người dùng còn có thể gõ chữ: Scanner.nextInt() ném InputMismatchException (cũng unchecked). Nếu không bắt, dòng trong finally vẫn được in, rồi chương trình mới chết với stack trace.
  • Hướng senior: tách kiểm tra khỏi việc in. checkScore chỉ kiểm tra rồi trả về hoặc ném; in gì là việc của caller. Như vậy unit test các biên 0, 10, -1, 11 rất dễ.

Ghi nhớ

  • Giải thích được checked khác unchecked ở đâu, và vì sao Error là unchecked nhưng không phải lỗi logic.
  • Đoán được câu nào chạy khi exception bay qua try-catch-finally và qua nhiều tầng call stack.
  • Biết vì sao try-with-resources tốt hơn tự đóng trong finally (suppressed exception), và vì sao không return trong finally.
  • Nêu được các luật dùng exception: giữ cause, không nuốt, không ném Exception chung, không dùng cho luồng điều khiển.
  • Biết chi phí exception nằm ở đâu và vì sao NPE trên production có thể mất stack trace.

Câu hỏi phỏng vấn

Junior

Checked và unchecked exception khác nhau thế nào?

Checked bị compiler bắt “catch or declare”; unchecked thì không.

Checked là con của Exception nhưng không thuộc RuntimeException; unchecked là RuntimeException và Error. Checked thường cho sự cố bên ngoài có thể phục hồi (I/O), unchecked cho lỗi lập trình hoặc vi phạm contract.

throw khác throws ra sao?

throw là câu lệnh ném một instance; throws là phần chữ ký method khai báo checked exception có thể ném.

throws cho caller biết phải xử lý những gì.

finally có luôn chạy không?

Gần như luôn, kể cả khi try có return hoặc ném exception.

Ngoại lệ: System.exit(), JVM crash/bị kill, thread treo vô hạn, daemon thread khi JVM tắt.

Vì sao phải đặt catch lớp con trước lớp cha?

Vì catch xét từ trên xuống và chỉ chạy handler khớp đầu tiên.

Lớp cha đứng trước thì handler lớp con không bao giờ tới được, compiler báo lỗi unreachable.

Mid

try-with-resources giải quyết vấn đề gì, suppressed exception là gì?

Nó tự đóng AutoCloseable theo thứ tự ngược, và không để exception của close() đè mất exception gốc.

Thân try và close() cùng ném thì exception của thân là chính, exception của close() gắn vào getSuppressed(). Viết tay trong finally thì exception gốc hay bị đè mất.

Senior

Exception có tốn chi phí không? Bạn tối ưu thế nào?

Có: chi phí chính là chụp stack trace lúc khởi tạo (fillInStackTrace), tỉ lệ với độ sâu stack.

  • Không dùng exception cho luồng điều khiển thường xuyên.
  • Exception nghiệp vụ tần suất cao: tắt stack trace bằng constructor writableStackTrace=false.
  • Lưu ý OmitStackTraceInFastThrow khiến NPE lặp lại mất stack trace trong log.
Exception ném trong @Async hoặc trong một thread của executor thì đi đâu?

Không về tới caller hay @ControllerAdvice; phải chủ động xử lý, nếu không lỗi bị mất.

  • Future/CompletableFuture: exception được gói lại, lộ ra khi get()/join() (dạng ExecutionException/CompletionException).
  • Method void @Async: vào AsyncUncaughtExceptionHandler (mặc định chỉ log).
  • Thread thường: vào UncaughtExceptionHandler.

Từ vựng tiếng Anh

Term Phát âm Nghĩa Ví dụ câu trong phỏng vấn
exception /ɪkˈsɛpʃən/ ngoại lệ “An exception signals that a method couldn’t fulfill its contract.”
throw / rethrow /θroʊ/ ném / ném lại “If the handler can’t recover, it should rethrow with the original cause.”
propagate /ˈprɒpəɡeɪt/ lan truyền “Unchecked exceptions propagate up the call stack until something catches them.”
call stack /kɔːl stæk/ ngăn xếp lời gọi “The JVM unwinds the call stack frame by frame looking for a matching handler.”
stack trace /stæk treɪs/ vết ngăn xếp “Never return the stack trace to the client; log it instead.”
checked exception /tʃɛkt/ ngoại lệ được compiler kiểm tra “Checked exceptions must be either caught or declared.”
swallow an exception /ˈswɒloʊ/ nuốt lỗi (bắt rồi bỏ qua) “Swallowing exceptions hides bugs and makes incidents hard to debug.”
root cause /ruːt kɔːz/ nguyên nhân gốc “Wrap the exception but keep the root cause so the stack trace stays complete.”
suppressed exception /səˈprɛst/ ngoại lệ bị nén “try-with-resources attaches close failures as suppressed exceptions.”
recover / recoverable /rɪˈkʌvər/ phục hồi / có thể phục hồi “Use checked exceptions only for recoverable conditions.”

Ghi chép dựa trên khoá Fundamentals of Backend (Ronin Engineer) và tài liệu Java Core của Hỏi Dân IT, cộng thêm kiến thức tự tìm hiểu, viết lại theo cách hiểu của mình.