es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Operador reactivo adecuado para dos métodos.

15 Jul, 2023 Programación

Tengo dos métodos dependientes entre sí.

Flux<DataBuffer> flux = service1.get();
Mono<String> s = service2.store(flux);

service1.get() devuelve Flux<DataBuffer> o Flux.error en caso de una operación de obtención no exitosa.

service2.store(Flux<DataBuffer> flux) devuelve Mono<String> o Mono.error en caso de una operación de almacenamiento no exitosa.

Service2 es un cliente reactivo Feign que almacena datos en un archivo y devuelve una referencia.

Necesito hacer que la llamada a service2 dependa de service1, pero quiero preservar el parámetro Flux y llamar a cada método solo una vez.
El objetivo es llamar a service2.store solo en caso de una respuesta exitosa de service1.get.

Por ejemplo:

public Mono<String> mainMethod() {
    return service1.get()
      .unknownOperator(flux -> service2.store(flux))
      .doOnError(e -> log.error(e.getMessage));
}

¿Puede aconsejarme cuál es el operador correcto en lugar de unknownOperator?

Los errores deben manejarse de la siguiente manera:
1. El error en service1.get debe registrarse y devolverse desde mainMethod. No se puede llamar a service2.store.
2. El error en service2.store debe registrarse y devolverse desde mainMethod.

Tags:  , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Puedes usar el operador flatMap para encadenar los dos métodos y asegurarte de que service2.store solo se llame si service1.get tiene éxito.

    Aquí tienes un ejemplo de implementación:

    public Mono<string> mainMethod() {
    return service1.get()
        .flatMap(flux -> service2.store(flux).onErrorResume(e -> {
            log.error("Error almacenando datos: " + e.getMessage());
            return Mono.error(e);
        })).onErrorResume(e -> {
            log.error("Error obteniendo datos: " + e.getMessage());
            return Mono.error(e);
        });
}

    El operador flatMap toma la salida de service1.get, que es un Flux<databuffer>, y la pasa a service2.store. Si service2.store encuentra un error, registra el error y lo devuelve al método llamador mediante onErrorResume. Si service1.get encuentra un error, registra el error y lo devuelve al método llamador mediante onErrorResume.

    Con esta implementación, service2.store solo se llama si service1.get tiene éxito, y se manejan correctamente tanto los casos de éxito como de error.

Comments are closed.