what the difference between handle and create?

Article background

i am trying to figure out that the difference betweenhandleand create;
i had refer to the reactor offical documents , but the sample which offical provided , could not point me to understand the diff with handle and create

• The handle sample

Flux<String> alphabet = Flux.just(-1, 30, 13, 9, 20)
    .handle((i, sink) -> {
        String letter = alphabet(i); 
        if (letter != null) 
            sink.next(letter); 
    });

alphabet.subscribe(System.out::println);

• The create sample

Flux<String> bridge = Flux.create(sink -> {
    myEventProcessor.register( 
      new MyEventListener<String>() { 

        public void onDataChunk(List<String> chunk) {
          for(String s : chunk) {
            sink.next(s); 
          }
        }

        public void processComplete() {
            sink.complete(); 
        }
    });
});

both sample above are from reactor offical documents , obviously , both of them have the operation sink that used to generate one by one (not sure , also have confusion in it ) , so the handle is not necessary when we need to generate datas , just use create instead of ``handle``` ?;

Main Question

Finally ， i have collect the question in summary

• Could use the create instead of handle every time?
  is there some best practice or useage in both of the operation above?

• Is it generate data step-by-step with the operation sink?
  if i have some IO operate in code before sink.nest() , it will block util the IO complate? so that is it will block for thw dowstream?

Although these samples produce similar results Flux.create has a different purpose that handle.

Flux.create could be used to create a Flux by emitting multiple elements.

@Test
void fluxCreateRange() {
    Flux<Integer> range = Flux.create(emitter -> {
        FluxSink<Integer> sink = emitter.next(0);

        for (int i = 1; i <= 3; i++) {
            sink.next(i);
        }

        sink.complete();
    });

    StepVerifier.create(range)
            .expectNext(0, 1, 2, 3)
            .verifyComplete();
}

The above code is the same as Flux.range(0, 3);

handle is used to process data as a part of the flow. The closest analog of the handle is a map. You could think about it as a combination of the map & filter. In contrast to flatMap both handle and map are synchronous function.

map - transforms the emitted item by applying a synchronous function. It provides 1:1 mapping and every item should be mapped. The only way to skip item is to throw exception and then immediately handle the error signal using onErrorResume.

handle - is more flexible and provides 0 or 1 mapping. It's possible to skip items by not emitting signal using sink.next().

In your case there is no reason to wrap user into Mono and use flatMap. Use map because mapping is 1:1.