Lợi ích của việc sử dụng exception – handling trong Java?

Chào mừng các bạn trở lại với thachleblog, bài viết hôm nay mình sẽ tiếp tục với chủ đề exception trong Java, phần 2. Ở bài trước, mình đã giới thiệu về các loại exceptions và cách sử dụng, hôm nay mình sẽ phân tích các lợi ích của việc sử  dụng exceptions handling trong Java (try catch, throw), tại sao chúng ta lại dùng exceptions handling trong khi vẫn có thể dùng if – else hoặc các cách thông thường khác. Nào chúng ta cùng bắt đầu nhé.

exception trong java

Hình minh họa cơ chế của exception handling (nguồn internet)

Lợi ích thứ 1: tách biệt exceptions – handling code với logic code

Việc sử dụng exceptions – handling sẽ giúp cho exceptions – handling code được tách biệt với code logic của chương trình, code logic sẽ dễ đọc hơn, đồng thời exception – handling code cũng rõ ràng, dễ quản lý hơn. Chúng ta cùng xem ví dụ:

  1. readFile {
  2. open the file;
  3. determine its size;
  4. allocate that much memory;
  5. read the file into memory;
  6. close the file;
  7. }

Đối với đoạn code trên, các vấn đề chúng ta cần phải dự trù để xử lý:
– Không tìm thấy file
– Không xác định được kích thước file
– Không đủ bộ nhớ
– Không đọc được file
– Không đóng được file
…..
Xử lý ngoại lệ bằng cách thông thường:

  1. errorCodeType readFile {
  2. initialize errorCode = 0;
  3. open the file;
  4. if (theFileIsOpen) {
  5. determine the length of the file;
  6. if (gotTheFileLength) {
  7. allocate that much memory;
  8. if (gotEnoughMemory) {
  9. read the file into memory;
  10. if (readFailed) {
  11. errorCode = -1;
  12. }
  13. } else {
  14. errorCode = -2;
  15. }
  16. } else {
  17. errorCode = -3;
  18. }
  19. close the file;
  20. if (theFileDidntClose && errorCode == 0) {
  21. errorCode = -4;
  22. } else {
  23. errorCode = errorCode and -4;
  24. }
  25. } else {
  26. errorCode = -5;
  27. }
  28. return errorCode;
  29. }

Ta có thể thấy là việc xử lý sẽ làm cho logic code trở nên rườm rà, khó đọc. Nhưng với việc sử dụng exceptions – handling trong Java, ta chỉ việc gom tất cả các đoạn code có khả năng gây ra exceptions trong try và sau đó là catch lần lượt:

  1. readFile {
  2. try {
  3. open the file;
  4. determine its size;
  5. allocate that much memory;
  6. read the file into memory;
  7. close the file;
  8. } catch (fileOpenFailed) {
  9. doSomething;
  10. } catch (sizeDeterminationFailed) {
  11. doSomething;
  12. } catch (memoryAllocationFailed) {
  13. doSomething;
  14. } catch (readFailed) {
  15. doSomething;
  16. } catch (fileCloseFailed) {
  17. doSomething;
  18. }
  19. }

Lợi ích thứ 2: trong trường hợp call stack method

Để dễ hiểu khái niệm call stack method và ưu điểm của exceptions trong trường hợp này, chúng ta cùng xem ví dụ:
Giả sử readfile method ở trên là method thứ tư được gọi theo thứ tự như sau:

  1. method1 {
  2. call method2;
  3. }
  4. method2 {
  5. call method3;
  6. }
  7. method3 {
  8. call readFile;
  9. }

Do method1 gọi method2, method2 gọi method3, method3 gọi readfile. Do đó, việc check exceptions theo cách thông thường sẽ phải thực hiện ở tất cả các method:

  1. method1 {
  2. errorCodeType error;
  3. error = call method2;
  4. if (error)
  5. doErrorProcessing;
  6. else
  7. proceed;
  8. }
  9. errorCodeType method2 {
  10. errorCodeType error;
  11. error = call method3;
  12. if (error)
  13. return error;
  14. else
  15. proceed;
  16. }
  17. errorCodeType method3 {
  18. errorCodeType error;
  19. error = call readFile;
  20. if (error)
  21. return error;
  22. else
  23. proceed;
  24. }

Với việc sử dụng exceptions – handling trong Java, chúng ta chỉ cần check exception ở method1 và throw exception ở method2 và method3:

  1. method1 {
  2. try {
  3. call method2;
  4. } catch (exception e) {
  5. doErrorProcessing;
  6. }
  7. }
  8. method2 throws exception {
  9. call method3;
  10. }
  11. method3 throws exception {
  12. call readFile;
  13. }

Lợi ích thứ 3: sử dụng 1 exception thay cho nhóm exception

Bởi đặc điểm kế thừa của exceptions, chúng ta có thể catch chính nhóm các exception bằng exception “cha” khi không quan tâm đến chính xác exception nào cần catch. Ví dụ ta có thể catch Exception thay cho việc phải quan tâm đến chính xác Exception nào xảy ra (tuy nhiên theo mình nghĩ nên hạn chế dùng cách này).

Vừa rồi là phần trình bày về lợi ích của việc sử dụng exceptions – handling trong Java. Hy vọng giúp các bạn trả lời được câu hỏi tại sao. Rất mong nhận được ý kiến đóng góp của các bạn.
Xin cảm ơn.

Tham khảo thêm:
https://docs.oracle.com/javase/tutorial/essential/exceptions/advantages.html