项目 - 项目中的异常处理方式

• 1. 异常链
• 2. catch+throw使用示例
• • • 1. 自定义异常
    • 2. Service层抛出IncidentException
    • 3. Controller层继续抛出IncidentException
    • 4. 统一异常处理
• 3. catch + throw使用示例
• • • 1. 自定义异常QueryAlertException
    • 2. Service层抛出IOException
    • 3. Controller层捕获IOException
    • 4. 统一异常处理
• 4. catch+throw使用示例
• • • 1. 自定义异常
    • 2. 异常状态码
    • 3. Service层捕获IOException后抛出CommonException
    • 4. 统一异常处理
• 5. throw使用示例
• • • 1. 自定义异常
    • 2. Service层抛出异常
    • 3. 统一异常处理

对于真实的企业级应用而言，常常有严格的分层关系，层与层之间有非常清晰的划分，上层功能的实现严格依赖于下层的API，也不会跨层访问。

当业务逻辑层访问持久层出现SQLException异常时，程序不应该把底层的SQLException异常传到用户界面，有如下两个原因：

• 对于正常用户而言，他们不想看到底层SQLException异常，SQLException异常对他们使用该系统没有任何帮助。
• 对于恶意用户而言，将SQLException异常暴露出来不安全。

底层的原始异常直接传给用户是一种不负责任的表现。通常的做法是：程序先捕获原始异常，然后抛出一个新的业务异常，新的业务异常中包含了对用户的提示信息，这种处理方式被称为异常转译。

public class MyException extends Exception {
    public MyException(){

    }

    public MyException(String message){
        super(message);
    }
}

public class Test {
    public static void main(String[] args) {
        
    }

    public static void  calSal() throws MyException {
       try {
           //实现工资结算
       }catch (SQLException sqle){
           // 把原始异常信息记录下来，留给管理员
           // ...
           // 下面异常中的message就是对用户的提示
           throw new MyException("访问底层数据库出现异常");
       }catch (Exception e){
           // 把原始异常信息记录下来，留给管理员
           // ...
           // 下面异常中的message就是对用户的提示
           throw new MyException("系统未知异常");
       }
    }
}

这种把原始异常信息隐藏起来，仅向上提供必要的异常提示信息的处理方式，可以保证底层异常不会扩散到表现层，可以避免向上暴露太多的实现细节，这完全符合面向对象的封装原则。

@Data
public class IncidentException extends Exception {
    private static final long serialVersionUID = -7888549951554226678L;

    private Integer code;

    private Object data;

    public IncidentException() {
        this("");
    }

    public IncidentException(String message) {
        this(0, message);
    }

    public IncidentException(Integer code, String message) {
        super(message);
        this.code = code;
    }

    public IncidentException(Integer code, String message, Object data) {
        super(message);
        this.code = code;
        this.data = data;
    }

    public IncidentException(Integer code, String message, Throwable throwable) {
        super(message, throwable);
        this.code = code;
    }
}

对于Checked异常的处理方式有如下两种：

• 当前方法明确知道如何处理该异常，程序应该使用try…catch块来捕获该异常，然后在对应的catch块中修复该异常。
• 当前方法不知道如何处理这种异常，应该在定义该方法时声明抛出该异常。

@Override
public BatchOperateResult toBeTransferred(ToBeTransferOperateQo toBeTransferOperateQo) throws IncidentException {
    try {
        // 该方法会抛出IOException
        List cascadeIds = this.alertDao.getCascadeIds(notAddIds, null);
    
        // 该方法会抛出IOException, JsonSerializeException
        List alerts = this.alertDao.getAlerts(notAddIds);

        // 该方法会抛出NotificationException
        riskEventService.saveBatch(alertList), addResult)
            
    } catch (IOException | JsonSerializeException | NotificationException e) {
        // 这里最好打印日志记录异常发生的详细情况，应用后台需要通过日志来记录异常发生的详细情况；
        // 程序先捕获原始异常，然后抛出一个新的业务异常，新的业务异常中包含了对用户的提示信息
        throw new IncidentException("标记为待流转失败", e);
    }
}

这种catch和throw结合使用的情况在大型企业级应用中非常常用，企业级应用对异常的处理通常分成两个部分：

① 应用后台需要通过日志来记录异常发生的详细情况；

② 应用还需要根据异常向应用使用者传达某种提示。在这种情形下，所有异常都需要两个方法共同完成，也就必须将catch和throw结合使用。

@PostMapping(value = "/transfer")
public ApiResponse toBeTransferred(
    @RequestBody ToBeTransferOperateQo qo) throws IncidentException {
    BatchOperateResult batchOperateResult 
        = this.alertService.toBeTransferred(toBeTransferOperateWithLogQo.getData());
    return this.dealBatchResultOrThrow(batchOperateResult);
}

Controller层并没有对Service层抛出的异常对象进行捕获处理，而是继续抛出IncidentException

@RestControllerAdvice
@Slf4j
@Priority(1)
public class GlobalExceptionHandler {

    @ExceptionHandler(IncidentException.class)
    public ApiResponse