异常处理是软件工程中最重要的基础能力之一。良好的异常处理机制能够显著提升服务的稳定性、可维护性和用户体验。本文档从设计原则、分类体系、实现规范到最佳实践,提供一套完整的异常处理指南,涵盖 Java、Python、Go 等多种语言的实现方案,并针对微服务架构、分布式事务等复杂场景给出深度分析。
异常处理的根本目的在于四个方面:
| 目的 | 具体价值 | 反面案例 | 衡量指标 |
|---|---|---|---|
| 服务稳定性 | 故障隔离、优雅降级、避免雪崩 | 未捕获的异常导致整个进程崩溃 | MTBF(平均故障间隔)、故障传播半径 |
| 用户体验 | 友好的错误提示、可理解的引导 | 500 错误页面或原始堆栈信息暴露给用户 | 错误反馈满意度、误操作率 |
| 数据一致性 | 事务原子性保障、补偿机制确保最终一致 | 部分写入失败导致订单状态混乱 | 数据不一致率 |
| 诊断信息 | 快速定位根因、减少排查时间 | 空 catch 块导致问题"凭空消失" | MTTR(平均修复时间) |
核心原则:异常处理不是"掩盖问题",而是"优雅地处理问题"。一个从不抛出异常的系统,往往是一个从不检查错误的系统。
这是异常处理体系中最核心的设计决策。将异常分为两大类,各自有不同的处理策略:
| 维度 | 业务异常 | 系统异常 |
|---|---|---|
| 产生原因 | 违反业务规则(余额不足、库存不足) | 系统运行故障(网络断开、磁盘满) |
| 用户感知 | 需要明确告知用户,提供操作指引 | 原则上不让用户感知,返回友好提示 |
| 处理方式 | 返回明确的错误码和错误提示 | 记录日志、触发告警、自动恢复 |
| 恢复方式 | 用户修正操作后重试 | 运维介入或系统自动恢复 |
| 示例 | 余额不足、参数校验失败、商品已下架 | 数据库连接断开、内存溢出、服务超时 |
| 日志级别 | WARN | ERROR |
| 是否需要告警 | 通常不需要(预期行为) | 需要(非预期故障) |
关键决策:只将具有业务含义的异常暴露给用户。系统自身的问题(如数据库连接失败),原则上返回"系统繁忙,请稍后重试"即可,不要让用户感知底层技术细节。
反模式警示:不要使用异常处理机制处理正常情况下就会出现的业务情况。异常机制的语言实现(try-catch 的堆栈展开、异常对象创建)本身有性能开销。
❌ 错误示例——用异常做流程控制:
try {
withdraw(account, amount);
} catch (InsufficientBalanceException e) {
// 余额不足是正常业务场景,不应该用异常处理
return Result.fail("余额不足");
}
✅ 正确做法——用返回值做流程分支:
BalanceCheckResult result = account.canWithdraw(amount);
if (!result.isAllowed()) {
return Result.fail(result.getReason()); // 正常业务流程分支
}
withdraw(account, amount);
判断标准:如果该"异常"在业务上预期会发生(如余额不足、库存不足),则不应使用异常机制处理。异常的含义是"不应该发生的事情"。
异常情况的检查与发现,应与正常业务流程分离。这体现了**关注点分离(Separation of Concerns)**的设计原则。
✅ 推荐架构:
三层分离模式:
// 第1层:前置校验(Guard Clauses)
// 职责:检查所有前置条件,拒绝异常输入
// 不进入业务逻辑
public class OrderValidation {
public static void validate(OrderRequest request) {
Assert.notNull(request.getUserId(), "用户ID不能为空");
Assert.notEmpty(request.getItems(), "订单项不能为空");
// 校验商品是否存在、库存是否足够等
}
}
// 第2层:业务逻辑(正常流程)
// 职责:只处理正常业务,不考虑异常情况
public class OrderService {
public Order createOrder(OrderRequest request) {
// 假设前置校验已通过
Order order = new Order();
order.setUserId(request.getUserId());
order.setItems(request.getItems());
return orderRepository.save(order);
}
}
// 第3层:全局异常处理
// 职责:统一处理所有未捕获的异常
@ControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler(ValidationException.class)
public ResponseEntity<?> handleValidation(ValidationException e) {
// 业务异常 → 返回业务错误
}
@ExceptionHandler(Exception.class)
public ResponseEntity<?> handleSystem(Exception e) {
// 系统异常 → 记录日志 + 返回通用错误
}
}
一旦发现不符合当前场景的情况,立即终止当前方法的执行,并抛出异常。
好处:
❌ 延迟失败的危害:
public void processOrder(Order order) {
validateOrder(order); // 如果这里不抛异常...
saveToDatabase(order); // ...数据可能已经部分写入
sendNotification(order); // ...通知可能已经发出
// 最后才发现问题,回滚成本极高
}
✅ Fail Fast 模式:
public void processOrder(Order order) {
// 先校验全部条件,不满足立即返回
ValidationResult vr = validateAll(order);
if (!vr.isValid()) {
log.warn("订单校验失败: {}, 原因: {}", order.getOrderNo(), vr.getErrors());
return Result.fail(vr.getErrors());
}
// 校验通过后才开始处理
saveToDatabase(order);
sendNotification(order);
}
Fail Fast vs Fail Safe 并不是非此即彼,而是不同场景下的不同选择:
| 场景 | 推荐策略 | 原因 |
|---|---|---|
| 参数校验 | Fail Fast | 参数错误没有重试意义,应立即拒绝 |
| 数据库连接失败 | Fail Safe + 重试 | 瞬时故障可能自动恢复 |
| 第三方支付超时 | Fail Safe + 降级 | 可以先返回处理中,异步确认 |
| 安全校验 | Fail Fast | 安全漏洞不能有任何容错 |
| 缓存读取失败 | Fail Safe | 降级到读数据库 |
实践经验:业务逻辑层优先使用 Fail Fast,基础设施层优先使用 Fail Safe + 重试。
"业务异常"常常被用来泛指所有非正向主流程的业务场景。但这些场景是否需要使用异常机制处理,需要谨慎判断,避免出现使用异常机制处理正常业务的情况。
案例:提现余额不足
对于"提现"操作,账户余额不足时,会提现失败。这种场景,一般不建议使用异常来处理,而建议把这种场景做为常规业务流程中的一种。即使使用异常机制来处理,也应当与系统异常严格区分出来。
业务异常的输出要求:
一个完整的业务异常需要达成如下要求:
业务异常基类实现:
public class BusinessException extends RuntimeException {
private final ErrorCode errorCode;
private final Map<String, Object> context;
public BusinessException(ErrorCode errorCode, String message, Map<String, Object> context) {
super(message);
this.errorCode = errorCode;
this.context = context;
}
// Getters...
}
使用示例:
// 按性质定义而非按场景定义
public class InsufficientBalanceException extends BusinessException {
public InsufficientBalanceException(String operation, BigDecimal required, BigDecimal available) {
super(ErrorCode.INSUFFICIENT_BALANCE,
String.format("%s 操作需要 %s,当前可用余额 %s", operation, required, available),
Map.of("operation", operation, "required", required, "available", available));
}
}
// 使用时
throw new InsufficientBalanceException("提现", new BigDecimal("1000"), balance);
| 子类 | 错误码前缀 | 典型场景 | 用户提示示例 |
|---|---|---|---|
| ValidationException | PARAM_ | 参数格式错误、字段缺失 | "手机号格式不正确" |
| AuthorizationException | AUTH_ | 无权访问、Token 过期 | "登录已过期,请重新登录" |
| StateException | STATE_ | 订单状态不允许操作 | "当前订单状态不支持取消" |
| ResourceException | RES_ | 商品已下架、房间已满 | "该商品已售罄" |
| RateLimitException | LIMIT_ | 频率限制、并发冲突 | "操作太频繁,请稍后再试" |
技术异常分为两类:
可预见的技术异常应当在系统设计时,通过预先设计的异常处理机制进行规避。
| 异常类型 | 触发条件 | 预防措施 | 监控告警阈值 |
|---|---|---|---|
| 磁盘满 | 日志/数据持续写入 | 磁盘容量监控、日志轮转 | 使用率 > 80% 预警,> 90% 告警 |
| FileDescriptor 用尽 | 大量并发连接未关闭 | 连接池配置、资源泄露检测 | FD 使用率 > 70% |
| 网络中断 | 网络设备故障 | 连接池、重试机制、熔断 | 连接失败率 > 5% |
| 第三方服务不可用 | 外部服务宕机 | 熔断器、降级策略、超时控制 | P99 延迟 > 1s |
| 内存溢出 OOM | 内存泄露/大对象 | 内存监控、JVM 参数、流量控制 | 堆内存 > 80% |
| 连接池耗尽 | 突发流量/连接泄露 | 合理配置池大小、快速失败 | 连接等待队列 > 100 |
处理原则:
不可预见的异常,应当能在服务内以统一方式全局处理,避免巴洛克式异常处理(每个地方都做自己的异常处理,每个地方的异常处理方式又非常相似)。
常见不可预见异常及其根因:
| 异常 | 典型根因 | 代码审查关注点 |
|---|---|---|
| NullPointerException | 未判空、链式调用 | 方法返回值是否为 null |
| IllegalArgumentException | 参数未校验 | Guard Clause 是否覆盖 |
| IndexOutOfBoundsException | 集合越界访问 | 循环边界条件是否正确 |
| ClassCastException | 泛型擦除后类型错误 | unchecked warning 是否处理 |
| ConcurrentModificationException | 遍历时修改集合 | 是否使用了迭代器安全删除 |
解决策略:
@RestControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler(BusinessException.class)
public ResponseEntity<ErrorResponse> handleBusiness(BusinessException ex) {
// 业务异常——返回具体错误
log.warn("业务异常: code={}, message={}, context={}",
ex.getErrorCode(), ex.getMessage(), ex.getContext());
return ResponseEntity.status(HttpStatus.BAD_REQUEST)
.body(ErrorResponse.of(ex.getErrorCode(), ex.getMessage()));
}
@ExceptionHandler(Exception.class)
public ResponseEntity<ErrorResponse> handleUnknown(Exception ex, HttpServletRequest request) {
// 不可预见异常——记录日志、发送告警
String requestId = request.getAttribute("requestId").toString();
log.error("[{}] 未知异常", requestId, ex);
alertService.sendAlert("UNKNOWN_EXCEPTION",
Map.of("requestId", requestId, "message", ex.getMessage()));
// 不暴露技术细节
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
.body(ErrorResponse.of("SYSTEM_ERROR", "系统繁忙,请稍后重试"));
}
}
自定义异常尽量从问题本身的性质出发定义异常,避免以具体场景、发送方、处理方的不同而定义不同的异常类型,以避免异常数量的膨胀。
❌ 反模式:按场景定义异常:
// 异常数量膨胀,难以管理
public class WithdrawInsufficientBalanceException extends Exception {}
public class TransferInsufficientBalanceException extends Exception {}
public class PaymentInsufficientBalanceException extends Exception {}
✅ 正确做法:按性质定义异常:
// 统一的余额不足异常,通过上下文区分场景
public class InsufficientBalanceException extends BusinessException {
public InsufficientBalanceException(String operationType, BigDecimal required, BigDecimal available) {
super(ErrorCode.INSUFFICIENT_BALANCE,
String.format("%s 操作需要 %s,当前可用余额 %s", operationType, required, available),
Map.of("operation", operationType, "required", required, "available", available));
}
}
异常命名规范:
| 命名模式 | 示例 | 适用场景 | 说明 |
|---|---|---|---|
[性质]Exception |
ValidationException |
通用业务异常 | 可在多处复用的通用异常 |
[性质]Error |
ConfigurationError |
严重配置错误 | 启动时就该发现的致命问题 |
[动作][性质]Exception |
PaymentTimeoutException |
特定动作异常 | 仅在特定动作下发生 |
[模块][性质]Exception |
UserNotFoundException |
领域专有异常 | 限界上下文内的专用异常 |
异常传递应遵循以下原则:
new Exception("msg", original))✅ 正确的异常转换:
public void createOrder(OrderRequest request) {
try {
database.save(order);
} catch (SQLException e) {
// 转换异常,增加业务上下文,保留原始异常
throw new OrderCreationException(
"订单创建失败,订单号: " + request.getOrderNo(), e);
}
}
❌ 错误的异常处理:
// 空 catch 块——异常被吞没
try { process(); } catch (Exception e) { }
// 丢失原始堆栈——排障信息不足
try { process(); } catch (Exception e) {
throw new RuntimeException("出错了"); // 原始异常和堆栈都不见
}
// 过度包装——每个层级都包装一次
try {
service.call();
} catch (BusinessException e) {
// 第三层包装了相同的信息
throw new ServiceException("服务异常", e);
}
异常日志是排查问题的重要依据,应遵循以下规范:
必须记录的信息:
日志级别选择:
| 异常类型 | 日志级别 | 说明 | 典型处理 |
|---|---|---|---|
| 业务异常(预期内) | WARN | 用户操作导致的异常 | 记录参数和业务上下文 |
| 可预见的系统异常 | ERROR | 系统问题,需要关注 | 记录完整堆栈,发送通知 |
| 不可预见的异常 | ERROR + 告警 | 可能代表 Bug,需要立即处理 | 记录完整堆栈,发送告警 |
| 降级/熔断事件 | WARN | 系统自动保护行为 | 记录降级策略和触发条件 |
日志格式示例:
[2024-01-15 10:23:45] [ERROR] [requestId=abc123] [userId=10086]
Payment failed for order: ORDER_20240115001
Exception: InsufficientBalanceException: 支付需要 1000.00,当前余额 500.00
at com.example.PaymentService.process(PaymentService.java:45)
at com.example.OrderService.pay(OrderService.java:123)
...
[Context]: {operation=order_payment, orderNo=ORDER_20240115001, amount=1000.00}
异常处理与事务管理密切相关:
基本规则:
Spring 事务配置示例:
// 指定哪些异常回滚,哪些不回滚
@Transactional(
rollbackFor = BusinessException.class,
noRollbackFor = PartialSuccessException.class
)
public void processOrder(Order order) {
// 业务逻辑
}
分布式事务中的异常处理:
| 方案 | 异常处理策略 | 适用场景 |
|---|---|---|
| 2PC/XA | 协调者负责统一回滚 | 强一致性、短事务 |
| TCC | try-confirm-cancel 三阶段,cancel 做补偿 | 跨服务长事务 |
| Saga | 编排链式补偿事务 | 最终一致性、事件驱动 |
| 本地消息表 | 异常时记录消息,定时重试 | 异步解耦场景 |
| Outbox Pattern | 统一写 outbox 表,CDC 分发 | 保证本地事务与消息一致 |
在设计异常体系时,检查以下要点:
错误码是异常体系的重要组成部分。好的错误码设计让排查问题事半功倍。
推荐格式:[系统标识]_[模块]_[错误类型]_[序号]
| 错误码 | 含义 | 用户提示 |
|---|---|---|
PAY_001_001 |
支付系统-账户模块-余额不足 | "余额不足,请充值" |
ORD_002_003 |
订单系统-创建模块-商品已下架 | "商品已下架,请选择其他商品" |
SYS_001_001 |
系统级-限流-被限流 | "系统繁忙,请稍后重试" |
AUTH_002_001 |
认证-令牌-过期 | "登录已过期,请重新登录" |
PARAM_001_001 |
参数-手机号-格式错误 | "手机号格式不正确" |
错误码分类:
| 类型 | 范围 | 说明 | 是否暴露给用户 |
|---|---|---|---|
| 系统级错误 | SYS_xxx |
基础设施问题 | 否,返回通用提示 |
| 业务级错误 | [业务]_xxx |
业务规则违反 | 是,需明确告知 |
| 参数错误 | PARAM_xxx |
输入校验失败 | 是,需明确告知 |
| 权限错误 | AUTH_xxx |
认证授权问题 | 是,需引导用户操作 |
在微服务架构中,异常需要在服务间传递。以下是一个典型的微服务异常处理流程:
策略:
统一错误响应格式:
{
"success": false,
"errorCode": "PAY_001_001",
"errorMessage": "余额不足",
"traceId": "abc123-def456",
"timestamp": "2024-01-15T10:23:45Z",
"details": {
"required": 1000.00,
"available": 500.00
}
}
建立完善的异常监控体系是系统可靠性的保障:
监控维度:
| 维度 | 指标 | 告警阈值 | 严重级别 |
|---|---|---|---|
| 异常频率 | 每秒异常次数、各类型异常趋势 | 环比增长 > 50% | P0-P3 |
| 异常恢复 | MTTR(平均修复时间) | > 30 分钟 | P1 |
| 影响范围 | 受影响用户数、交易数、订单数 | 影响用户 > 100 | P0 |
| 异常覆盖率 | 已知异常 vs 未知异常的比例 | 未知异常占比 > 10% | P2 |
告警策略:
对于不使用异常机制的编程范式(如 Go 的错误返回值),或者需要用类型系统表达"可能失败"的场景,Result 类型是一种优雅的选择。
| 对比维度 | 异常机制 | Result 类型 |
|---|---|---|
| 类型安全 | 编译期不检查 | 编译期检查 |
| 性能开销 | 创建异常对象、展开堆栈 | 几乎无开销 |
| 错误传播 | 自动沿调用栈传播 | 手动处理返回值 |
| 适用语言 | Java, C#, Python, Ruby | Rust, Go(惯用), Kotlin, Scala |
| 适用场景 | 不可恢复的系统异常 | 预期的业务失败 |
Java 中使用 Result 类型:
public class Result<T> {
private final T data;
private final Error error;
private final boolean success;
private Result(T data, Error error) {
this.data = data;
this.error = error;
this.success = error == null;
}
public static <T> Result<T> success(T data) {
return new Result<>(data, null);
}
public static <T> Result<T> failure(Error error) {
return new Result<>(null, error);
}
public T orElseThrow() {
if (!success) throw error.toException();
return data;
}
}
// 使用
Result<Order> result = orderService.create(request);
if (result.isFailure()) {
return ResponseEntity.badRequest().body(result.getError());
}
受检异常 vs 非受检异常:
| 对比维度 | 受检异常(Checked) | 非受检异常(Unchecked) |
|---|---|---|
| 基类 | Exception(不含 RuntimeException) | RuntimeException |
| 设计要求 | 强制调用方处理 | 调用方可选处理 |
| 适用场景 | 可恢复的外部错误 | 编程错误/不可恢复 |
| 现代实践 | 避免使用 | 推荐使用 |
| 性能影响 | 同 | 同 |
推荐模式:
// 推荐:用 Optional 避免 NullPointerException
Optional<User> user = userRepository.findById(id);
User u = user.orElseThrow(() -> new UserNotFoundException("用户不存在: " + id));
// 使用 @NonNull 注解 + IDE 静态检查
public void process(@NonNull User user) {
// 编译器/IDE 会检查 user 是否为 null
}
EAFP vs LBYL:
| 范式 | 全称 | Python 推荐度 | 适用场景 |
|---|---|---|---|
| EAFP | It's Easier to Ask for Forgiveness than Permission | 高 | 外部资源访问(文件、网络) |
| LBYL | Look Before You Leap | 中等 | 业务校验、参数验证 |
# EAFP 风格(Python 推荐)
def read_config(path: str) -> dict:
try:
with open(path, 'r') as f:
return json.load(f)
except FileNotFoundError:
log.warning(f"配置文件 {path} 不存在,使用默认配置")
return {}
except json.JSONDecodeError:
log.error(f"配置文件 {path} 格式错误")
return {}
# LBYL 风格(适用于业务校验)
def transfer(sender: Account, receiver: Account, amount: Decimal):
if not sender.has_sufficient_balance(amount):
return Result.fail("余额不足")
if not receiver.is_active():
return Result.fail("对方账户已冻结")
# 所有校验通过后执行
execute_transfer(sender, receiver, amount)
自定义异常规范:
class BusinessError(Exception):
"""业务异常基类"""
def __init__(self, code: str, message: str, context: dict = None):
self.code = code
self.context = context or {}
super().__init__(message)
# 使用
raise BusinessError("PAY_001_001", "余额不足",
{"required": 1000, "available": 500})
Go 没有异常机制,使用 error 返回值:
规范:
fmt.Errorf("...: %w", err) 包装错误(Go 1.13+)errors.Is() 和 errors.As() 解包错误链// 定义哨兵错误
var ErrInsufficientBalance = errors.New("余额不足")
// 包装错误链
func Withdraw(account string, amount decimal.Decimal) error {
balance, err := getBalance(account)
if err != nil {
return fmt.Errorf("查询余额失败: %w", err)
}
if balance.LessThan(amount) {
return fmt.Errorf("%w: 需要 %s, 可用 %s",
ErrInsufficientBalance, amount, balance)
}
// ...
return nil
}
// 调用方解包
err := Withdraw("alice", 100)
if errors.Is(err, ErrInsufficientBalance) {
// 处理余额不足
} else if err != nil {
// 处理其他错误
}
| 特性 | Java | Python | Go | Rust | JavaScript |
|---|---|---|---|---|---|
| 异常机制 | try-catch-finally | try-except-finally | error 返回值 | Result<T, E> | try-catch |
| 自定义异常 | 继承 Exception | 继承 Exception | errors.New | Enum | 继承 Error |
| 异常检查 | 可选(Checked/Unchecked) | 无 | 类型系统 | 类型系统 | 无 |
| 错误包装 | new Exception(msg, cause) |
raise ... from e |
fmt.Errorf("%w") |
.map_err() |
手动 |
| 全局处理 | @ControllerAdvice | 装饰器 | 中间件 | 匹配 Err 分支 | Express 中间件 |
| 性能影响 | 异常对象 O(1) | 异常对象 O(1) | error 值无开销 | Result 枚举无开销 | 异常对象 O(1) |
| 反模式 | 表面特征 | 实际危害 | 改进方案 |
|---|---|---|---|
| 空 catch 块 | catch(e) {} |
异常被永久隐藏 | 至少记录 WARN 日志 |
| 异常做流程控制 | 用 try-catch 替代 if-else | 性能损耗 + 语义不清 | 改用 Guard Clause + 返回值 |
| 吞着异常继续 | 捕获后继续执行 | 数据可能已损坏 | 尽快失败 + 回滚 |
| 捕获太宽泛 | catch(Exception e) |
难以定位具体问题 | 逐层细化异常类型 |
| 重复包装 | A->B->C 三次包装 | 堆栈变长,信息重复 | 只在关键边界转换 |
| 暴露内部细节 | 把 SQL 错误返回给用户 | 安全风险 + 用户困惑 | 统一转换为业务错误 |
Java 7 引入的 try-with-resources 确保资源自动关闭:
// ❌ 传统方式——需要手动关闭
BufferedReader reader = null;
try {
reader = new BufferedReader(new FileReader("file.txt"));
return reader.readLine();
} finally {
if (reader != null) reader.close();
}
// ✅ try-with-resources——自动关闭
try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
return reader.readLine();
}
在 DDD 中,异常分为领域异常和应用异常:
| 层次 | 异常类型 | 处理位置 | 示例 |
|---|---|---|---|
| 领域层 | DomainException | 领域服务内部 | "转账金额不能为负" |
| 应用层 | ApplicationException | 应用服务 | "用户不存在" |
| 基础设施层 | InfrastructureException | 仓库实现 | "数据库连接失败" |
| 接口层 | 统一转换 | 全局处理器 | 所有异常→统一响应格式 |
// 领域异常——表达通用业务规则
public class MoneyCannotBeNegative extends DomainException {
public MoneyCannotBeNegative() {
super("金额不能为负值");
}
}
// 应用异常——表达用例级别的错误
public class UserNotFoundException extends ApplicationException {
public UserNotFoundException(String userId) {
super("用户不存在: " + userId);
}
}
响应式编程(Reactive Programming)中的异常处理与传统方式不同:
| 传统方式 | 响应式方式 | 说明 |
|---|---|---|
| try-catch | onErrorResume() |
发生错误时提供备选 |
| throw | Mono.error() / Flux.error() |
在响应式流中发出错误信号 |
| finally | doFinally() |
无论成功/失败都执行 |
// 响应式异常处理
Flux.just("user1", "user2", "user3")
.flatMap(this::fetchUserData)
.onErrorResume(UserNotFoundException.class, e -> {
log.warn("用户不存在: {}", e.getUserId());
return Mono.empty(); // 跳过错误,继续处理
})
.onErrorResume(DatabaseException.class, e -> {
log.error("数据库异常", e);
return Flux.error(new BusinessException("SYS_001", "系统繁忙"));
})
.doFinally(signal -> {
log.info("处理完成,信号: {}", signal);
});
现代微服务架构中,异常处理需要与可观测性(Observability)三支柱紧密配合:
结构化日志示例:
{
"timestamp": "2024-01-15T10:23:45.123Z",
"level": "ERROR",
"logger": "com.example.PaymentService",
"traceId": "abc123-def456-789",
"spanId": "span-001",
"userId": "user_10086",
"error": {
"type": "InsufficientBalanceException",
"code": "PAY_001_001",
"message": "支付需要 1000.00,当前余额 500.00",
"stacktrace": ["at com.example.PaymentService.process:45", "..."]
},
"context": {
"orderNo": "ORDER_20240115001",
"amount": 1000.00,
"available": 500.00,
"paymentMethod": "balance"
}
}
良好的异常处理是系统稳定性的基石。核心要点:
| 原则 | 说明 | 一句话记住 |
|---|---|---|
| 区分业务异常和系统异常 | 不同异常,不同处理策略 | "用户看到的和开发看到的不一样" |
| 不用异常处理正常业务 | 异常是例外,不是流程分支 | "if-else 能解决的问题别用 try-catch" |
| 尽快失败 | 发现问题立即终止,避免错误扩散 | "在源头掐灭,别等它烧遍全链路" |
| 全局统一处理 | 避免巴洛克式异常处理 | "一次全局配置,胜过处处重复" |
| 保留完整上下文 | 异常信息要足够诊断问题 | "异常消息要能回答发生了什么、在哪里、为什么" |
| 建立监控告警 | 异常是系统健康的晴雨表 | "没有告警的异常等于没有发生" |
| 错误码规范化 | 唯一标识每个错误场景 | "错误码是异常的身份证号" |
| 跨服务传递 | traceId 串联全链路异常 | "从客户端到数据库,一个 traceId 走到底" |
记住:异常处理的目标不是"消灭异常",而是"优雅地处理异常"。一个从不抛出异常的系统,可能是一个从不检查错误的系统。