Debug Java trong IntelliJ: breakpoint và cách đọc stack trace

Debug Java trong IntelliJ: đặt breakpoint, step over, step into, xem biến và đọc stack trace với NullPointerException qua lỗi giảm giá đơn hàng.

Debug nghĩa là cho chương trình dừng giữa chừng để bạn xem giá trị từng biến và đi tiếp từng bước. Stack trace là danh sách các method đã gọi nhau dẫn tới lỗi. Khi đọc, bạn tìm dòng at đầu tiên nằm trong code của mình, và dòng Caused by cuối cùng để biết nguyên nhân gốc.

Ở bài trước, bạn dựng được project Maven in phiếu tính tiền cho quán Mộc (quán cà phê tình huống minh họa của loạt bài). Nhưng chương trình chạy được chưa có nghĩa là chạy đúng. Có hai kiểu "sai" mà mọi người viết code đều gặp: chương trình sập với một đống chữ đỏ, và chương trình chạy êm nhưng in ra con số sai. Bài này xử lý cả hai, bằng hai chương trình mà mình cố tình viết lỗi.

Stack trace của Java nói gì với bạn?

Mình bắt đầu với kiểu sập. Chương trình InPhieuLoi in từng dòng món của một đơn: mã món 0 là "Cà phê sữa", mã món 2 là một món mà mình quên điền tên (giá trị null, nghĩa là "không có gì"). Đơn số 7 có hai dòng, dòng thứ hai dùng mã món 2.

src/main/java/vn/moc/donhang/InPhieuLoi.java
package vn.moc.donhang;

public class InPhieuLoi {

    static final String[] TEN_MON = {"Cà phê sữa", "Bạc xỉu", null, "Bánh mì que"}; // chỉ số 2 chưa có tên

    static String dinhDangDong(int maMon, int soLuong) {
        String ten = TEN_MON[maMon];
        return soLuong + " x " + ten + " (" + ten.length() + " ký tự)";
    }

    static void inPhieu(int maDon, int[] dsMaMon, int[] dsSoLuong) {
        try {
            for (int i = 0; i < dsMaMon.length; i++) {
                System.out.println(dinhDangDong(dsMaMon[i], dsSoLuong[i]));
            }
        } catch (NullPointerException e) {
            throw new IllegalStateException("Không in được phiếu của đơn " + maDon, e);
        }
    }

    public static void main(String[] args) {
        inPhieu(7, new int[]{0, 2}, new int[]{2, 1});
    }
}

Mình build rồi chạy (hai cờ -D giúp chữ tiếng Việt in đúng trên Windows, như bài đầu tiên):

Chạy (trong thư mục project, sau mvn package)
java -Dstdout.encoding=UTF-8 -Dstderr.encoding=UTF-8 -cp target/classes vn.moc.donhang.InPhieuLoi
Kết quả
2 x Cà phê sữa (10 ký tự)
Exception in thread "main" java.lang.IllegalStateException: Không in được phiếu của đơn 7
	at vn.moc.donhang.InPhieuLoi.inPhieu(InPhieuLoi.java:19)
	at vn.moc.donhang.InPhieuLoi.main(InPhieuLoi.java:24)
Caused by: java.lang.NullPointerException: Cannot invoke "String.length()" because "ten" is null
	at vn.moc.donhang.InPhieuLoi.dinhDangDong(InPhieuLoi.java:10)
	at vn.moc.donhang.InPhieuLoi.inPhieu(InPhieuLoi.java:16)
	... 1 more

Dòng đầu là kết quả đúng của dòng món thứ nhất, tới dòng thứ hai thì sập. Đoạn chữ đỏ phía dưới là stack trace. Mình đọc từng phần.

Khối đầu tiên bắt đầu bằng loại lỗi và thông báo: IllegalStateException: Không in được phiếu của đơn 7. Đây là thông báo do chính mình viết ở dòng throw new IllegalStateException(...). Dưới nó là các dòng at, mỗi dòng là một method đang chạy lúc lỗi xảy ra, kèm tên file và số dòng. Dòng trên cùng là nơi lỗi được ném ra gần nhất, các dòng dưới là những method đã gọi nó: inPhieu ở dòng 19 được main gọi ở dòng 24.

Dòng bắt đầu bằng Caused by mới là nguyên nhân gốc. Ở chỗ catch, mình bắt lỗi rồi bọc nó vào một lỗi khác, kèm e làm tham số thứ hai, để thêm thông tin "đơn nào".

Java giữ cả hai và in lỗi gốc sau chữ Caused by. Lỗi gốc là NullPointerException ở InPhieuLoi.java:10. Dòng cuối ... 1 more nghĩa là còn một dòng nữa trùng với khối bên trên (main), nên Java không in lại cho đỡ dài.

Thông báo của NullPointerException ở đây rất cụ thể: Cannot invoke "String.length()" because "ten" is null, tức bạn gọi .length() trên biến ten, mà ten đang là null. Java chỉ viết rõ vậy từ bản 15 trở đi. Ở bản 14 bạn phải bật một cờ riêng mới có, và các bản cũ hơn chỉ in NullPointerException trống trơn (xem JEP 358). Trên Java 25 trong bài này, thông báo có đầy đủ tên biến vì Maven biên dịch kèm thông tin debug theo mặc định.

Từ đó, cách tìm lỗi là một chuỗi ba bước.

Bước một, mở dòng 10, dòng ten.length(), vì đó là nơi lỗi bùng ra. Bước hai, hỏi ten đến từ đâu: dòng 9, TEN_MON[maMon]. Bước ba, xem maMon là bao nhiêu khi lỗi xảy ra: nhìn tiếp xuống at inPhieu, dòng 16 gọi dinhDangDong(dsMaMon[i], ...) với i là 1, và mảng dsMaMon là {0, 2}, nên maMon là 2, đúng phần tử null trong TEN_MON. Lỗi không nằm ở .length(); nó nằm ở dữ liệu, tức mã món 2 chưa có tên. Dòng bắn lỗi thường là nơi lỗi lộ ra, còn nguyên nhân hay nằm ở chỗ khác.

Có một cái bẫy mà mình thấy người mới hay mắc: nếu ở dòng throw new IllegalStateException(...) bạn không truyền e, Java chỉ in lỗi bọc ngoài và bạn mất hẳn khối Caused by, tức mất luôn dòng 10. Hãy luôn giữ lỗi gốc khi bọc. Bạn cũng có thể đọc thêm về cách đọc stack trace nói chung ở bài đọc stack trace, viết cho JavaScript nhưng cách nghĩ giống nhau.

Chương trình chạy êm nhưng in sai thì làm sao?

Kiểu sai thứ hai khó hơn, vì không có chữ đỏ nào chỉ đường. Đơn của Mai gồm 3 trà đào (45.000 đồng một ly) và 1 cà phê sữa (35.000 đồng): tổng 170.000 đồng, theo quy tắc của quán thì giảm 10% là 17.000 và Mai trả 153.000 đồng. Mình viết một bản tính tiền có lỗi:

src/main/java/vn/moc/donhang/GiamGiaLoi.java
package vn.moc.donhang;

public class GiamGiaLoi {

    static long tinhTienPhaiTra(int[] soLuong, long[] donGia) {
        long phaiTra = 0;
        for (int i = 0; i < soLuong.length; i++) {
            long thanhTien = soLuong[i] * donGia[i];
            if (thanhTien >= 100_000) {
                thanhTien = thanhTien - thanhTien * 10 / 100;
            }
            phaiTra += thanhTien;
        }
        return phaiTra;
    }

    public static void main(String[] args) {
        // Đơn của Mai: 3 trà đào (45000) + 1 cà phê sữa (35000). Tổng 170000, đáng ra giảm 17000.
        int[] soLuong = {3, 1};
        long[] donGia = {45_000, 35_000};
        System.out.println("Phải trả: " + tinhTienPhaiTra(soLuong, donGia));
    }
}
Kết quả của java -Dstdout.encoding=UTF-8 -cp target/classes vn.moc.donhang.GiamGiaLoi
Phải trả: 156500

Con số sai: phải là 153.000 mà ra 156.500, chênh 3.500.

Cách mà gần như ai cũng làm đầu tiên là chèn thêm các dòng System.out.println để in biến ra. Cách này chạy được và đôi khi là đủ, nhưng nó có ba điểm yếu: bạn phải đoán trước cần in biến nào, mỗi lần đổi chỗ in là phải biên dịch và chạy lại, và bạn phải nhớ xóa các dòng in khi xong, kẻo chúng lọt vào code thật. Debugger được làm ra để tránh những chuyện đó.

Debugger dùng thế nào: breakpoint, step và xem biến?

Debugger cho phép bạn đặt breakpoint (điểm dừng) ở một dòng. Khi chương trình chạy tới đó, nó dừng lại, và bạn xem được mọi biến lúc ấy, rồi đi tiếp từng bước hoặc cho chạy tiếp tới breakpoint kế.

Trong IntelliJ, các bước như sau (mình mô tả theo thiết lập mặc định của bản cho Windows và Linux, và chưa chụp màn hình trong bài này). Bạn nhấn vào lề trái cạnh số dòng 13, chỗ phaiTra += thanhTien;, để có chấm đỏ.

Sau đó bấm chuột phải vào class có main và chọn Debug (biểu tượng con bọ). Chương trình dừng ở dòng có chấm đỏ, tô sáng dòng đó, và cửa sổ Debug ở dưới hiện danh sách biến cùng giá trị.

Các phím hay dùng: F8 chạy hết dòng hiện tại rồi dừng ở dòng kế (step over), F7 chui vào bên trong method được gọi ở dòng đó (step into), Shift+F8 thoát ra khỏi method hiện tại (step out), và F9 chạy tiếp tới breakpoint kế (resume). Alt+F8 mở hộp để tính thử một biểu thức, ví dụ phaiTra + thanhTien, mà không phải sửa code. Chuột phải lên chấm đỏ cho bạn đặt thêm điều kiện, ví dụ chỉ dừng khi i == 1, rất tiện khi vòng lặp chạy cả nghìn lần.

Để bạn thấy một phiên debug thật mà không phụ thuộc vào giao diện, mình dùng jdb, trình debug dòng lệnh đi kèm JDK. Nó làm cùng việc như IntelliJ, chỉ khác là bạn gõ lệnh. Bạn mở nó bằng jdb -classpath target/classes vn.moc.donhang.GiamGiaLoi, rồi gõ từng lệnh dưới đây, mỗi lệnh sau khi dấu nhắc trở lại. Lệnh stop at đặt breakpoint ở dòng 13, run chạy chương trình, locals in các biến, print in một biểu thức, where in ngăn xếp các method đang gọi và cont chạy tiếp.

Phiên jdb: breakpoint ở dòng 13, các lệnh gõ sau dấu >
> stop at vn.moc.donhang.GiamGiaLoi:13
Deferring breakpoint vn.moc.donhang.GiamGiaLoi:13.
It will be set after the class is loaded.
> run
run vn.moc.donhang.GiamGiaLoi
Set uncaught java.lang.Throwable
Set deferred uncaught java.lang.Throwable
> 
VM Started: Set deferred breakpoint vn.moc.donhang.GiamGiaLoi:13

Breakpoint hit: "thread=main", vn.moc.donhang.GiamGiaLoi.tinhTienPhaiTra(), line=13 bci=48

main[1] locals
Method arguments:
soLuong = instance of int[2] (id=462)
donGia = instance of long[2] (id=463)
Local variables:
phaiTra = 0
i = 0
thanhTien = 121500
main[1] where
  [1] vn.moc.donhang.GiamGiaLoi.tinhTienPhaiTra (GiamGiaLoi.java:13)
  [2] vn.moc.donhang.GiamGiaLoi.main (GiamGiaLoi.java:22)
main[1] cont
> 
Breakpoint hit: "thread=main", vn.moc.donhang.GiamGiaLoi.tinhTienPhaiTra(), line=13 bci=48

main[1] locals
Method arguments:
soLuong = instance of int[2] (id=462)
donGia = instance of long[2] (id=463)
Local variables:
phaiTra = 121500
i = 1
thanhTien = 35000
main[1] print phaiTra + thanhTien
 phaiTra + thanhTien = 156500

Hãy đọc vòng thứ nhất (i = 0): thanhTien = 121500. Dòng trà đào là 3 × 45.000 = 135.000, nhưng ở đây nó đã thành 121.500, nghĩa là đã bị giảm 13.500 trước khi cộng. Vòng thứ hai (i = 1): cà phê sữa chỉ có 35.000 nên không giảm, và tổng cuối là 121.500 + 35.000 = 156.500, đúng con số sai.

Giờ lỗi lộ ra, mà mình không phải đoán. Cái if (thanhTien >= 100_000) đang xét từng dòng món, trong khi quy tắc của quán xét tổng cả đơn. Dòng trà đào tình cờ vượt 100.000 nên bị giảm riêng 10% của 135.000 là 13.500, còn dòng cà phê sữa không được giảm. Đúng ra phải cộng hết trước (170.000), rồi mới xét ngưỡng và giảm 10% của 170.000, tức 17.000. Phần chênh 17.000 trừ 13.500 là đúng 3.500, khớp với con số lệch ở trên.

Bạn có thể tự hỏi sao không in luôn bằng println. Với bài nhỏ này thì được. Nhưng debugger thắng ở chỗ mình đổi ý được ngay giữa chừng: sau khi nhìn locals, mình tính thử phaiTra + thanhTien mà không sửa dòng code nào, và đổi sang xem vòng sau mà không biên dịch lại.

Sửa lỗi và kiểm tra lại thế nào?

Cách sửa là dùng lại TinhDon của bài trước: cộng tổng đơn trước, rồi mới tính giảm giá một lần cho cả đơn.

src/main/java/vn/moc/donhang/GiamGiaDung.java
package vn.moc.donhang;

public class GiamGiaDung {

    public static void main(String[] args) {
        int[] soLuong = {3, 1};
        long[] donGia = {45_000, 35_000};

        long tong = TinhDon.tinhTongTien(soLuong, donGia);
        long giam = TinhDon.tinhGiamGia(tong);
        System.out.println("Tổng " + tong + ", giảm " + giam + ", phải trả: " + (tong - giam));
    }
}
Kết quả của java -Dstdout.encoding=UTF-8 -cp target/classes vn.moc.donhang.GiamGiaDung
Tổng 170000, giảm 17000, phải trả: 153000

153.000 đồng, đúng như tính tay. Điều mình rút ra từ lỗi này không nằm ở cú pháp: quy tắc giảm giá đã có sẵn trong TinhDon.tinhGiamGia, và bản lỗi viết lại một phiên bản riêng, sai, của quy tắc đó. Khi cùng một quy tắc nghiệp vụ nằm ở hai chỗ, sớm muộn hai chỗ sẽ lệch nhau. Đây cũng là lý do mình vẫn muốn có test tự động, dù debugger đã giúp tìm ra lỗi.

Mẹo nào giúp debug nhanh hơn?

Mình thấy vài thói quen đáng giá. Đọc kỹ thông báo lỗi trước khi mở debugger, vì nhiều lỗi, như NullPointerException ở trên, đã tự chỉ ra nguyên nhân. Khi bạn phải debug thì đặt breakpoint sớm hơn chỗ nghi ngờ một chút, để thấy dữ liệu đúng trước khi nó bị hỏng. Dùng step over (F8) làm mặc định và chỉ dùng step into (F7) khi bạn thật sự nghi ngờ method bên trong, nếu không bạn sẽ lạc vào code của thư viện. Và khi tìm ra lỗi, hãy viết lại thành một ca kiểm thử, để lỗi đó không quay lại.

Hỏi phỏng vấn thế nào?

Với junior, người phỏng vấn thường hỏi "bạn debug thế nào khi gặp lỗi?" hoặc đưa một đoạn stack trace và hỏi bạn đọc ra điều gì. Câu trả lời tốt đi theo trình tự: đọc loại lỗi và thông báo, tìm dòng at đầu tiên trong code của mình, tìm Caused by cuối cùng, rồi mới dùng breakpoint để xem dữ liệu. Nếu bạn kể được một lỗi mà nơi bùng ra và nơi gây ra khác nhau, như ví dụ mã món 2 ở trên, bạn cho họ thấy bạn đã debug thật. Bạn có thể xem thêm ở mục phỏng vấn.

Bước tiếp theo là gì?

Bạn đã biết tìm lỗi khi nó xảy ra. Nhưng cách này chỉ tìm ra lỗi sau khi nó đã xuất hiện, và mỗi lần mình sửa code ở nơi này, lại không có gì bảo đảm chỗ khác vẫn đúng. Mình muốn một cách để máy tự kiểm lại các quy tắc, ví dụ "đúng 100.000 đồng thì giảm 10.000, 99.999 thì không", mỗi lần mình đổi code. Đó là việc của test tự động, và là nội dung của bài kế tiếp trong series Học Java từ đầu cho người làm backend.

Nhận bài tiếp theo qua email.

Một email mỗi tuần, chỉ khi có điều đáng đọc. Không spam.