Kotlin(SpringBoot)中基于JpaRepository通过Service层优雅实现行删除

这个问题我太有共鸣了——把数据库操作从Controller抽去Service后，生硬的if-else确实破坏了原来那种流畅的链式代码风格。结合Kotlin的语法糖和Spring的最佳实践，有几个方案能帮你找回优雅感：

方案一：让Service返回Optional<Unit>，复用链式调用 #

这种方式既保持了Service和Web层的解耦，又能让Controller回到原来的简洁风格：

Service层代码 #

@Service
class UserService(private val userRepository: UserRepository) {
    fun deleteById(id: Long): Optional<Unit> = userRepository.findById(id).map {
        userRepository.delete(it)
    }
}

这里我们直接返回findById的Optional映射结果——找到用户就执行删除，返回Optional.of(Unit)；没找到就返回Optional.empty()，完全贴合原来的逻辑。

Controller层代码 #

@RestController
@RequestMapping("/users")
class UserController(private val userService: UserService) {
    @DeleteMapping("/{id}")
    fun deleteById(@PathVariable id: Long): ResponseEntity<Void> =
        userService.deleteById(id)
            .map { ResponseEntity.ok().build<Void>() }
            .orElseGet { ResponseEntity.notFound().build() }
}

用map和orElseGet链式处理结果，和你最初在Controller里的写法几乎一样简洁，同时完成了逻辑分层。

方案二：自定义密封类，实现类型安全的状态返回 #

如果你的业务逻辑后续可能扩展更多状态（比如权限不足、删除失败等），用密封类会更灵活，而且编译期就能保证所有分支都被处理：

定义密封类 #

sealed class OperationResult {
    object Success : OperationResult()
    object NotFound : OperationResult()
    // 后续可以加比如 PermissionDenied 等状态
}

Service层代码 #

@Service
class UserService(private val userRepository: UserRepository) {
    fun deleteById(id: Long): OperationResult =
        if (userRepository.existsById(id)) {
            userRepository.deleteById(id)
            OperationResult.Success
        } else {
            OperationResult.NotFound
        }
}

这里用existsById比findById更高效，因为不需要加载整个用户实体，只需要检查存在性。

Controller层代码 #

@RestController
@RequestMapping("/users")
class UserController(private val userService: UserService) {
    @DeleteMapping("/{id}")
    fun deleteById(@PathVariable id: Long): ResponseEntity<Void> =
        when (userService.deleteById(id)) {
            OperationResult.Success -> ResponseEntity.ok().build()
            OperationResult.NotFound -> ResponseEntity.notFound().build()
        }
}

when表达式搭配密封类，代码可读性拉满，后续扩展状态只需要在密封类里加新对象，Controller里补分支即可。

方案三：利用全局异常处理，让Controller最简洁 #

这是Spring生态下最推荐的解耦方式——Service只负责业务规则，不存在就抛出异常，异常交给全局处理器统一处理，Controller只需要专注于请求响应：

自定义业务异常 #

class UserNotFoundException(userId: Long) : RuntimeException("User with id $userId not found")

Service层代码 #

@Service
class UserService(private val userRepository: UserRepository) {
    fun deleteById(id: Long) {
        if (!userRepository.existsById(id)) {
            throw UserNotFoundException(id)
        }
        userRepository.deleteById(id)
    }
}

全局异常处理器 #

@RestControllerAdvice
class GlobalExceptionHandler {
    @ExceptionHandler(UserNotFoundException::class)
    fun handleUserNotFound(ex: UserNotFoundException): ResponseEntity<Void> {
        return ResponseEntity.notFound().build()
    }
}

Controller层代码 #

@RestController
@RequestMapping("/users")
class UserController(private val userService: UserService) {
    @DeleteMapping("/{id}")
    fun deleteById(@PathVariable id: Long): ResponseEntity<Void> {
        userService.deleteById(id)
        return ResponseEntity.ok().build()
    }
}

Controller代码极致简洁，完全不用处理业务状态判断，所有异常统一由全局处理器处理，符合单一职责原则。

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