Estoy usando RxJava para procesar algunas notificaciones que extraemos de una cola.

RxJava parecía funcionar bien con un flujo de trabajo simple, ahora con nuevos requisitos, el flujo está creciendo en complejidad con más ramas (vea la imagen a continuación como referencia)ntenté ejemplificar el flujo con una prueba de unidad pequeña:

@Test
public void test() {
    Observable.range(1, 100)
        .groupBy(n -> n % 3)
        .toMap(GroupedObservable::getKey)
        .flatMap(m1 -> {
            Observable<Integer> ones1 = m1.get(0);
            Observable<Integer> twos1 = m1.get(1).map(n -> n - 10);
            Observable<Integer> threes = m1.get(2).map(n -> n + 100);
            Observable<Integer> onesAndTwos = Observable.merge(ones1, twos1)
                .map(n -> n * 3)
                .groupBy(n -> n % 2)
                .toMap(GroupedObservable::getKey)
                .flatMap(m2 -> {
                    Observable<Integer> ones2 = m2.get(0).map(n -> n * 10);
                    Observable<Integer> twos2 = m2.get(1).map(n -> n * 100);
                    return Observable.merge(ones2, twos2);
                });
                return Observable.merge(onesAndTwos, threes).map(n -> n +1);
        })
        .subscribe(System.out::println);
}

Aunque todavía es técnicamente posible usar RxJava, ahora me pregunto si es una buena opción, ya que para formalizar la ramificación tuve que hacer 2 niveles de anidación dentro de la @ principflatMap, que no parece realmente ordenado.

¿Sería esta la forma correcta de describir un flujo de trabajo como el anterior? ¿O RxJava no es una buena opción para ramificar flujos de trabajo?

¡Gracias por tu ayuda