远程客户端断开时如何取消数据库事务？

针对你遇到的客户端超时断开但服务端仍完成事务、导致数据不一致的问题，可通过以下几种方案解决：

一、主动检测客户端连接状态，中断无效执行 #

在业务逻辑的关键节点（调用外部服务前、执行事务前、事务执行中）检查客户端连接是否已断开，若断开则抛出异常并回滚事务。

实现示例 #

@RestController
class Controller {
    @Autowired
    private BusinessLogicService businessLogicService;

    @PostMapping("/do/thing")
    public Response doThing(HttpServletRequest request) {
        return businessLogicService.performAction(request);
    }
}

@Service
class BusinessLogicService {
    @Autowired
    private TransactionTemplate transactionTemplate;
    @Autowired
    private RestClient restClient;
    @Autowired
    private Dao dao;

    public Response performAction(HttpServletRequest request) {
        // 调用外部服务前检查连接
        if (isClientDisconnected(request)) {
            throw new RuntimeException("客户端已断开连接，终止操作");
        }
        var pieceOfData = restClient.callExternalService();

        // 执行事务前再次检查
        if (isClientDisconnected(request)) {
            throw new RuntimeException("客户端已断开连接，终止操作");
        }

        transactionTemplate.execute(status -> {
            // 若事务内有耗时操作，可在循环/关键步骤插入检查
            if (isClientDisconnected(request)) {
                status.setRollbackOnly();
                throw new RuntimeException("客户端已断开连接，事务回滚");
            }
            dao.save(pieceOfData);
            return null;
        });

        return new Response();
    }

    private boolean isClientDisconnected(HttpServletRequest request) {
        try {
            // 通过输入流状态判断客户端是否断开连接
            return request.getInputStream().isClosed();
        } catch (IOException e) {
            return true;
        }
    }
}

这种方式能及时终止无意义的执行，但存在一定局限性：若客户端断开后服务端未及时检测到，仍可能完成事务。

二、异步处理+任务状态查询模式 #

将耗时业务逻辑改为异步执行，客户端先获取任务ID，后续通过ID轮询查询执行结果。从流程上避免客户端超时导致的一致性问题。

实现示例 #

@RestController
class Controller {
    @Autowired
    private BusinessLogicService businessLogicService;
    @Autowired
    private TaskStatusRepository taskStatusRepository;

    @PostMapping("/do/thing")
    public TaskResponse doThing() {
        TaskStatus task = new TaskStatus();
        task.setStatus(TaskStatus.Status.PENDING);
        task = taskStatusRepository.save(task);
        // 异步执行核心业务逻辑
        businessLogicService.performActionAsync(task.getId());
        // 立即返回任务ID，让客户端后续查询结果
        return new TaskResponse(task.getId());
    }

    @GetMapping("/task/{id}")
    public TaskStatus getTaskStatus(@PathVariable String id) {
        return taskStatusRepository.findById(id)
                .orElseThrow(() -> new RuntimeException("任务不存在"));
    }
}

@Service
class BusinessLogicService {
    @Autowired
    private TransactionTemplate transactionTemplate;
    @Autowired
    private RestClient restClient;
    @Autowired
    private Dao dao;
    @Autowired
    private TaskStatusRepository taskStatusRepository;

    @Async
    public void performActionAsync(String taskId) {
        TaskStatus task = taskStatusRepository.findById(taskId).orElseThrow();
        try {
            var pieceOfData = restClient.callExternalService();
            transactionTemplate.execute(status -> {
                dao.save(pieceOfData);
                return null;
            });
            // 更新任务状态为成功
            task.setStatus(TaskStatus.Status.SUCCESS);
            task.setResult("操作完成");
        } catch (Exception e) {
            // 更新任务状态为失败
            task.setStatus(TaskStatus.Status.FAILED);
            task.setErrorMsg(e.getMessage());
        } finally {
            taskStatusRepository.save(task);
        }
    }
}

// 任务状态实体示例
class TaskStatus {
    public enum Status {PENDING, SUCCESS, FAILED}
    private String id;
    private Status status;
    private String result;
    private String errorMsg;
    // getter/setter省略
}

class TaskResponse {
    private String taskId;
    public TaskResponse(String taskId) {this.taskId = taskId;}
    // getter省略
}

此方案是解决这类问题的最优解之一：客户端无需长时间等待，服务端可正常完成操作，客户端后续能通过任务ID获取最终结果，从根源上避免数据不一致。

三、实现幂等性保障 #

为每个请求分配唯一ID，服务端先校验该ID是否已处理，避免客户端重试导致的重复数据修改。

实现示例 #

@Service
class BusinessLogicService {
    @Autowired
    private TransactionTemplate transactionTemplate;
    @Autowired
    private RestClient restClient;
    @Autowired
    private Dao dao;
    @Autowired
    private RequestLogRepository requestLogRepository;

    public Response performAction(String requestId) {
        // 检查请求是否已处理过
        RequestLog existingLog = requestLogRepository.findByRequestId(requestId);
        if (existingLog != null) {
            if (RequestLog.Status.SUCCESS.equals(existingLog.getStatus())) {
                return existingLog.getResponse();
            } else {
                throw new RuntimeException("请求处理失败：" + existingLog.getErrorMsg());
            }
        }

        try {
            var pieceOfData = restClient.callExternalService();
            return transactionTemplate.execute(status -> {
                dao.save(pieceOfData);
                // 事务内同时记录请求日志，保证一致性
                RequestLog log = new RequestLog();
                log.setRequestId(requestId);
                log.setStatus(RequestLog.Status.SUCCESS);
                log.setResponse(new Response());
                requestLogRepository.save(log);
                return log.getResponse();
            });
        } catch (Exception e) {
            RequestLog errorLog = new RequestLog();
            errorLog.setRequestId(requestId);
            errorLog.setStatus(RequestLog.Status.FAILED);
            errorLog.setErrorMsg(e.getMessage());
            requestLogRepository.save(errorLog);
            throw new RuntimeException("操作失败", e);
        }
    }
}

// 请求日志实体示例
class RequestLog {
    public enum Status {SUCCESS, FAILED}
    private String requestId;
    private Status status;
    private Response response;
    private String errorMsg;
    // getter/setter省略
}

幂等性保障通常配合异步查询模式使用，即使客户端因超时重试，也不会重复修改数据库，进一步强化数据一致性。

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