Walk through the main Reactor factory methods (just, empty, error, fromCallable, defer, fromIterable) and when you'd reach for each.

## Why factory methods matter A `Mono`/`Flux` is a **cold, lazy blueprint** — but *how* you feed a value into it decides *when* that value is computed. The factory methods differ precisely on **eager-vs-lazy** and **single-vs-many**. ### `just` — eager, ready value ```java Mono<String> m = Mono.just(compute()); // compute() runs NOW, at assembly Flux<Integer> f = Flux.just(1, 2, 3); ``` `just` takes a value that **already exists**. The argument expression is evaluated **immediately when the line runs**, *not* at subscription. So `Mono.just(callBlockingService())` executes the blocking call eagerly and captures its *result*; if it throws, the exception escapes right there (not as an onError signal). Rule of thumb: only pass a **constant or already-held** value to `just`. ### `empty` — complete with nothing ```java Mono<User> m = Mono.empty(); // 0 items, then onComplete Flux<User> f = Flux.empty(); ``` Used for "not found" (`switchIfEmpty` targets), no-op branches, or `Mono<Void>`-style completions. ### `error` — terminate with a throwable ```java Mono<User> m = Mono.error(new NotFoundException()); ``` Emits `onError` immediately on subscription. Note: `Mono.error(new Ex())` still **constructs** the exception eagerly at assembly; to defer even the exception creation use `Mono.error(() -> new Ex())` (the supplier overload) or wrap in `defer`. ### `fromCallable` — lazy single synchronous computation ```java Mono<Config> m = Mono.fromCallable(() -> readFileBlocking()); ``` Takes a `java.util.concurrent.Callable`. The lambda runs **at subscription time**, and any thrown checked/unchecked exception is **captured and turned into onError** instead of propagating at assembly. This is the correct wrapper for **blocking or exception-throwing synchronous code** — and you typically pair it with `.subscribeOn(Schedulers.boundedElastic())` to move the blocking work off the event-loop thread. (`Mono.fromSupplier` is the same idea but takes a `Supplier` and can't throw checked exceptions.) ### `defer` — lazy assembly of the whole publisher ```java Mono<Instant> now = Mono.defer(() -> Mono.just(Instant.now())); ``` `defer` takes a `Supplier<? extends Publisher>` and invokes it **fresh for every subscriber**. Contrast with `Mono.just(Instant.now())`, where `Instant.now()` is fixed once at assembly and every subscriber sees the *same* timestamp. Use `defer` when: the source must be rebuilt per subscription, you need per-subscriber state/context, you're wrapping a factory that itself decides eagerly, or you want to defer a whole conditional pipeline. `defer` is the general-purpose "make this lazy" tool; `fromCallable` is the narrower "defer one value-producing call." ### `fromIterable` — existing collection into a Flux ```java Flux<String> f = Flux.fromIterable(List.of("a", "b", "c")); ``` Streams each element of an existing `Iterable` as `onNext` signals. Related: `Flux.fromStream` (Java `Stream`, one-shot), `Flux.fromArray`. The iterable is iterated **at subscription**, so re-subscribing re-iterates it (careful with one-shot iterables). ## The eager-vs-lazy trap (most-tested gotcha) ```java // BUG: blocking call runs eagerly at assembly, on the calling thread Mono<Data> bad = Mono.just(repository.blockingLoad()); // FIX: deferred to subscription, exceptions -> onError, offloadable Mono<Data> good = Mono.fromCallable(() -> repository.blockingLoad()) .subscribeOn(Schedulers.boundedElastic()); ``` Because `just` evaluates its argument immediately, side-effecting or blocking code inside `just(...)` defeats the whole point of reactive laziness. Interviewers love this distinction. ## Quick decision table - Constant/held value → `just` - No value, just complete → `empty` - Known failure → `error` (supplier form to defer the throwable) - Blocking/throwing synchronous call, single value → `fromCallable` (+ `subscribeOn`) - Rebuild whole publisher per subscription / per-subscriber freshness → `defer` - Existing collection → `Flux.fromIterable`