如何抛出异常返回HTTP响应后继续执行后续业务逻辑？

是否存在一种方式，既能返回HTTP响应状态码（比如422），又能继续执行后续业务逻辑？

目前我通过@RestControllerAdvice处理异常，代码如下：

@ExceptionHandler(
    EntityNotFoundException::class,
)
@ResponseStatus(HttpStatus.UNPROCESSABLE_ENTITY)
fun handleBonusNotFound(ex: Exception): ResponseEntity<Any> {
    val errorId = UUID.randomUUID().toString()
    logger.error("errorId: $errorId, msg: '${ex.message}'", ex)

    return ResponseEntity.unprocessableEntity().body(
        ErrorModelResponse(errorId, ex.message.toString())
    )
}

但抛出异常后后续代码无法执行，我需要解决这个问题：既要返回422响应状态码，又要继续执行逻辑，同时希望大部分业务逻辑保留在service层，由@RestController返回响应。请问该如何实现？是否需要模拟异常或已有工具可用？

解决方案 #

首先明确：抛出异常的本质会中断当前线程的执行流程，所以依赖真实抛出异常的方式无法同时满足返回响应和继续执行逻辑的需求，必须换思路实现。以下是几种可行方案：

方案一：异步执行后续业务逻辑，同步返回错误响应 #

核心思路是：先给客户端返回422响应，再把需要继续执行的逻辑交给异步线程处理，避免阻塞响应返回。

1. 开启异步支持：在Spring Boot启动类添加@EnableAsync注解
2. 在Service层定义异步方法：

@Service
class BizService {
    private val logger = LoggerFactory.getLogger(javaClass)

    @Async
    fun executePostResponseLogic() {
        // 这里编写需要后续执行的业务逻辑
        logger.info("开始执行后续业务逻辑")
        // ... 具体逻辑代码
    }
}

3. Controller层直接构造错误响应，触发异步逻辑：

@RestController
class BizController(
    private val bizService: BizService,
    private val logger: Logger
) {
    @GetMapping("/your-endpoint")
    fun handleRequest(): ResponseEntity<Any> {
        // 替换为实际的判断条件，比如检查实体是否存在
        val shouldReturn422 = true

        if (shouldReturn422) {
            val errorId = UUID.randomUUID().toString()
            val errorMsg = "实体不存在"
            logger.error("errorId: $errorId, msg: '$errorMsg'")
            
            // 异步触发后续逻辑，不影响响应返回
            bizService.executePostResponseLogic()
            
            // 同步返回422响应
            return ResponseEntity.unprocessableEntity().body(
                ErrorModelResponse(errorId, errorMsg)
            )
        }

        return ResponseEntity.ok("正常响应")
    }
}

方案二：Service层返回结果标记，Controller层按需返回响应 #

核心思路是：Service层完成所有业务逻辑，同时返回一个标记告知Controller是否需要返回错误响应，Controller根据标记返回对应结果。

1. 定义Service结果包装类：

data class ServiceExecutionResult(
    val needReturnError: Boolean,
    val errorMessage: String?,
    // 可添加业务数据字段
)

2. Service层执行完整逻辑并返回标记：

@Service
class BizService {
    fun executeFullLogic(): ServiceExecutionResult {
        var needReturnError = false
        var errorMsg: String? = null

        // 第一步：判断是否需要返回422的条件
        if (someEntityCheckFailed()) {
            needReturnError = true
            errorMsg = "实体不存在"
        }

        // 继续执行所有后续业务逻辑，不受错误标记影响
        executeSubLogic1()
        executeSubLogic2()

        return ServiceExecutionResult(needReturnError, errorMsg)
    }

    private fun someEntityCheckFailed(): Boolean {
        // 实际的实体检查逻辑
        return true
    }

    private fun executeSubLogic1() {
        // 业务逻辑1
    }

    private fun executeSubLogic2() {
        // 业务逻辑2
    }
}

3. Controller层根据标记返回响应：

@RestController
class BizController(
    private val bizService: BizService,
    private val logger: Logger
) {
    @GetMapping("/your-endpoint")
    fun handleRequest(): ResponseEntity<Any> {
        val result = bizService.executeFullLogic()

        if (result.needReturnError) {
            val errorId = UUID.randomUUID().toString()
            logger.error("errorId: $errorId, msg: '${result.errorMessage}'")
            return ResponseEntity.unprocessableEntity().body(
                ErrorModelResponse(errorId, result.errorMessage.toString())
            )
        }

        return ResponseEntity.ok("正常响应")
    }
}

注意：这种方案是同步执行所有逻辑，如果后续业务耗时较长，会拉长响应返回时间，适合后续逻辑耗时短的场景。

方案三：复用原异常处理逻辑，不真正抛出异常 #

核心思路是：把原来@RestControllerAdvice中的错误响应构造、日志记录逻辑抽成工具类，Controller直接调用工具类生成响应，再触发后续逻辑。

1. 抽取错误响应工具类：

@Component
class ErrorResponseGenerator(private val logger: Logger) {
    fun buildUnprocessableEntityResponse(errorMsg: String): ResponseEntity<Any> {
        val errorId = UUID.randomUUID().toString()
        logger.error("errorId: $errorId, msg: '$errorMsg'")
        return ResponseEntity.unprocessableEntity().body(
            ErrorModelResponse(errorId, errorMsg)
        )
    }
}

2. Controller层调用工具类并触发后续逻辑：

@RestController
class BizController(
    private val errorResponseGenerator: ErrorResponseGenerator,
    private val bizService: BizService
) {
    @GetMapping("/your-endpoint")
    fun handleRequest(): ResponseEntity<Any> {
        val shouldReturn422 = true

        if (shouldReturn422) {
            val errorResponse = errorResponseGenerator.buildUnprocessableEntityResponse("实体不存在")
            // 异步执行后续逻辑
            bizService.executePostResponseLogic()
            return errorResponse
        }

        return ResponseEntity.ok("正常响应")
    }
}

这种方案可以最大化复用原有代码，减少重复编写日志和响应构造的逻辑。

内容的提问来源于stack exchange，提问作者agingcabbage32