Java异常处理最佳实践#

什么是异常处理？#

异常处理是Java中用于处理程序运行时错误的机制。当程序运行过程中发生错误时，会抛出异常，程序可以捕获并处理这些异常，以保证程序的正常运行。

异常的分类#

Java中的异常分为两大类：

Checked Exception（受检异常）：必须在代码中显式处理的异常，如IOException、SQLException等
Unchecked Exception（非受检异常）：不需要在代码中显式处理的异常，如NullPointerException、ArrayIndexOutOfBoundsException等

异常处理的核心组件#

1. try-catch-finally#

1
try {
2
    // 可能抛出异常的代码
3
} catch (ExceptionType1 e) {
4
    // 处理ExceptionType1类型的异常
5
} catch (ExceptionType2 e) {
6
    // 处理ExceptionType2类型的异常
7
} finally {
8
    // 无论是否发生异常，都会执行的代码
9
}

2. throws#

1
public void method() throws ExceptionType1, ExceptionType2 {
2
    // 可能抛出异常的代码
3
}

3. throw#

1
public void method() {
2
    if (someCondition) {
3
        throw new ExceptionType("Error message");
4
    }
5
}

异常处理的最佳实践#

1. 只捕获可以处理的异常#

不要捕获所有异常，只捕获那些你知道如何处理的异常。对于不知道如何处理的异常，应该让它向上传播。

1
// 不好的做法
2
try {
3
    // 可能抛出多种异常的代码
4
} catch (Exception e) {
5
    // 捕获所有异常，但不知道如何处理
6
    e.printStackTrace();
7
}
8

9
// 好的做法
10
try {
11
    // 可能抛出IOException的代码
12
} catch (IOException e) {
13
    // 只捕获IOException，并进行适当处理
14
    logger.error("IO error occurred", e);
15
    // 进行恢复操作
16
}

2. 具体捕获异常类型#

应该捕获具体的异常类型，而不是捕获通用的Exception或Throwable。

1
// 不好的做法
2
try {
3
    // 可能抛出特定异常的代码
4
} catch (Exception e) {
5
    // 捕获所有异常
6
    e.printStackTrace();
7
}
8

9
// 好的做法
10
try {
11
    // 可能抛出IOException的代码
12
} catch (FileNotFoundException e) {
13
    // 处理文件未找到异常
14
    logger.error("File not found", e);
15
} catch (IOException e) {
16
    // 处理其他IO异常
17
    logger.error("IO error", e);
18
}

3. 不要在finally块中使用return#

在finally块中使用return会覆盖try或catch块中的return值，导致意外的结果。

1
// 不好的做法
2
public int method() {
3
    try {
4
        return 1;
5
    } catch (Exception e) {
6
        return 2;
7
    } finally {
8
        return 3; // 这会覆盖try或catch中的return值
9
    }
10
}
11

12
// 好的做法
13
public int method() {
14
    int result = 0;
15
    try {
16
        result = 1;
17
    } catch (Exception e) {
18
        result = 2;
19
    } finally {
20
        // 执行清理操作
21
    }
22
    return result;
23
}

4. 正确使用finally块#

finally块应该用于释放资源，无论是否发生异常。

1
// 好的做法
2
InputStream inputStream = null;
3
try {
4
    inputStream = new FileInputStream("file.txt");
5
    // 读取文件
6
} catch (IOException e) {
7
    logger.error("IO error", e);
8
} finally {
9
    if (inputStream != null) {
10
        try {
11
            inputStream.close();
12
        } catch (IOException e) {
13
            logger.error("Error closing stream", e);
14
        }
15
    }
16
}
17

18
// 更好的做法（使用try-with-resources）
19
try (InputStream inputStream = new FileInputStream("file.txt")) {
20
    // 读取文件
21
} catch (IOException e) {
22
    logger.error("IO error", e);
23
}

5. 使用try-with-resources#

对于实现了AutoCloseable接口的资源，应该使用try-with-resources语句，以确保资源的正确关闭。

1
// 好的做法
2
try (InputStream inputStream = new FileInputStream("file.txt");
3
     OutputStream outputStream = new FileOutputStream("output.txt")) {
4
    // 处理输入输出流
5
} catch (IOException e) {
6
    logger.error("IO error", e);
7
}

6. 不要忽略异常#

不要捕获异常后不做任何处理，至少应该记录日志。

1
// 不好的做法
2
try {
3
    // 可能抛出异常的代码
4
} catch (Exception e) {
5
    // 忽略异常
6
}
7

8
// 好的做法
9
try {
10
    // 可能抛出异常的代码
11
} catch (Exception e) {
12
    logger.error("Error occurred", e);
13
    // 或者进行其他适当的处理
14
}

7. 不要在循环中捕获异常#

异常处理的开销较大，应该避免在循环中捕获异常。

1
// 不好的做法
2
for (int i = 0; i < 1000; i++) {
3
    try {
4
        // 可能抛出异常的代码
5
    } catch (Exception e) {
6
        logger.error("Error occurred", e);
7
    }
8
}
9

10
// 好的做法
11
try {
12
    for (int i = 0; i < 1000; i++) {
13
        // 可能抛出异常的代码
14
    }
15
} catch (Exception e) {
16
    logger.error("Error occurred", e);
17
}

8. 合理使用自定义异常#

对于业务逻辑相关的错误，应该使用自定义异常，以提高代码的可读性和可维护性。

1
// 自定义异常
2
public class BusinessException extends Exception {
3
    private int errorCode;
4

5
    public BusinessException(int errorCode, String message) {
6
        super(message);
7
        this.errorCode = errorCode;
8
    }
9

10
    public int getErrorCode() {
11
        return errorCode;
12
    }
13
}
14

15
// 使用自定义异常
16
public void processOrder(Order order) throws BusinessException {
17
    if (order == null) {
18
        throw new BusinessException(400, "Order cannot be null");
19
    }
20
    if (order.getItems().isEmpty()) {
21
        throw new BusinessException(400, "Order cannot be empty");
22
    }
23
    // 处理订单
24
}

9. 异常信息要清晰#

异常信息应该清晰明了，包含足够的信息，以便于调试和排错。

1
// 不好的做法
2
if (user == null) {
3
    throw new NullPointerException("Null");
4
}
5

6
// 好的做法
7
if (user == null) {
8
    throw new NullPointerException("User object cannot be null");
9
}

10. 避免使用异常控制流程#

异常应该用于处理意外情况，而不是用于控制正常的程序流程。

1
// 不好的做法
2
public int divide(int a, int b) {
3
    try {
4
        return a / b;
5
    } catch (ArithmeticException e) {
6
        return 0;
7
    }
8
}
9

10
// 好的做法
11
public int divide(int a, int b) {
12
    if (b == 0) {
13
        return 0;
14
    }
15
    return a / b;
16
}

11. 正确使用异常链#

当需要将一个异常转换为另一个异常时，应该使用异常链，以保留原始异常的信息。

1
// 好的做法
2
try {
3
    // 可能抛出SQLException的代码
4
} catch (SQLException e) {
5
    // 将SQLException转换为BusinessException，并保留原始异常
6
    throw new BusinessException(500, "Database error", e);
7
}
8

9
// 自定义异常需要支持异常链
10
public class BusinessException extends Exception {
11
    private int errorCode;
12

13
    public BusinessException(int errorCode, String message, Throwable cause) {
14
        super(message, cause);
15
        this.errorCode = errorCode;
16
    }
17

18
    public int getErrorCode() {
19
        return errorCode;
20
    }
21
}

12. 记录异常信息#

应该使用日志框架记录异常信息，而不是使用e.printStackTrace()。

1
// 不好的做法
2
try {
3
    // 可能抛出异常的代码
4
} catch (Exception e) {
5
    e.printStackTrace(); // 输出到标准错误流
6
}
7

8
// 好的做法
9
private static final Logger logger = LoggerFactory.getLogger(MyClass.class);
10

11
try {
12
    // 可能抛出异常的代码
13
} catch (Exception e) {
14
    logger.error("Error occurred while processing", e); // 记录到日志文件
15
}

13. 考虑使用Unchecked Exception#

对于业务逻辑相关的错误，可以考虑使用Unchecked Exception，以简化代码结构。

1
// 自定义Unchecked Exception
2
public class BusinessRuntimeException extends RuntimeException {
3
    private int errorCode;
4

5
    public BusinessRuntimeException(int errorCode, String message) {
6
        super(message);
7
        this.errorCode = errorCode;
8
    }
9

10
    public int getErrorCode() {
11
        return errorCode;
12
    }
13
}
14

15
// 使用Unchecked Exception
16
public void processOrder(Order order) {
17
    if (order == null) {
18
        throw new BusinessRuntimeException(400, "Order cannot be null");
19
    }
20
    // 处理订单
21
}

14. 异常处理的层次结构#

应该在适当的层次处理异常，一般来说：

底层代码：抛出具体的异常
中层代码：转换或包装异常
上层代码：处理异常并向用户展示

15. 测试异常处理#

应该编写测试用例来测试异常处理逻辑，确保异常能够被正确捕获和处理。

1
@Test
2
expected = BusinessException.class
3
public void testProcessOrderWithNullOrder() {
4
    service.processOrder(null);
5
}
6

7
@Test
8
expected = BusinessException.class
9
public void testProcessOrderWithEmptyItems() {
10
    Order order = new Order();
11
    order.setItems(Collections.emptyList());
12
    service.processOrder(order);
13
}

常见陷阱#

1. 过度使用异常#

不要将异常用于控制正常的程序流程，这会影响程序的性能。

2. 忽略异常#

捕获异常后不做任何处理，会导致问题被隐藏，难以调试。

3. 捕获所有异常#

捕获所有异常会导致程序无法正确处理特定的异常情况。

4. 异常信息不清晰#

异常信息应该包含足够的信息，以便于调试和排错。

5. 不正确的异常链#

当转换异常时，应该保留原始异常的信息，以便于调试。

6. 资源泄漏#

应该使用try-with-resources语句或在finally块中关闭资源，以避免资源泄漏。

7. 异常处理的性能问题#

异常处理的开销较大，应该避免在性能敏感的代码中使用异常。

8. 不适当的异常类型#

应该使用适当的异常类型，以提高代码的可读性和可维护性。

异常处理的性能考虑#

1. 异常的开销#

异常处理的开销主要来自以下几个方面：

异常对象的创建：需要收集栈信息，开销较大
异常的抛出和捕获：需要进行栈回溯，开销较大
异常的处理：需要执行catch块中的代码

2. 性能优化#

避免在循环中抛出异常：循环中抛出异常会导致大量的异常对象创建和处理
使用预定义的异常：避免每次都创建新的异常对象
合理使用异常：只在真正的异常情况下使用异常
考虑使用返回值：对于可预期的错误，使用返回值而不是异常

总结#

异常处理是Java编程中的重要部分，它可以帮助我们处理程序运行过程中的错误，保证程序的正常运行。本文介绍了异常处理的最佳实践和常见陷阱，希望能够帮助你更好地理解和使用异常处理。

练习#

编写一个程序，使用try-catch-finally处理文件读写操作中的异常。
编写一个自定义异常类，并在程序中使用它。
编写一个程序，使用try-with-resources语句管理资源。
编写一个程序，演示异常链的使用。
编写一个程序，测试异常处理的性能。
编写一个程序，演示如何在不同层次处理异常。
编写一个程序，演示如何使用日志框架记录异常信息。
编写一个程序，演示如何避免使用异常控制流程。
编写一个程序，演示如何正确捕获和处理多个异常。
编写一个程序，演示如何使用Unchecked Exception。

溪谷回声

记录每一次探索与抵达

Java异常处理最佳实践