Spring反应式Mongo路由器处理程序中的UpdateById方法

Question

在Spring ReactiveJava如何使用路由器和处理程序编写updateById（）方法？

例如，路由器有以下代码：

RouterFunctions.route(RequestPredicates.PUT("/employees/{id}").and(RequestPredicates.accept(MediaType.APPLICATION_JSON))
    .and(RequestPredicates.contentType(MediaType.APPLICATION_JSON)),
        employeeHandler::updateEmployeeById);

我的问题是如何编写雇员处理程序::update雇员ById（）保持ID不变，但更改雇员对象的其他成员？

java prettyprint-override">public Mono<ServerResponse> updateEmployeeById(ServerRequest serverRequest) {
    Mono<Employee> employeeMono = serverRequest.bodyToMono(Employee.class);

    <And now what??>

    return ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(employeeMono, Employee.class);
}

Employee类如下所示：

@Document
@Data  
@AllArgsConstructor  
@NoArgsConstructor  
public class Employee {

    @Id
    int id;
    double salary;

}

谢谢你的帮助。

Answer 1

上述的一个稍有不同的版本毫无例外地发挥了作用：

public Mono<ServerResponse> updateEmployeeById(ServerRequest serverRequest) {

        Mono<ServerResponse> notFound = ServerResponse.notFound().build();

        Mono<Employee> employeeMono = serverRequest.bodyToMono(Employee.class);
        Integer employeeId = Integer.parseInt(serverRequest.pathVariable("id"));

        employeeMono = employeeMono.flatMap(employee -> employeeRepository.findById(employeeId)
                .map(foundEmployee -> {                 
                    foundEmployee.setSalary(employee.getSalary());
                    return foundEmployee;
                })
                .flatMap(employeeRepository::save));

        return ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(employeeMono, Employee.class).switchIfEmpty(notFound);
    }

感谢斯捷潘·齐布尔斯基。

Answer 2

首先，您必须在类路径中添加ReactiveMongoRepository。你也可以在这里读到。

    @Repository
    public interface EmployeeRepository extends ReactiveMongoRepository<Employee, Integer> {
        Mono<Employee> findById(Integer id);
    }

然后，updateEmployeeById方法可以具有以下结构：

    public Mono<ServerResponse> updateEmployeeById(ServerRequest serverRequest) {
    return serverRequest
            .bodyToMono(Employee.class)
            .doOnSubscribe(e -> log.info("update employee request received"))
            .flatMap(employee -> {
                Integer id = Integer.parseInt(serverRequest.pathVariable("id"));
                return employeeRepository
                        .findById(id)
                        .switchIfEmpty(Mono.error(new NotFoundException("employee with " + id + " has not been found")))

                        // what you need to do is to update already found entity with
                        // new values. Usually map() function is used for that purpose
                        // because map is about 'transformation' what is setting new
                        // values in our case
                        .map(foundEmployee -> {
                            foundEmployee.setSalary(employee.getSalary());
                            return foundEmployee;
                        });
            })
            .flatMap(employeeRepository::save)
            .doOnError(error -> log.error("error while updating employee", error))
            .doOnSuccess(e -> log.info("employee [{}] has been updated", e.getId()))
            .flatMap(employee -> ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(BodyInserters.fromValue(employee), Employee.class));
}

更新：

根据Prana的回答，我已经更新了上面的代码，将我们的解决方案合并到了一起。添加了Slf4j帮助下的日志记录。和switchIfEmpty（）用于未找到实体的情况。

我还建议您阅读关于全局异常处理的文章，这将使您的应用编程接口更好。其中一部分我可以在这里提供：

/**
 * Returns routing function.
 *
 * @param errorAttributes errorAttributes
 * @return routing function
 */
@Override
protected RouterFunction<ServerResponse> getRoutingFunction(ErrorAttributes errorAttributes) {
    return RouterFunctions.route(RequestPredicates.all(), this::renderErrorResponse);
}

private HttpStatus getStatus(Throwable error) {
    HttpStatus status;
    if (error instanceof NotFoundException) {
        status = NOT_FOUND;
    } else if (error instanceof ValidationException) {
        status = BAD_REQUEST;
    } else {
        status = INTERNAL_SERVER_ERROR;
    }
    return status;
}

/**
 * Custom global error handler.
 *
 * @param request request
 * @return response
 */
private Mono<ServerResponse> renderErrorResponse(ServerRequest request) {

    Map<String, Object> errorPropertiesMap = getErrorAttributes(request, false);

    Throwable error = getError(request);
    HttpStatus errorStatus = getStatus(error);

    return ServerResponse
            .status(errorStatus)
            .contentType(APPLICATION_JSON)
            .body(BodyInserters.fromValue(errorPropertiesMap));
}