叛变反应-如果上游不为空，则持续到数据库

Question

我正在开发一个Quarkus MongoDB反应兵变应用程序。我有一个人对象和事件对象。我正在为一个人创建新活动。我的uri看起来像这样

POST/person/{personId}/event

这是完整的代码。

public class EventResource {

    @Inject
    EventRepository eventRepository;

    @Inject
    PersonRepository personRepository;

    @POST
    @Path("/{person_id}/event")
    public Uni<Response> create(Event event, @PathParam("person_id") String personId){
        //Check if personId exist.
        Uni<Person> uniPerson = personRepository.getPersonById(personId);

        //THIS WORKS BUT ON FAILURE IS TREATED WHEN ERROR IS RAISED FOR EeventRepository.craete() and not if person is not found.
         /*return uniPerson.onItem().ifNotNull()
                                    .transformToUni(pid -> eventRepository.create(event, pid.getId()))
                                    .onItem().transform(e -> Response.ok().entity(e).build())

                .onFailure()
                .recoverWithItem(f-> {
                    AStatus status =  createErrorStatus(f.getMessage());
                    return Response.serverError().entity(status).build();
                });
*/
        Uni<Response> eventResp = uniPerson.onItem().transform(person -> {
                                                        if(person==null)
                                                            return Response.serverError().build();
                                                        else{
                                                          return    eventRepository.create(event, person.getId())
                                                                  .onItem().transform(event1 -> Response.ok(event1).build());

                                                        }


                                                    });

        return eventResp;


    }

Answer 1

如果取消，您可以使用兵变：

    @POST
    @Path("/{person_id}/event")
    public Uni<Response> create(Event event, @PathParam("person_id") String personId){
         return personRepository
                 .getPersonById(personId)
                 .onItem().ifNotNull().transformToUni(person -> createEvent(event, person))
                 .onItem().ifNull().continueWith(this::personNotFound)
                 // This onFailure will catch all the errors
                 .onFailure()
                    .recoverWithItem(f-> {
                         AStatus status =  createErrorStatus(f.getMessage());
                         return Response.serverError().entity(status).build();
                    });
    }


    private Uni<Response> createEvent(Event event, Person person) {
        return eventRepository
            .create(event, person.getId())
            .map( e -> Response.ok().entity(e).status(CREATED).build())
    }

    private Response personNotFound() {
        return Response.serverError().build();
    }

您看到的错误是因为当项不为空时，您返回的是Uni

Uni<Response> eventResp = uniPerson
    .chain(person -> {
        if (person==null)
            return Uni.createFrom().item(Response.serverError().build());
        else {
            return eventRepository
                .create(event, person.getId())
                .map(event1 -> Response.ok(event1).build());
        }
    });

我之所以使用map和链chain，是因为它们较短，但可以用 和 onItem。