TestReactor

package test;

import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import reactor.core.scheduler.Schedulers;

import java.time.Duration;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Optional;
import java.util.Random;

/**
 * @author he.pei
 */
public class TestReactor {
    public static void main(String[] args) {
        testFlux();
        testMono();

    }

    private static void testMono() {
        Mono.fromSupplier(() -> "Hello").subscribe(System.out::println);
        Mono.justOrEmpty(Optional.of("Hello")).subscribe(System.out::println);
        Mono.create(sink -> sink.success("Hello")).subscribe(System.out::println);
    }

    private static void testFlux() {

        fluxSchedulers();
        fluxError();
        fluxFlatMap();
        fluxRange();
        fluxZipWith();
        fluxTake();
        fluxReduce();
        fluxCreate();
        fluxMerge();
    }

    /**
     *
     */
    private static void fluxSchedulers() {
        Flux.create(sink -> {
                    sink.next(Thread.currentThread().getName());
                    sink.complete();
                }).publishOn(Schedulers.single())
                .map(x -> String.format("[%s] %s", Thread.currentThread().getName(), x))
                .publishOn(Schedulers.elastic())
                .map(x -> String.format("[%s] %s", Thread.currentThread().getName(), x))
                .subscribeOn(Schedulers.parallel())
                .toStream()
                .forEach(System.out::println);
    }

    private static void fluxError() {
        Flux.just(1, 2).concatWith(Mono.error(new IllegalStateException())).subscribe(System.out::println, System.err::println);
        Flux.just(1, 2).concatWith(Mono.error(new IllegalStateException())).onErrorReturn(0).subscribe(System.out::println);

        Flux.just(1, 2).concatWith(Mono.error(new IllegalArgumentException())).onErrorResume(e -> {
            if (e instanceof IllegalStateException) {
                return Mono.just(0);
            } else if (e instanceof IllegalArgumentException) {
                return Mono.just(-1);
            }
            return Mono.empty();
        }).subscribe(System.out::println);

        fluxErrorRetry();

    }

    private static void fluxErrorRetry() {
        Flux.just(1, 2).concatWith(Mono.error(new IllegalStateException())).retry(1).subscribe(System.out::println);
    }

    /**
     * flatMap和flatMapSequential操作符把流中的每个元素转换成一个流，
     * 再把所有流中的元素进行合并。flatMapSequential和flatMap之间的区别与mergeSequential和merge是一样的。
     */
    private static void fluxFlatMap() {
        Flux.just(5, 10).flatMap(x -> Flux.interval(
                        Duration.of(x * 10, ChronoUnit.MILLIS), Duration.of(100, ChronoUnit.MILLIS))
                .take(x)).toStream().forEach(System.out::println);
    }

    private static void fluxCreate() {
        Flux.generate(sink -> {
            sink.next("Hello");
            sink.complete();
        }).subscribe(System.out::println);


        final Random random = new Random();
        Flux.generate(ArrayList::new, (list, sink) -> {
            int value = random.nextInt(100);
            list.add(value);
            sink.next(value);
            if (list.size() == 10) {
                sink.complete();
            }
            return list;
        }).subscribe(System.out::println);


        Flux.create(sink -> {
            for (int i = 0; i < 10; i++) {
                sink.next(i);
            }
            sink.complete();
        }).subscribe(System.out::println);
    }

    private static void fluxRange() {
        Flux.range(1, 100).buffer(20).subscribe(System.out::println);
        Flux.interval(Duration.of(100, ChronoUnit.MILLIS)).buffer(Duration.of(1001, ChronoUnit.MILLIS)).take(2).toStream().forEach(System.out::println);
        Flux.range(1, 10).bufferUntil(i -> i % 2 == 0).subscribe(System.out::println);
        Flux.range(1, 10).bufferWhile(i -> i % 2 == 0).subscribe(System.out::println);
        Flux.range(1, 10).filter(i -> i % 2 == 0).subscribe(System.out::println);
    }

    private static void fluxMerge() {
        Flux.merge(Flux.interval(Duration.ZERO, Duration.of(100, ChronoUnit.MILLIS)).take(5),
                Flux.interval(Duration.of(50, ChronoUnit.MILLIS),
                        Duration.of(100, ChronoUnit.MILLIS)).take(5)).toStream().forEach(System.out::println);


        Flux.mergeSequential(Flux.interval(Duration.ZERO, Duration.of(100, ChronoUnit.MILLIS)).take(5),
                Flux.interval(Duration.of(50, ChronoUnit.MILLIS),
                        Duration.of(100, ChronoUnit.MILLIS)).take(5)).toStream().forEach(System.out::println);


    }

    private static void fluxReduce() {
        Flux.range(1, 100).reduce(Integer::sum).subscribe(System.out::println);
        //在操作时可以指定一个初始值。若没有初始值，则序列的第一个元素作为初始值
        Flux.range(1, 100).reduceWith(() -> 1, Integer::sum).subscribe(System.out::println);
    }

    private static void fluxTake() {
        Flux.range(1, 1000).take(10).subscribe(System.out::println);
        Flux.range(1, 1000).takeLast(10).subscribe(System.out::println);
        Flux.range(1, 1000).takeWhile(i -> i < 10).subscribe(System.out::println);
        Flux.range(1, 1000).takeUntil(i -> i == 10).subscribe(System.out::println);
    }

    private static void fluxZipWith() {
        Flux.just("a", "b").zipWith(Flux.just("c", "d")).subscribe(System.out::println);
        Flux.just("a", "b").zipWith(Flux.just("c", "d"), (s1, s2) -> String.format("%s-%s", s1, s2)).subscribe(System.out::println);
    }
}