Spring Boot唯一字段DataIntegrityViolationException未同时抛出问题

PostgreSQL 在执行 INSERT/UPDATE 操作时，会按照唯一约束的创建顺序逐个校验约束条件，一旦检测到第一个违反约束的字段，就会立即终止操作并抛出异常，不会继续校验后续的约束。这就是为什么提交重复的 username 和 email 时，只会先触发其中一个字段的异常。

要实现同时返回所有违反唯一约束的字段信息，最可靠的方式是在保存数据前主动校验所有唯一字段，同时配合异常处理兜底并发场景的问题。

1. 扩展 Repository 方法 #

在 UserRepository 中添加查询方法，用于检查字段是否已存在：

public interface UserRepository extends JpaRepository<User, UUID> {
    boolean existsByUsername(String username);
    boolean existsByEmail(String email);
}

2. 在 Service 中主动校验并抛出自定义异常 #

修改 AuthenticationService 的 register 方法，提前检查所有唯一字段，收集所有重复项后抛出自定义异常：

@Transactional
public APIResponse<AuthenticationResponseDTO> register(RegisterRequestDTO request) {
    List<String> duplicateFields = new ArrayList<>();

    // 检查用户名是否重复
    if (userRepository.existsByUsername(request.getUsername())) {
        duplicateFields.add("username");
    }
    // 检查邮箱是否重复
    if (userRepository.existsByEmail(request.getEmail())) {
        duplicateFields.add("email");
    }

    // 如果存在重复字段，抛出自定义异常
    if (!duplicateFields.isEmpty()) {
        String errorMsg = String.format("字段 %s 已存在", String.join(", ", duplicateFields));
        throw new DuplicateFieldException(errorMsg, duplicateFields);
    }

    // 原有逻辑继续执行
    var user = User.builder()
                   .email(request.getEmail())
                   .username(request.getUsername())
                   .password(passwordEncoder.encode(request.getPassword()))
                   .type(request.getUserType())
                   .build();

    var jwtToken = jwtService.generateToken(user);
    user.setAuthToken(jwtToken); 

    userRepository.saveAndFlush(user);
    AuthenticationResponseDTO authenticationResponse = AuthenticationResponseDTO.builder()
                                                                                .accessToken(jwtToken)
                                                                                .build();
    return APIResponse.ok(authenticationResponse,
                          Constant.getUserResponseHashMap(),
                          Constant.USER_RESPONSE_CODE_PREFIX.concat("7")
    );
}

3. 创建自定义异常类 #

public class DuplicateFieldException extends RuntimeException {
    private final List<String> duplicateFields;

    public DuplicateFieldException(String message, List<String> duplicateFields) {
        super(message);
        this.duplicateFields = duplicateFields;
    }

    public List<String> getDuplicateFields() {
        return duplicateFields;
    }
}

4. 全局异常处理 #

使用 @ControllerAdvice 捕获自定义异常和数据库原生的 DataIntegrityViolationException，统一返回响应格式：

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(DuplicateFieldException.class)
    public ResponseEntity<APIResponse<Void>> handleDuplicateFieldException(DuplicateFieldException ex) {
        // 构造包含所有重复字段的错误响应
        return ResponseEntity.badRequest().body(
            APIResponse.error(
                ex.getMessage(),
                Collections.singletonMap("duplicateFields", ex.getDuplicateFields()),
                "USER_ERROR_001"
            )
        );
    }

    @ExceptionHandler(DataIntegrityViolationException.class)
    public ResponseEntity<APIResponse<Void>> handleDataIntegrityViolationException(DataIntegrityViolationException ex) {
        // 解析数据库异常信息，提取重复字段（针对并发场景的兜底处理）
        String message = ex.getMostSpecificCause().getMessage();
        List<String> duplicateFields = new ArrayList<>();
        if (message.contains("username")) {
            duplicateFields.add("username");
        }
        if (message.contains("email")) {
            duplicateFields.add("email");
        }
        String errorMsg = String.format("字段 %s 已存在", String.join(", ", duplicateFields));
        return ResponseEntity.badRequest().body(
            APIResponse.error(
                errorMsg,
                Collections.singletonMap("duplicateFields", duplicateFields),
                "USER_ERROR_001"
            )
        );
    }
}

• 主动校验能解决大部分场景的问题，但要注意并发写入的极端情况：比如在你检查字段不存在后，到保存数据前的间隙，有其他请求插入了相同字段，这时候数据库还是会抛出 DataIntegrityViolationException，所以需要全局异常处理兜底。
• 不推荐依赖数据库同时抛出多个约束异常，因为不同数据库的约束校验逻辑可能不同，主动校验的方式更可控、更跨数据库兼容。

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