spring boot 全局异常处理可以通过配置 @controlleradvice 结合 @exceptionhandler 来捕获悲观锁异常。核心做法是识别抛出 pessimisticlockingfailureexception 或 optimisticlockexception 的底层原因,并在处理器中返回特定的 http 状态码(如 409 conflict)或业务错误信息。由于 jpa/hibernate 在获取行锁失败时通常抛出 pessimisticlockingfailureexception,而乐观锁冲突抛出 optimisticlockexception,我们需要针对这两种情况分别编写处理逻辑,确保前端能明确区分是资源被占用还是数据版本冲突。

PessimisticLockingFailureException 的具体触发条件是什么
当使用 LOCK_MODE.PESSIMISTIC_WRITE 或 PESSIMISTIC_READ 查询数据库时,如果目标行已被其他事务锁定且当前事务无法立即获取锁(例如等待超时或死锁检测),JPA 实现层会抛出 PessimisticLockingFailureException。这通常发生在高并发场景下,多个事务同时尝试更新同一行数据。要捕获此异常,需在全局异常处理器中显式声明对该异常类型的处理,并提取其根本原因(Root Cause)以判断是 MySQL 的锁等待超时还是其他数据库特有的锁机制限制。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class LockDemoApplication {
public static void main(String[] args) {
SpringApplication.run(LockDemoApplication.class, args);
}
}
import jakarta.persistence.*;
@Entity
@Table(name = "account")
public class Account {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
private Double balance;
// Getters and Setters omitted for brevity
}
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Lock;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;
import jakarta.persistence.LockModeType;
@Repository
public interface AccountRepository extends JpaRepository<Account, Long> {
@Lock(LockModeType.PESSIMISTIC_WRITE)
@Query("SELECT a FROM Account a WHERE a.id = :id")
Account findByIdWithPessimisticLock(@Param("id") Long id);
}
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Service
public class AccountService {
private final AccountRepository accountRepository;
public AccountService(AccountRepository accountRepository) {
this.accountRepository = accountRepository;
}
@Transactional
public void transfer(Long fromId, Double amount) {
// 尝试获取悲观锁,如果失败将抛出 PessimisticLockingFailureException
Account source = accountRepository.findByIdWithPessimisticLock(fromId);
if (source.getBalance() < amount) {
throw new IllegalArgumentException("Insufficient balance");
}
source.setBalance(source.getBalance() - amount);
accountRepository.save(source);
}
}
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/api/accounts")
public class AccountController {
private final AccountService accountService;
public AccountController(AccountService accountService) {
this.accountService = accountService;
}
@PostMapping("/transfer")
public String transfer(@RequestParam Long fromId, @RequestParam Double amount) {
try {
accountService.transfer(fromId, amount);
return "Transfer successful";
} catch (Exception e) {
// 实际生产中应记录日志
return "Error: " + e.getMessage();
}
}
}
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.orm.ObjectOptimisticLockingFailureException;
import org.springframework.dao.PessimisticLockingFailureException;
import java.util.HashMap;
import java.util.Map;
@RestControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler(PessimisticLockingFailureException.class)
public ResponseEntity<Map<String, String>> handlePessimisticLock(PessimisticLockingFailureException ex) {
Map<String, String> error = new HashMap<>();
error.put("error", "Resource is currently locked by another transaction. Please retry later.");
error.put("type", "PESSIMISTIC_LOCK");
return ResponseEntity.status(HttpStatus.CONFLICT).body(error);
}
@ExceptionHandler(ObjectOptimisticLockingFailureException.class)
public ResponseEntity<Map<String, String>> handleOptimisticLock(ObjectOptimisticLockingFailureException ex) {
Map<String, String> error = new HashMap<>();
error.put("error", "Data version conflict. The record has been modified by another user.");
error.put("type", "OPTIMISTIC_LOCK");
return ResponseEntity.status(HttpStatus.CONFLICT).body(error);
}
@ExceptionHandler(Exception.class)
public ResponseEntity<Map<String, String>> handleGeneral(Exception ex) {
Map<String, String> error = new HashMap<>();
error.put("error", "An unexpected error occurred.");
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(error);
}
}
预期结果:当两个事务同时调用 transfer 方法操作同一账户时,第二个事务将收到 HTTP 409 响应,Body 中包含 "type": "PESSIMISTIC_LOCK"。若使用乐观锁(添加 @Version 字段),则收到 "type": "OPTIMISTIC_LOCK"。
OptimisticLockException 与悲观锁异常的处理差异有哪些
乐观锁异常 ObjectOptimisticLockingFailureException 是在事务提交阶段,因数据库行版本号(@Version)不匹配而抛出的,它不涉及数据库层面的行锁竞争,而是应用层的并发控制策略。相比之下,悲观锁异常在查询阶段即抛出,因为数据库引擎拒绝授予锁。在处理上,乐观锁异常更适合通过重试机制解决,因为冲突通常是暂时的;而悲观锁异常可能需要更复杂的锁等待策略或降级方案。两者在全局异常处理器中应分开处理,以便前端采取不同的用户提示策略。

import jakarta.persistence.*;
@Entity
@Table(name = "account_optimistic")
public class AccountOptimistic {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
private Double balance;
@Version
private Integer version;
// Getters and Setters omitted for brevity
}
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface AccountOptimisticRepository extends JpaRepository<AccountOptimistic, Long> {
}
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Service
public class OptimisticAccountService {
private final AccountOptimisticRepository repository;
public OptimisticAccountService(AccountOptimisticRepository repository) {
this.repository = repository;
}
@Transactional
public void updateBalance(Long id, Double newBalance) {
AccountOptimistic account = repository.findById(id)
.orElseThrow(() -> new RuntimeException("Account not found"));
account.setBalance(newBalance);
// 提交时检查 @Version 字段,若不匹配则抛出 ObjectOptimisticLockingFailureException
repository.save(account);
}
}
预期结果:当两个事务同时读取同一账户并修改余额后提交,先提交的事务成功,后提交的事务将抛出 ObjectOptimisticLockingFailureException,被全局处理器捕获并返回 409 状态码及 "OPTIMISTIC_LOCK" 类型标识。
如何根据 PessimisticLockingFailureException 的根因区分 MySQL 锁等待超时与其他数据库锁冲突
PessimisticLockingFailureException 的 cause 属性包含了底层 JDBC 驱动抛出的原始异常。在 MySQL 中,如果锁等待超过 innodb_lock_wait_timeout 设置的时间,根因通常是 com.mysql.cj.jdbc.exceptions.MySQLTransactionRollbackException 或 java.sql.SQLTransactionRollbackException,错误代码为 1205(Lock wait timeout exceeded)。而在 PostgreSQL 中,可能表现为 org.postgresql.util.PSQLException 错误代码 40P01(deadlock detected)或 55P03(cannot serialize access due to concurrent update)。通过检查 ex.getCause() 的类型和 SQL 错误代码,可以在全局异常处理器中提供更精确的错误消息,帮助开发者或运维人员快速定位是锁等待超时还是死锁问题。


















