一、异常处理的核心原则
1.1 异常处理的哲学
java
// 不良实践：空catch块 try { process(); } catch (Exception e) { // 什么也不做 - 最糟糕的做法！ } // 良好实践：明确处理 try { process(); } catch (SpecificException e) { log.error("处理失败，原因: {}", e.getMessage()); recoverOrThrow(e); }1.2 异常处理的5个基本原则
早抛出：在问题发生的地方立即抛出异常
迟捕获：在能够恰当处理的地方捕获异常
记录日志：永远不要"吞掉"异常
异常透明：保持异常信息的完整性
合理抽象：提供有意义的异常信息
二、Java异常体系深度解析
2.1 异常层次结构
java
// Throwable 体系完整结构 Throwable ├── Error (不可恢复，通常不捕获) │ ├── VirtualMachineError │ │ ├── OutOfMemoryError │ │ └── StackOverflowError │ └── LinkageError │ └── NoClassDefFoundError └── Exception ├── IOException (受检异常) │ ├── FileNotFoundException │ └── EOFException └── RuntimeException (非受检异常) ├── NullPointerException ├── IllegalArgumentException ├── IllegalStateException ├── IndexOutOfBoundsException └── UnsupportedOperationException
2.2 受检 vs 非受检异常的选择策略
java
// 何时使用受检异常 public class DataAccessException extends Exception { // 调用者必须处理的可恢复错误 public DataAccessException(String message, Throwable cause) { super(message, cause); } } // 何时使用非受检异常 public class BusinessRuleViolationException extends RuntimeException { // 编程错误或不可恢复的错误 public BusinessRuleViolationException(String message) { super(message); } } /** * 使用指南： * 1. 受检异常：调用者可以预期并处理的错误 * 2. 非受检异常：编程错误、断言失败、系统错误 */三、异常创建与自定义
3.1 创建信息丰富的异常
java
public class PaymentException extends RuntimeException { private final String paymentId; private final BigDecimal amount; private final LocalDateTime timestamp; private final ErrorCode errorCode; public PaymentException(String paymentId, BigDecimal amount, ErrorCode errorCode, String message) { super(String.format("支付失败[ID:%s, 金额:%s, 错误码:%s]: %s", paymentId, amount, errorCode, message)); this.paymentId = paymentId; this.amount = amount; this.timestamp = LocalDateTime.now(); this.errorCode = errorCode; } // 提供构造器的多种变体 public PaymentException(String paymentId, BigDecimal amount, ErrorCode errorCode, String message, Throwable cause) { this(paymentId, amount, errorCode, message); initCause(cause); } // 添加业务方法 public boolean isRetryable() { return errorCode.isRetryable(); } public Map<String, Object> toErrorResponse() { return Map.of( "paymentId", paymentId, "errorCode", errorCode.getCode(), "message", getMessage(), "timestamp", timestamp ); } }3.2 异常工厂模式
java
public final class ExceptionFactory { private ExceptionFactory() {} public static ValidationException invalidParameter(String paramName, Object value) { String message = String.format("参数'%s'的值'%s'无效", paramName, value); return new ValidationException(message, paramName, value); } public static ResourceNotFoundException resourceNotFound( String resourceType, String identifier) { String message = String.format("%s[%s]不存在", resourceType, identifier); return new ResourceNotFoundException(message, resourceType, identifier); } public static BusinessException businessRuleViolation( String ruleCode, String details, Object... args) { String formattedMessage = String.format(details, args); return new BusinessException(ruleCode, formattedMessage); } } // 使用示例 throw ExceptionFactory.invalidParameter("userId", userId); throw ExceptionFactory.resourceNotFound("User", userId);四、异常捕获与处理模式
4.1 精准捕获策略
java
// 反模式：捕获过于宽泛 try { process(); } catch (Exception e) { // 太宽泛！ // 会捕获所有异常，包括RuntimeException } // 模式1：精确捕获 try { process(); } catch (FileNotFoundException e) { // 处理文件不存在 handleMissingFile(e); } catch (IOException e) { // 处理其他IO问题 handleIOError(e); } catch (IllegalArgumentException e) { // 处理参数错误 logAndNotify("参数错误", e); } // 模式2：多重捕获（Java 7+） try { process(); } catch (FileNotFoundException | NoSuchFileException e) { handleFileIssue(e); } catch (IOException | SQLException e) { handleResourceError(e); }4.2 异常处理模板模式
java
public abstract class ExceptionHandlingTemplate { public <T> T execute(Supplier<T> operation) { try { return operation.get(); } catch (BusinessException e) { log.warn("业务异常: {}", e.getMessage()); return handleBusinessException(e); } catch (ResourceNotFoundException e) { log.error("资源未找到", e); return handleResourceNotFound(e); } catch (Exception e) { log.error("未预期的异常", e); throw new SystemException("系统错误", e); } } public void execute(Runnable operation) { execute(() -> { operation.run(); return null; }); } protected abstract <T> T handleBusinessException(BusinessException e); protected abstract <T> T handleResourceNotFound(ResourceNotFoundException e); } // 使用示例 public class PaymentService extends ExceptionHandlingTemplate { public PaymentResult processPayment(PaymentRequest request) { return execute(() -> { // 业务逻辑 validate(request); Payment payment = repository.save(request); return paymentGateway.charge(payment); }); } @Override protected PaymentResult handleBusinessException(BusinessException e) { return PaymentResult.failed(e.getMessage()); } @Override protected PaymentResult handleResourceNotFound(ResourceNotFoundException e) { return PaymentResult.notFound(e.getMessage()); } }五、资源管理与异常安全
5.1 Try-with-Resources 最佳实践
java
// 传统方式的问题 BufferedReader reader = null; try { reader = new BufferedReader(new FileReader("file.txt")); // 处理文件 } catch (IOException e) { // 处理异常 } finally { if (reader != null) { try { reader.close(); // 可能抛出异常 } catch (IOException e) { // 关闭异常被忽略或覆盖了原始异常 } } } // Try-with-Resources 方式（Java 7+） try (BufferedReader reader = new BufferedReader(new FileReader("file.txt")); BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) { String line; while ((line = reader.readLine()) != null) { writer.write(process(line)); writer.newLine(); } } catch (IOException e) { log.error("文件操作失败", e); throw new ProcessingException("处理文件失败", e); } // 自定义可自动关闭的资源 public class DatabaseConnection implements AutoCloseable { private final Connection connection; public DatabaseConnection(String url) throws SQLException { this.connection = DriverManager.getConnection(url); } public ResultSet executeQuery(String sql) throws SQLException { return connection.createStatement().executeQuery(sql); } @Override public void close() { try { if (connection != null && !connection.isClosed()) { connection.close(); log.debug("数据库连接已关闭"); } } catch (SQLException e) { log.warn("关闭数据库连接时出错", e); } } // 使用示例 public void processData() { try (DatabaseConnection db = new DatabaseConnection("jdbc:mysql://localhost/test")) { ResultSet rs = db.executeQuery("SELECT * FROM users"); // 处理结果 } catch (SQLException e) { throw new DataAccessException("数据库操作失败", e); } } }5.2 异常安全的资源清理
java
public class ResourceHolder { private final List<AutoCloseable> resources = new ArrayList<>(); public <T extends AutoCloseable> T register(T resource) { resources.add(resource); return resource; } public void cleanUp() { List<Throwable> errors = new ArrayList<>(); // 按创建顺序的逆序关闭 for (int i = resources.size() - 1; i >= 0; i--) { AutoCloseable resource = resources.get(i); try { if (resource != null) { resource.close(); } } catch (Exception e) { errors.add(e); } } if (!errors.isEmpty()) { Throwable first = errors.get(0); for (int i = 1; i < errors.size(); i++) { first.addSuppressed(errors.get(i)); } throw new RuntimeException("清理资源时发生错误", first); } } } // 使用示例 public void processMultipleResources() { ResourceHolder holder = new ResourceHolder(); try { FileInputStream fis = holder.register(new FileInputStream("input.txt")); FileOutputStream fos = holder.register(new FileOutputStream("output.txt")); DatabaseConnection db = holder.register(new DatabaseConnection("url")); // 使用资源 process(fis, fos, db); } catch (Exception e) { throw new ProcessingException("处理失败", e); } finally { holder.cleanUp(); } }六、异常链与包装
6.1 保持异常链的完整性
java
// 错误方式：丢失原始异常信息 try { parseFile(); } catch (IOException e) { throw new ProcessingException("处理失败"); // 原始异常丢失！ } // 正确方式：保持异常链 try { parseFile(); } catch (IOException e) { // 方式1：使用带cause参数的构造器 throw new ProcessingException("处理文件时出错", e); // 方式2：使用initCause ProcessingException pe = new ProcessingException("处理文件时出错"); pe.initCause(e); throw pe; }6.2 异常转换模式
java
public class ExceptionTranslator { /** * 将技术异常转换为业务异常 */ public static BusinessException translate(Exception e) { if (e instanceof SQLException) { return translateSQLException((SQLException) e); } else if (e instanceof IOException) { return translateIOException((IOException) e); } else if (e instanceof RuntimeException) { return translateRuntimeException((RuntimeException) e); } else { return new BusinessException("系统错误", e); } } private static BusinessException translateSQLException(SQLException e) { String sqlState = e.getSQLState(); switch (sqlState) { case "23505": // 唯一约束冲突 return new DuplicateKeyException("记录已存在", e); case "23503": // 外键约束冲突 return new ConstraintViolationException("关联记录不存在", e); case "08001": // 无法连接到数据库 case "08003": // 连接不存在 case "08007": // 连接异常 return new DatabaseConnectionException("数据库连接失败", e); default: return new DataAccessException("数据库操作失败", e); } } private static BusinessException translateIOException(IOException e) { if (e instanceof FileNotFoundException) { return new ResourceNotFoundException("文件不存在", e); } else if (e instanceof AccessDeniedException) { return new PermissionDeniedException("无访问权限", e); } else { return new SystemException("IO错误", e); } } // 使用示例 public void saveData(Data data) { try { dataRepository.save(data); } catch (Exception e) { throw ExceptionTranslator.translate(e); } } }七、全局异常处理策略
7.1 Spring Boot 全局异常处理
java
@RestControllerAdvice public class GlobalExceptionHandler { private static final Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class); /** * 处理业务异常 */ @ExceptionHandler(BusinessException.class) public ResponseEntity<ErrorResponse> handleBusinessException( BusinessException ex, WebRequest request) { ErrorResponse error = ErrorResponse.builder() .code(ex.getErrorCode()) .message(ex.getMessage()) .timestamp(Instant.now()) .path(getRequestPath(request)) .build(); log.warn("业务异常: {}", ex.getMessage()); return ResponseEntity .status(HttpStatus.BAD_REQUEST) .body(error); } /** * 处理资源不存在异常 */ @ExceptionHandler(ResourceNotFoundException.class) public ResponseEntity<ErrorResponse> handleResourceNotFound( ResourceNotFoundException ex, WebRequest request) { ErrorResponse error = ErrorResponse.builder() .code("NOT_FOUND") .message(ex.getMessage()) .timestamp(Instant.now()) .path(getRequestPath(request)) .suggestion("请检查资源ID是否正确") .build(); return ResponseEntity .status(HttpStatus.NOT_FOUND) .body(error); } /** * 处理验证异常 */ @ExceptionHandler(MethodArgumentNotValidException.class) public ResponseEntity<ErrorResponse> handleValidationException( MethodArgumentNotValidException ex, WebRequest request) { List<FieldError> fieldErrors = ex.getBindingResult().getFieldErrors(); List<ValidationError> validationErrors = fieldErrors.stream() .map(error -> ValidationError.builder() .field(error.getField()) .message(error.getDefaultMessage()) .rejectedValue(error.getRejectedValue()) .build()) .collect(Collectors.toList()); ErrorResponse error = ErrorResponse.builder() .code("VALIDATION_FAILED") .message("参数验证失败") .timestamp(Instant.now()) .path(getRequestPath(request)) .errors(validationErrors) .build(); return ResponseEntity .status(HttpStatus.BAD_REQUEST) .body(error); } /** * 处理所有未捕获的异常 */ @ExceptionHandler(Exception.class) public ResponseEntity<ErrorResponse> handleAllUncaughtException( Exception ex, WebRequest request) { // 记录完整堆栈信息 log.error("未处理的异常", ex); // 生产环境不暴露详细信息 boolean isProduction = "prod".equals(env.getProperty("spring.profiles.active")); ErrorResponse error = ErrorResponse.builder() .code("INTERNAL_ERROR") .message(isProduction ? "系统内部错误" : ex.getMessage()) .timestamp(Instant.now()) .path(getRequestPath(request)) .build(); // 发送告警通知 if (isProduction) { alertService.sendAlert("系统异常", ex); } return ResponseEntity .status(HttpStatus.INTERNAL_SERVER_ERROR) .body(error); } private String getRequestPath(WebRequest request) { if (request instanceof ServletWebRequest) { HttpServletRequest servletRequest = ((ServletWebRequest) request).getRequest(); return servletRequest.getRequestURI(); } return "unknown"; } } // 错误响应对象 @Data @Builder @AllArgsConstructor @NoArgsConstructor public class ErrorResponse { private String code; private String message; private Instant timestamp; private String path; private String suggestion; private List<ValidationError> errors; @Data @Builder public static class ValidationError { private String field; private String message; private Object rejectedValue; } }7.2 线程池中的异常处理
java
public class ThreadPoolExceptionHandler { // 自定义线程工厂 public static class NamedThreadFactory implements ThreadFactory { private final String namePrefix; private final AtomicInteger threadNumber = new AtomicInteger(1); public NamedThreadFactory(String namePrefix) { this.namePrefix = namePrefix; } @Override public Thread newThread(Runnable r) { Thread t = new Thread(r, namePrefix + "-thread-" + threadNumber.getAndIncrement()); t.setUncaughtExceptionHandler(new LoggingExceptionHandler()); return t; } } // 未捕获异常处理器 public static class LoggingExceptionHandler implements Thread.UncaughtExceptionHandler { @Override public void uncaughtException(Thread t, Throwable e) { log.error("线程 '{}' 抛出未捕获异常", t.getName(), e); // 发送告警 alertService.alertThreadException(t, e); } } // 使用UncaughtExceptionHandler的ExecutorService public static ExecutorService createSafeExecutor(int corePoolSize, String poolName) { ThreadPoolExecutor executor = new ThreadPoolExecutor( corePoolSize, corePoolSize, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(), new NamedThreadFactory(poolName)); // 设置拒绝策略 executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); return executor; } // 使用示例 public void executeParallelTasks(List<Task> tasks) { ExecutorService executor = createSafeExecutor(10, "task-processor"); List<Future<Result>> futures = new ArrayList<>(); for (Task task : tasks) { Future<Result> future = executor.submit(() -> { try { return task.execute(); } catch (Exception e) { log.error("任务执行失败: {}", task.getId(), e); throw new TaskExecutionException("任务执行失败", e); } }); futures.add(future); } // 处理结果 for (Future<Result> future : futures) { try { Result result = future.get(); processResult(result); } catch (InterruptedException e) { Thread.currentThread().interrupt(); throw new RuntimeException("任务被中断", e); } catch (ExecutionException e) { Throwable cause = e.getCause(); if (cause instanceof TaskExecutionException) { handleTaskFailure((TaskExecutionException) cause); } else { throw new RuntimeException("未知错误", cause); } } } executor.shutdown(); } }八、日志记录与监控
8.1 异常日志记录最佳实践
java
public class ExceptionLogger { private static final Logger log = LoggerFactory.getLogger(ExceptionLogger.class); /** * 记录异常的不同级别 */ public static void logException(String context, Throwable e, LogLevel level) { switch (level) { case DEBUG: log.debug("{} - {}", context, e.getMessage(), e); break; case INFO: log.info("{} - {}", context, e.getMessage(), e); break; case WARN: log.warn("{} - {}", context, e.getMessage(), e); break; case ERROR: log.error("{} - {}", context, e.getMessage(), e); // 发送告警 alertIfNeeded(e); break; } // 记录额外的上下文信息 if (log.isDebugEnabled()) { log.debug("异常上下文: {}", gatherContextInfo()); } } /** * 智能异常分析 */ public static ExceptionInfo analyzeException(Throwable e) { ExceptionInfo info = new ExceptionInfo(); info.setType(e.getClass().getSimpleName()); info.setMessage(e.getMessage()); info.setTimestamp(Instant.now()); // 分析堆栈轨迹 StackTraceElement[] stackTrace = e.getStackTrace(); if (stackTrace.length > 0) { info.setClassName(stackTrace[0].getClassName()); info.setMethodName(stackTrace[0].getMethodName()); info.setLineNumber(stackTrace[0].getLineNumber()); } // 判断异常类型 info.setSeverity(calculateSeverity(e)); info.setSuggestedAction(getSuggestedAction(e)); return info; } /** * 异常上下文收集器 */ public static class ExceptionContext { private final Map<String, Object> context = new LinkedHashMap<>(); public ExceptionContext add(String key, Object value) { context.put(key, value); return this; } public void logWithContext(String message, Throwable e) { MDC.put("exception_context", toJson(context)); log.error(message, e); MDC.remove("exception_context"); } private String toJson(Map<String, Object> map) { try { return objectMapper.writeValueAsString(map); } catch (JsonProcessingException ex) { return map.toString(); } } } // 使用示例 public void processPayment(PaymentRequest request) { ExceptionContext context = new ExceptionContext() .add("paymentId", request.getId()) .add("amount", request.getAmount()) .add("userId", request.getUserId()); try { paymentService.process(request); } catch (PaymentException e) { context.logWithContext("支付处理失败", e); throw e; } } }8.2 异常监控与告警
java
public class ExceptionMonitor { private final MeterRegistry meterRegistry; private final Map<String, CircuitBreaker> circuitBreakers = new ConcurrentHashMap<>(); /** * 异常率监控 */ public <T> T monitor(String operationName, Supplier<T> operation) { Timer.Sample sample = Timer.start(meterRegistry); try { T result = operation.get(); sample.stop(meterRegistry.timer("operation." + operationName + ".success")); meterRegistry.counter("operation." + operationName + ".success.count").increment(); return result; } catch (Exception e) { sample.stop(meterRegistry.timer("operation." + operationName + ".failure")); meterRegistry.counter("operation." + operationName + ".failure.count", "exception", e.getClass().getSimpleName()).increment(); throw e; } } /** * 断路器模式 */ public <T> T executeWithCircuitBreaker(String serviceName, Supplier<T> operation) { CircuitBreaker circuitBreaker = circuitBreakers.computeIfAbsent( serviceName, name -> CircuitBreaker.of(name, CircuitBreakerConfig.custom() .failureRateThreshold(50) .slowCallRateThreshold(100) .waitDurationInOpenState(Duration.ofSeconds(30)) .slowCallDurationThreshold(Duration.ofSeconds(5)) .permittedNumberOfCallsInHalfOpenState(3) .minimumNumberOfCalls(10) .slidingWindowType(CircuitBreakerConfig.SlidingWindowType.COUNT_BASED) .slidingWindowSize(20) .recordExceptions(Exception.class) .build()) ); return circuitBreaker.executeSupplier(() -> { try { return operation.get(); } catch (Exception e) { meterRegistry.counter("circuitbreaker." + serviceName + ".exception") .increment(); throw e; } }); } /** * 异常聚合报告 */ public ExceptionReport generateDailyReport() { ExceptionReport report = new ExceptionReport(); report.setDate(LocalDate.now()); // 从指标收集异常统计 List<Meter> meters = meterRegistry.getMeters().stream() .filter(m -> m.getId().getName().contains(".failure.count")) .collect(Collectors.toList()); for (Meter meter : meters) { if (meter instanceof Counter) { Counter counter = (Counter) meter; double count = counter.count(); Tag exceptionTag = counter.getId().getTag("exception"); if (exceptionTag != null) { report.addExceptionStatistic(exceptionTag.getValue(), (long) count); } } } return report; } }九、测试中的异常处理
9.1 JUnit异常测试
java
public class ExceptionTestExamples { /** * JUnit 4 异常测试 */ @Test(expected = IllegalArgumentException.class) public void testExpectedException_JUnit4() { validator.validate(null); } /** * JUnit 5 异常测试 - 更优雅的方式 */ @Test void testExceptionThrowing_JUnit5() { // 验证异常类型 IllegalArgumentException exception = assertThrows( IllegalArgumentException.class, () -> validator.validate(null) ); // 验证异常信息 assertEquals("参数不能为空", exception.getMessage()); // 验证异常的其他属性 assertTrue(exception instanceof ValidationException); } /** * 使用 assertThat 的流畅接口 */ @Test void testExceptionWithAssertJ() { // AssertJ 提供了更丰富的断言 assertThatThrownBy(() -> validator.validate(null)) .isInstanceOf(IllegalArgumentException.class) .hasMessage("参数不能为空") .hasMessageContaining("不能为空") .hasNoCause(); } /** * 测试异常链 */ @Test void testExceptionChain() { Throwable throwable = catchThrowable(() -> service.process()); assertThat(throwable) .isInstanceOf(BusinessException.class) .hasMessage("业务处理失败") .hasCauseInstanceOf(IOException.class) .hasRootCauseMessage("文件未找到"); } /** * 自定义异常断言器 */ public static class PaymentExceptionAssert { private final PaymentException exception; private PaymentExceptionAssert(PaymentException exception) { this.exception = exception; } public static PaymentExceptionAssert assertThat(PaymentException exception) { return new PaymentExceptionAssert(exception); } public PaymentExceptionAssert hasPaymentId(String expectedId) { assertEquals(expectedId, exception.getPaymentId()); return this; } public PaymentExceptionAssert hasAmount(BigDecimal expectedAmount) { assertEquals(expectedAmount, exception.getAmount()); return this; } public PaymentExceptionAssert isRetryable() { assertTrue(exception.isRetryable()); return this; } } @Test void testCustomExceptionAssert() { PaymentException exception = assertThrows(PaymentException.class, () -> paymentService.process(invalidPayment)); PaymentExceptionAssert.assertThat(exception) .hasPaymentId("123") .hasAmount(new BigDecimal("100.00")) .isRetryable(); } }9.2 Mock异常测试
java
public class MockExceptionTest { @Mock private PaymentGateway paymentGateway; @Mock private NotificationService notificationService; @InjectMocks private PaymentService paymentService; /** * 测试异常重试逻辑 */ @Test void testRetryOnTemporaryFailure() { // 模拟第一次调用失败，第二次成功 when(paymentGateway.charge(any())) .thenThrow(new TemporaryFailureException("服务暂时不可用")) .thenReturn(new PaymentResult("success")); PaymentResult result = paymentService.processWithRetry(paymentRequest); assertEquals("success", result.getStatus()); verify(paymentGateway, times(2)).charge(any()); } /** * 测试异常传播 */ @Test void testExceptionPropagation() { when(paymentGateway.charge(any())) .thenThrow(new PaymentGatewayException("支付网关错误")); // 验证是否抛出了正确的业务异常 BusinessException exception = assertThrows(BusinessException.class, () -> paymentService.process(paymentRequest)); assertEquals("支付处理失败", exception.getMessage()); assertInstanceOf(PaymentGatewayException.class, exception.getCause()); } /** * 测试资源清理 */ @Test void testResourceCleanupOnException() { try (MockedStatic<ResourceManager> mockedStatic = mockStatic(ResourceManager.class)) { mockedStatic.when(ResourceManager::acquire).thenReturn(resource); doThrow(new IOException("写入失败")).when(resource).write(any()); assertThrows(ProcessingException.class, () -> paymentService.process(paymentRequest)); // 验证资源被正确清理 mockedStatic.verify(ResourceManager::release, times(1)); } } /** * 测试多个服务的异常交互 */ @Test void testExceptionInMultipleServices() { // 设置模拟行为 when(paymentGateway.charge(any())).thenReturn(successResult); doThrow(new NotificationFailedException("通知发送失败")) .when(notificationService).notify(any()); // 即使通知失败，支付也应该成功 PaymentResult result = paymentService.process(paymentRequest); assertEquals("success", result.getStatus()); // 验证通知被调用但失败了 verify(notificationService, times(1)).notify(any()); // 验证异常被记录 verify(logger, times(1)).warn(contains("通知发送失败"), any()); } }十、性能优化与最佳实践
10.1 异常处理的性能考量
java
public class PerformanceOptimizedExceptions { /** * 避免在性能关键路径上创建异常 */ // 不佳：每次验证都创建异常 public void validateValue(String value) { if (value == null || value.isEmpty()) { throw new IllegalArgumentException("值不能为空"); // 创建异常有开销 } } // 优化：预创建异常或使用常量 private static final IllegalArgumentException EMPTY_VALUE_EXCEPTION = new IllegalArgumentException("值不能为空"); public void validateValueOptimized(String value) { if (value == null || value.isEmpty()) { throw EMPTY_VALUE_EXCEPTION; // 重用异常实例 } } /** * 使用条件检查替代异常 */ public void processArray(int[] array, int index) { // 不佳：依赖异常进行流程控制 try { int value = array[index]; process(value); } catch (ArrayIndexOutOfBoundsException e) { useDefaultValue(); } // 优化：显式边界检查 if (index >= 0 && index < array.length) { int value = array[index]; process(value); } else { useDefaultValue(); } } /** * 异常创建的性能分析 */ public void benchmarkExceptionCreation() { int iterations = 1000000; // 测试创建异常的开销 long start = System.nanoTime(); for (int i = 0; i < iterations; i++) { try { throw new RuntimeException("test"); } catch (RuntimeException e) { // 忽略 } } long end = System.nanoTime(); System.out.printf("创建 %d 个异常耗时: %.2f ms%n", iterations, (end - start) / 1_000_000.0); // 测试填充堆栈轨迹的开销 start = System.nanoTime(); RuntimeException exception = new RuntimeException("test"); for (int i = 0; i < iterations; i++) { exception.getStackTrace(); // 触发堆栈轨迹填充 } end = System.nanoTime(); System.out.printf("获取 %d 次堆栈轨迹耗时: %.2f ms%n", iterations, (end - start) / 1_000_000.0); } /** * 轻量级异常（不填充堆栈轨迹） */ public static class LightweightException extends RuntimeException { public LightweightException(String message) { super(message); } @Override public Throwable fillInStackTrace() { // 不填充堆栈轨迹以提高性能 return this; } } /** * 异常缓存模式 */ public static class ExceptionCache { private static final Map<String, RuntimeException> CACHE = new ConcurrentHashMap<>(); public static RuntimeException getCachedException(String key, String message) { return CACHE.computeIfAbsent(key, k -> new RuntimeException(message) { @Override public Throwable fillInStackTrace() { return this; // 缓存实例不填充堆栈 } }); } } }10.2 异常处理的最佳实践总结
设计时考虑异常
定义清晰的异常层次结构
为不同的错误场景创建专门的异常类
提供有用的异常信息和上下文
编码时处理异常
具体化捕获的异常类型
保持异常链的完整性
在合适的层次处理异常
资源管理
使用try-with-resources
确保资源被正确清理
处理清理过程中可能出现的异常
日志与监控
记录有意义的错误信息
监控异常率和模式
设置合理的告警机制
性能优化
避免在性能关键路径上过度使用异常
考虑使用轻量级异常
对频繁抛出的异常进行缓存
测试策略
为异常场景编写测试
验证异常信息和属性
测试异常处理逻辑
文档化
在API文档中说明可能抛出的异常
提供异常处理的示例代码
记录异常处理的业务逻辑
java
/** * 优雅异常处理的终极示例 */ public class PaymentProcessor { public PaymentResult processPayment(PaymentRequest request) { // 1. 验证输入 validateRequest(request); // 2. 执行业务逻辑 try { return executePayment(request); } catch (PaymentGatewayException e) { // 3. 处理已知异常 log.warn("支付网关异常", e); return handleGatewayError(e, request); } catch (Exception e) { // 4. 处理未知异常 log.error("未预期的支付错误", e); throw new PaymentProcessingException("支付处理失败", e); } finally { // 5. 清理资源 cleanUpResources(); } } private PaymentResult executePayment(PaymentRequest request) { try (PaymentGatewayConnection connection = gateway.connect()) { // 使用资源 PaymentResult result = connection.charge(request); // 发送通知（不影响主流程） try { notificationService.notify(result); } catch (NotificationException e) { log.warn("通知发送失败，但不影响支付结果", e); } return result; } } }总结
优雅的异常处理是高质量Java应用程序的标志。通过遵循本文中的原则和模式，您可以：
提高代码健壮性：正确处理各种错误场景
改善可维护性：清晰的异常处理逻辑便于理解和修改
增强可调试性：丰富的异常信息加速问题定位
提升用户体验：提供有意义的错误信息和恢复建议
保障系统稳定性：合理的异常处理防止级联故障
