Разница между Flux.compose и Flux.transform?

Я изучаю реактивные потоки и работаю над издателями (Flux) и работаю над преобразованием Flux. Для этого у меня есть методы создания и преобразования.

Вот мой код:

private static void composeStream() {
    System.out.println("*********Calling composeStream************");
    Function<Flux<String>, Flux<String>> alterMap = f -> {
                                                                return f.filter(color -> !color.equals("ram"))
                                                                        .map(String::toUpperCase);
                                                            };

    Flux<String> compose = Flux.fromIterable(Arrays.asList("ram", "sam", "kam", "dam"))
                                    .doOnNext(System.out::println)
                                    .compose(alterMap);

    compose.subscribe(d -> System.out.println("Subscriber to Composed AlterMap :"+d));
    System.out.println("-------------------------------------");

}

private static void transformStream() {
    System.out.println("*********Calling transformStream************");
    Function<Flux<String>, Flux<String>> alterMap = f -> f.filter(color -> !color.equals("ram"))
                                                            .map(String::toUpperCase);

    Flux.fromIterable(Arrays.asList("ram", "sam", "kam", "dam"))
            .doOnNext(System.out::println)
            .transform(alterMap)
            .subscribe(d -> System.out.println("Subscriber to Transformed AlterMap: "+d));
    System.out.println("-------------------------------------");
}

и вот вывод, одинаковый для обоих случаев:

*********Calling transformStream************
ram
sam
Subscriber to Transformed AlterMap: SAM
kam
Subscriber to Transformed AlterMap: KAM
dam
Subscriber to Transformed AlterMap: DAM
-------------------------------------
*********Calling composeStream************
ram
sam
Subscriber to Composed AlterMap :SAM
kam
Subscriber to Composed AlterMap :KAM
dam
Subscriber to Composed AlterMap :DAM
-------------------------------------

Какая разница между двумя? Пожалуйста, предложите


reactive-programming publisher publish-subscribe project-reactor reactive-streams
person KayV    schedule 03.01.2018    source источник
comment
Привет, @KayV. Я предлагаю вам посетить gitter.im/reactor/reactor. Было бы намного проще и быстрее получить ответ на ваши вопросы :)   -  person Oleh Dokuka    schedule 03.01.2018
comment
Возможный дубликат compose() vs. ) по сравнению с as() по сравнению с map() во Flux и Mono   -  person Oleh Dokuka    schedule 03.01.2018

Ответы (1)


arrow_upward
7
arrow_downward

Согласно документации:

Преобразуйте этот Flux, чтобы создать цель Flux. В отличие от Flux#compose(Function), предоставленная функция выполняется как часть сборки.

Что это значит?

Если мы напишем небольшой тест, как показано ниже:

 int[] counter = new int[1];
 Function transformer  = f -> {
     counter[0]++;

     return f;
 }

 Flux flux = flux Flux.just("")
     .transform(transformer);

 System.out.println(counter[0]);

 flux.subscribe();
 flux.subscribe();
 flux.subscribe();
 System.out.println(counter[0]);

На выходе мы увидим следующий результат:

 1
 1

Это означает, что функция преобразования будет выполняться один раз при сборке трубы, то есть, другими словами, функция преобразования будет выполняться нетерпеливо.

В свою очередь, с .compose мы получим следующее поведение для того же кода

 int[] counter = new int[1];
 Function transformer  = f -> {
     counter[0]++;

     return f;
 }

 Flux flux = flux Flux.just("")
     .compose(transformer);

 System.out.println(counter[0]);

 flux.subscribe();
 flux.subscribe();
 flux.subscribe();
 System.out.println(counter[0]);

И вывод

 0
 3

Это означает, что для каждого подписчика функция преобразования будет выполняться отдельно, и мы можем считать такое выполнение ленивым

person Oleh Dokuka    schedule 03.01.2018