Primeros pasos en programación reactiva, II

En esta serie de post acerca de programación reactiva voy a ir contando los pasos que estoy dando para ir practicando con esta forma de programación y más en concreto su uso en aplicaciones HTTP con Micronaut

En el post anterior vimos mediante un par de ejemplos sencillos cómo un Controller puede ofrecer recursos de forma reactiva en lugar de bloqueante. En este segundo post simplemente vamos a estructurar un poco mejor el codigo usando un Service y dejar así el Controller más "림피오"

@Controller("/numbers")
public class NumberGeneratorController {

    @Inject
    NumberGeneratorService service;

    @Get("/list{?size}")
    Single<int[]> list(Optional<Integer> size){
        return service.list( size.orElse(99+1) );
    }
}

@Singleton
public class NumberGeneratorService {

    Single<int[]> list( Integer size) {
        Random rnd = new Random();
        return Single.just(
                IntStream.
                        range(1, size).
                        map(i -> Math.abs(rnd.nextInt())).
                        toArray()
        );
    }
}

노트

Como puedes ver, simplemente hemos movido el codigo al servicio y hacemos que el controlador lo invoque directamente.

Hasta ahora el código era devolver una lista de números que Generamos con una línea de código (partida en varias para mejorar su lectura, pero una línea de codigo al fín y al cabo). Sin embargo muchas veces la lógica a Implementar requerirá de algo más complejo, por lo que un simple just 아니 아니 세르비라. Crearemos entonces un Single que emitirá el resultado (o fallo) cuando se complete dicha lógica

경고

Recuerda que además de Single, Existing otros tipos reactivos interesantes como Flowable o Maybe. 포 아오라
오류가 발생하지 않았음을 알리는 단일 오류가 발생했습니다.

    Single<int[]> listWithBoundControl( Integer size){
        return Single.create( emitter ->{

            if( size > 100){
                emitter.onError(new ArrayIndexOutOfBoundsException());
                return;
            }

            Random rnd = new Random();
            int[] ret = new int[size];
            for(int i=0; i<size; i++){
                ret[i] = Math.abs(rnd.nextInt());
            }
            emitter.onSuccess(ret);
        });
    }

En este ejemplo vemos que podemos notificar un error (si por ejemplo el tamaño que nos piden a general excede un límite), ejecutar codigo en una función privada, etc.

La "magia"en este codigo es que tanto el controller como el servicio lo que devuelven en las llamadas es unSingle el cual el framework, micronaut en este caso, va a manejar para ejecutarlo y devolver el resultado cuando se ejecute.

La segunda "magia"(que a mí specificmente me fascina) es la capacidad del compilador de comprobar que realmente estamos devolviendo lo que dice la firma del metodo que devolvemos. Es decir, si pruebas a cambiar el objeto que devolvemos en onSuccess por un String, por ejemplo, el compilador lo detecta y no compila.

이력서

En este segundo, y corto, post hemos visto cómo ejecutar una lógica de negocio más compleja y notificar el resultado mediante el uso de emitter