SpringReactive va WebFlux8 boʻlim · 24 savol

Spring WebFlux va Project Reactor: reactive kod qanday ishlaydi

Bu sahifa reactive dasturlash va Spring WebFlux mavzusini chuqur tushuntiradi: bloklovchi I/O qanday muammo tugʻdiradi, event loop bir nechta thread bilan minglab ulanishga qanday xizmat qiladi, `Mono` va `Flux` nima va nega subscribe qilinmaguncha hech narsa bajarilmaydi. Murakkab joylar qadamma-qadam animatsiya bilan koʻrsatilgan.

Boʻlimlar asoslardan chuqurroq mavzularga qarab ketadi: event loop va birinchi endpointʼdan backpressure, productionʼda debug qilish va WebFlux, Spring MVC yoki virtual threadʼlar orasidagi tanlovgacha. Misollar Spring Boot 3.x (Spring Framework 6, Reactor 3) va Java 21 uchun yozilgan, Spring Boot 4 da oʻzgargan joylar alohida aytilgan. Virtual threadʼlar Concurrency mavzusida, lazy pipeline gʻoyasi esa Stream API mavzusida batafsil koʻrilgan.

Har boʻlim oxirida tushunganingizni tekshiradigan savollar bor. Avval javobni oʻzingiz oʻylab koʻring, keyin oching.

1Nega reactive: bloklovchi I/O, thread-per-request va event loop

Spring MVC servisida har bir soʻrov bitta threadʼda bajariladi: Tomcat poolʼdan thread oladi va javob yozilguncha u shu soʻrovniki boʻladi. Bu — thread-per-request modeli. Kod maʼlumotlar bazasiga yoki boshqa servisga murojaat qilsa, thread javob kelguncha bloklanadi: u hech narsa qilmaydi, lekin poolʼdagi joyini band qilib turadi.

Tomcat poolʼi default holatda 200 thread. Bir vaqtda 200 ta soʻrov sekin javobni kutib qolsa, 201-soʻrov navbatda turadi, CPU esa deyarli boʻsh. Poolʼni kattalashtirish cheksiz yechim emas: platform thread — bu OS threadʼi, har biri stack uchun xotira oladi, minglab threadʼlar orasidagi context switch esa OS uchun ham qimmat.

Non-blocking I/O boshqacha ishlaydi: thread soʻrovni tarmoqqa yozadi va javobni kutmaydi. Socket tayyor boʻlganini OS oʻzi xabar qiladi — Linuxʼda epoll, macOSʼda kqueue orqali — shu paytgacha thread boshqa ulanishlar bilan ishlaydi. Tayyor eventʼlarni sikl ichida olib, ularni birma-bir qayta ishlaydigan thread — event loop. Spring Bootʼda WebFlux default holatda Reactor Netty ustida ishlaydi: event loop threadʼlari soni default holatda CPU yadrolari soniga teng, lekin kamida 4 ta.

1/7Thread-per-request: poolʼda 4 ta thread (Tomcatʼda default 200). Har bir soʻrov bitta threadʼni oladi va javob yozilguncha uni ushlab turadi.

Bu modelning bitta qatʼiy sharti bor: event loop threadʼida bloklanib boʻlmaydi. Thread-per-request modelida bitta sekin chaqiruv faqat oʻz soʻrovini sekinlashtiradi. Event loopʼda esa bitta Thread.sleep, JDBC chaqiruvi yoki sinxron fayl oʻqish shu threadʼga biriktirilgan hamma ulanishni toʻxtatib qoʻyadi; block() esa bu threadʼlarda IllegalStateException tashlaydi. Shuning uchun reactive ilovada butun yoʻl — HTTP client, maʼlumotlar bazasi drayveri, kutubxonalar — non-blocking boʻlishi kerak.

// xato: event loopʼni 1 soniya bloklaydi
@GetMapping("/slow")
Mono<String> slow() throws InterruptedException {
    Thread.sleep(1000);
    return Mono.just("ok");
}

// toʻgʻri: kutishni timer bajaradi, thread boʻsh
@GetMapping("/fast")
Mono<String> fast() {
    return Mono.delay(Duration.ofSeconds(1))
            .thenReturn("ok");
}

Reactive kod CPUʼni tezlashtirmaydi va bitta soʻrovni tezroq bajarmaydi: 100 ms kutiladigan javob baribir 100 ms da keladi. U kam thread va kam xotira bilan bir vaqtda koʻproq kutayotgan soʻrovga xizmat qiladi. Foyda I/O koʻp, CPU ishi kam boʻlgan yuklamada koʻrinadi: koʻp tashqi chaqiruvni birlashtiradigan gateway va agregator servislar, minglab ochiq ulanish — WebSocket, Server-Sent Events — va streaming. Java 21 dagi virtual threadʼlar xuddi shu muammoni boshqa yoʻl bilan hal qiladi, ularni oxirgi boʻlimda solishtiramiz.

Tushunganingizni tekshiring

Bloklovchi va non-blocking I/O farqi nimada? Reactive yondashuv qaysi muammoni hal qiladi?Javob
Qisqa javob

Bloklovchi I/Oʼda thread javob kelguncha kutib turadi va boshqa ish qilolmaydi. Non-blocking I/Oʼda thread soʻrovni yuboradi va boshqa ishga oʻtadi, javob tayyor boʻlganda unga xabar keladi. Reactive yondashuv kutish paytida threadʼlarni band qilmasdan, oz sonli thread bilan koʻp ulanishga xizmat qilish uchun kerak.

Thread-per-request modelida bir vaqtda ishlanadigan soʻrovlar soni pool oʻlchami bilan cheklanadi. Soʻrovlar vaqtining koʻp qismi tashqi javobni kutishga ketsa, threadʼlar tugaydi, CPU esa boʻsh turadi. Poolʼni kattalashtirish xotira va context switch narxini oshiradi.

Non-blocking modelda kutish threadʼga bogʻlanmaydi: soʻrovning holati obyektlarda — callbackʼlarda, publisher zanjirida — saqlanadi, thread esa faqat haqiqiy ish boʻlganda band boʻladi: maʼlumot kelganda yoki yozish kerak boʻlganda. Shuning uchun bir nechta event loop threadʼi oʻn minglab ochiq ulanishni ushlab tura oladi.

Lekin bu bitta soʻrovning tezligini oshirmaydi va CPU koʻp ishlatadigan hisob-kitobga foyda bermaydi. Foyda — kutish koʻp boʻlgan yuklamada kamroq resurs bilan koʻproq throughput va yuk ostida barqarorroq kechikish.

Event loop qanday ishlaydi? Unda bitta bloklovchi chaqiruv nima qiladi?Javob
Qisqa javob

Event loop — tayyor boʻlgan I/O eventʼlarini (yangi ulanish, kelgan maʼlumot, yozishga tayyor socket) navbat bilan qayta ishlaydigan thread. Har bir ulanish bitta event loopʼga biriktiriladi. Event loop bloklansa, unga biriktirilgan hamma ulanish shu vaqt davomida kutadi.

Netty har bir channelʼni, yaʼni ulanishni, bitta event loopʼga beradi va u yopilguncha shu threadʼda ishlanadi. Event loop sikl ichida OSʼdan tayyor eventʼlarni oladi va har biri uchun handlerʼlarni chaqiradi. Handler tez tugashi kerak: u ishni boshlab, natija keyin kelishini bildiradigan publisher qaytaradi.

Event loop threadʼida Thread.sleep(1000) chaqirilsa, oʻsha bir soniya ichida bu threadʼdagi boshqa ulanishlar maʼlumot oʻqiy ham, javob yoza ham olmaydi. 8 yadroli mashinada event loopʼlar ham 8 ta: shunday sekin chaqiruvlar 8 tasida bir vaqtda tushsa, butun server toʻxtaydi — CPU boʻsh, lekin hech kim javob olmaydi.

Reactor Netty event loop threadʼlari — reactor-http-nio-2 yoki Linuxʼda koʻpincha reactor-http-epoll-2 kabi nomli threadʼlar — Reactorʼning NonBlocking belgisini oladi. Shuning uchun ularda block() chaqirilsa, Reactor IllegalStateException tashlaydi. Thread.sleep, JDBC yoki fayl oʻqish kabi boshqa bloklovchi chaqiruvlarni esa u oʻzi sezmaydi — ularni BlockHound topadi.

2Mono, Flux, subscribe va birinchi endpoint

Project Reactor — Spring WebFlux ishlatadigan reactive kutubxona. Uning ikki asosiy turi bor: Mono<T> — koʻpi bilan bitta element, u qiymat bilan, boʻsh holda yoki xato bilan tugaydi; Flux<T> — 0 dan cheksizgacha elementlar ketma-ketligi, keyin tugash yoki xato. Ikkalasi ham Reactive Streams spetsifikatsiyasidagi Publisher interfeysini implement qiladi.

TurNechta elementMisol
Mono<T>0 yoki 1foydalanuvchini ID boʻyicha topish, save natijasi, bitta HTTP javob
Mono<Void>element yoʻq, faqat tugash yoki xatodelete, javobsiz yozish, «ish tugadi» signali
Flux<T>0…N, cheksiz ham boʻlishi mumkinsoʻrov natijasidagi qatorlar, eventʼlar oqimi, Flux.interval

Reactive Streams toʻrtta interfeysdan iborat: Publisher, Subscriber, Subscription va Processor. Shartnoma qatʼiy: subscriber avval onSubscribe(subscription) oladi, keyin request(n) bilan nechta element olishga tayyorligini aytadi, publisher esa soʻralganidan koʻp bermaydi — onNext koʻpi bilan n marta. Oxirida koʻpi bilan bitta terminal signal keladi: onComplete yoki onError, undan keyin boshqa signal boʻlmaydi. Xuddi shu interfeyslar Java 9 dan beri java.util.concurrent.Flow ichida ham bor; Reactor org.reactivestreams paketidagisini ishlatadi va ular orasida adapter bor.

1/6Zanjir qurildi: Flux.range(1, 3).map(i -> i * 10). Hech narsa bajarilmadi — bu faqat tavsif, unga hali hech kim subscribe qilmagan.

Eng muhim gʻoya: Flux.range(1, 3).map(...).filter(...) yozilganda hech narsa bajarilmaydi — faqat zanjirning tavsifi quriladi, bu assembly bosqichi. Ish subscribe() chaqirilganda boshlanadi: subscribe signali manbagacha yuqoriga koʻtariladi, maʼlumot esa pastga, subscriber tomon oqadi. Bu Stream APIʼdagi lazy pipelineʼga oʻxshaydi, lekin farq bor: stream bir martalik, Fluxga esa qayta-qayta subscribe qilish mumkin va har bir subscribe odatda ishni boshidan boshlaydi.

Flux<Integer> flux = Flux.range(1, 3)
        .map(i -> i * 10)
        .doOnNext(i -> System.out.println("map " + i));
// hali hech narsa chiqmadi

flux.subscribe(
        i -> System.out.println("onNext " + i),
        err -> System.out.println("onError " + err),
        () -> System.out.println("onComplete"));

WebFlux ilovasida subscribe()ni deyarli hech qachon oʻzingiz chaqirmaysiz: controller Mono yoki Flux qaytaradi, WebFlux unga subscribe qiladi va kelgan elementlarni HTTP javobga yozadi. Siz chaqiradigan joylar — test, main metod yoki ataylab fire-and-forget qilinadigan fon ishi.

Endpoint ikki xil yoziladi. Birinchisi — Spring MVCʼdagi kabi @RestController: annotatsiyalar bir xil, faqat metod Mono yoki Flux qaytaradi. Ikkinchisi — functional routing: marshrutlar RouterFunction beanʼida kod bilan yoziladi, handler esa HandlerFunction — ServerRequest olib, Mono<ServerResponse> qaytaradigan funksiya.

@RestController
@RequestMapping("/users")
class UserController {
    private final UserService users;

    UserController(UserService users) {
        this.users = users;
    }

    @GetMapping("/{id}")
    Mono<User> get(@PathVariable long id) {
        return users.find(id);
    }

    @GetMapping
    Flux<User> all() {
        return users.findAll();
    }
}
@Bean
RouterFunction<ServerResponse> routes(UserHandler h) {
    return RouterFunctions.route()
            .GET("/users/{id}", h::get)
            .GET("/users", h::all)
            .build();
}

// UserHandler ichida
Mono<ServerResponse> get(ServerRequest req) {
    long id = Long.parseLong(req.pathVariable("id"));
    Mono<ServerResponse> notFound =
            ServerResponse.notFound().build();
    return users.find(id)
            .flatMap(u -> ServerResponse.ok()
                    .bodyValue(u))
            .switchIfEmpty(notFound);
}

Ikkala usul ham bir xil infratuzilmada ishlaydi: spring-boot-starter-webflux default holatda Reactor Netty serverini koʻtaradi, DispatcherHandler — DispatcherServletning reactive juftligi — esa soʻrovni mos handlerʼga yuboradi. Classpathʼda Spring MVC ham boʻlsa, Spring Boot servlet ilovasini tanlaydi: WebClient ishlayveradi, lekin server Tomcat ustidagi Spring MVC boʻladi. Buni spring.main.web-application-type=reactive bilan oʻzgartirish mumkin.

Tushunganingizni tekshiring

Mono va Flux farqi nima? Nega Mono<List<T>> emas, Flux<T> qaytariladi?Javob
Qisqa javob

Mono — koʻpi bilan bitta element, Flux — istalgancha element. Flux<T> elementlarni kelishi bilan bittalab beradi, Mono<List<T>> esa hammasi yigʻilguncha kutadi va butun listni xotirada ushlab turadi.

Ikkalasi ham bir xil signallarni beradi: onNext, keyin onComplete yoki onError. Farq — kontraktda: Mono turini koʻrgan dasturchi natija bitta boʻlishini biladi va Mono operatorlari shunga moslangan (zipWhen, flatMapMany, toFuture). Mono<Void> faqat ish tugaganini yoki xatoni bildiradi.

Flux<T> natija katta yoki cheksiz boʻlganda muhim: elementlar kelishi bilan qayta ishlanadi va ularning tezligini backpressure orqali subscriber boshqaradi. collectList() bilan Mono<List<T>>ga aylantirish mumkin, lekin bunda hamma element xotiraga yigʻiladi va birinchi natija ham oxirgisi bilan birga keladi.

HTTP javobda farq media typeʼga bogʻliq. application/json boʻlsa, Flux bitta JSON massiv boʻlib yoziladi: Spring Framework 6 dan beri elementlar listga yigʻilmaydi, kelishi bilan massivga yoziladi, lekin javob baribir bitta hujjat — brauzer yoki oddiy JSON parser uni oxirida oʻqiydi. Har bir element alohida hujjat boʻlib, kelishi bilan ishlanishi uchun streaming media type kerak: application/x-ndjson yoki text/event-stream.

Nega subscribe qilinmaguncha hech narsa bajarilmaydi? Kim subscribe qiladi?Javob
Qisqa javob

Operatorlar faqat zanjirni quradi: har biri oldingi publisherʼni oʻraydigan yangi publisher qaytaradi. Ish subscribe() chaqirilganda boshlanadi. WebFlux ilovasida controller qaytargan Mono yoki Fluxga WebFluxʼning oʻzi subscribe qiladi.

flux.map(f) hech narsa hisoblamaydi: u manba va funksiyani saqlaydigan yangi publisher obyektini yaratadi. subscribe() chaqirilganda zanjir teskari tomonga oʻraladi: har bir operator oʻzidan yuqoridagisiga subscribe qiladi, manba onSubscribe beradi va request(n) pastdan yuqoriga koʻtariladi. Shundan keyingina maʼlumot pastga oqa boshlaydi.

Shuning uchun natijasi ishlatilmagan reactive chaqiruv jimgina hech narsa qilmaydi. Masalan, repository.save(user); qatorining natijasi tashlab yuborilsa, bazaga hech narsa yozilmaydi: save faqat Mono qaytardi, unga hech kim subscribe qilmadi.

Controller ichida natijani kutmasdan subscribe() chaqirish ham xato: shunda ikkinchi, mustaqil bajarilish boshlanadi — soʻrov tugasa yoki client uzilsa ham u davom etadi, xatosi javobga yetib bormaydi, testda esa uni kutib boʻlmaydi. Har bir subscribe — alohida bajarilish: bitta Mono<User>ga ikki marta subscribe qilinsa, WebClient ikki HTTP soʻrov yuboradi.

// xato: natija tashlab yuborildi
public Mono<Void> register(User u) {
    repository.save(u); // hech narsa yozilmaydi
    return mailer.sendWelcome(u);
}

// toʻgʻri: hammasi bitta zanjirda
public Mono<Void> register(User u) {
    return repository.save(u)
            .flatMap(mailer::sendWelcome);
}
Mono.just, Mono.fromCallable va Mono.defer farqi nima?Javob
Qisqa javob

Mono.just(x) qiymatni zanjir qurilayotgan paytda oladi: x darhol, subscribeʼdan oldin hisoblanadi. fromCallable va defer esa ishni har bir subscribe paytiga qoldiradi: fromCallable qiymatni hisoblaydigan funksiyani, defer esa yangi Mono yaratadigan funksiyani oladi.

Mono.just(loadUser()) yozilganda Java avval loadUser()ni chaqiradi — bu oddiy metod argumenti — va tayyor qiymatni Monoga oʻraydi. Natija hech kim subscribe qilmasa ham hisoblanadi, har bir subscriber esa aynan oʻsha qiymatni oladi. loadUser() exception tashlasa, u onError signali emas, zanjir qurilayotgan joyda oddiy exception boʻlib chiqadi.

Mono.fromCallable(() -> loadUser()) funksiyani har bir subscribe paytida chaqiradi, uning exceptionʼini onErrorga aylantiradi, null qaytsa esa boʻsh Mono beradi. Bloklovchi chaqiruvni reactive zanjirga olib kirish uchun aynan shu ishlatiladi. Mono.defer(() -> ...) esa funksiyadan tayyor Mono oladi: masalan, subscribe paytidagi holatga qarab har xil zanjir qurish uchun.

Shu tuzoq switchIfEmpty, defaultIfEmpty, onErrorReturn va thenga beriladigan argumentlarda ham bor: switchIfEmpty(loadFromDb()) yozilsa, loadFromDb() metodi zanjir qurilayotganda chaqiriladi — natija kerak boʻlmasa ham. Metod Mono qaytarishdan oldin oʻzi ish bajarsa yoki qimmat boʻlsa, chaqiruv Mono.defer(() -> loadFromDb()) bilan oʻraladi.

Mono<Long> eager = Mono.just(System.nanoTime());
Mono<Long> lazy = Mono.fromCallable(System::nanoTime);

eager.block().equals(eager.block()); // true
lazy.block().equals(lazy.block());   // false
WebFluxʼda annotatsiyali controller va functional routing farqi nima? Qaysi birini tanlaysiz?Javob
Qisqa javob

Ikkalasi bir xil server va bir xil reactive turlar ustida ishlaydi, farq — marshrut qanday yozilishida. @RestControllerda marshrut annotatsiyada turadi, functional routingʼda esa RouterFunction beanʼida kod bilan yoziladi va HandlerFunction ServerRequestdan Mono<ServerResponse> qaytaradi.

Annotatsiyali controller Spring MVCʼdan oʻtayotgan jamoa uchun tanish: @PathVariable, @RequestBody, @Valid, @ExceptionHandler xuddi shunday ishlaydi. Metod Mono<T> yoki Flux<T> qaytaradi, @RequestBody Mono<T> esa body toʻliq kelishini kutmasdan zanjir qurishga imkon beradi.

Functional routingʼda hamma narsa koʻz oldida: marshrutlar bir joyda, predicateʼlar va filterʼlar kod bilan ulanadi, annotatsiya qidirish yoʻq. Kichik servislar va marshrutlari dinamik quriladigan holatlar uchun qulay, Kotlin DSL bilan ayniqsa ixcham. Kamchiligi — argumentlarni ajratish va validatsiyani qoʻlda yozish kerak.

Ikkala holatda ham handler default holatda event loop threadʼida chaqiriladi, shuning uchun uning ichida bloklanib boʻlmaydi. Yana bir nozik joy: Mono<User> boʻsh tugasa, controller 200 status va boʻsh body qaytaradi — 404 kerak boʻlsa, uni switchIfEmpty bilan oʻzingiz berasiz.

@GetMapping("/{id}")
Mono<User> get(@PathVariable long id) {
    return users.find(id)
            .switchIfEmpty(Mono.error(
                    new ResponseStatusException(
                            HttpStatus.NOT_FOUND)));
}

3Operatorlar: map, flatMap, concatMap, zip va merge

Operator — publisherʼni oʻrab, yangi publisher qaytaradigan metod. Zanjirdagi har bir operator yuqoridagisidan signallarni oladi, ularni oʻzgartiradi va pastga beradi. Eng koʻp ishlatiladigan operatorlar ikki guruhga boʻlinadi: elementni sinxron oʻzgartiradiganlar va har bir element uchun yangi asinxron ish boshlaydiganlar.

OperatorNima qiladiTartib
map(f)T → R, sinxron funksiyasaqlanadi
filter(p)shartdan oʻtmagan elementni tashlaydisaqlanadi
flatMap(f)T → Publisher<R>: ichki publisherʼlarga bir vaqtda subscribe qiladisaqlanmaydi: qaysi natija oldin tayyor boʻlsa, oʻsha oldin chiqadi
concatMap(f)ichki publisherʼlarni bittalab, oldingisi tugagach boshlaydisaqlanadi, parallellik yoʻq
flatMapSequential(f)hammasini bir vaqtda boshlaydi, natijani manba tartibida beradisaqlanadi, erta kelganlari buferda kutadi
zip(a, b)har bir manbadan bittadan olib juftlaydijuftlar tartibida
merge(a, b)manbalar elementlarini kelishi bilan aralashtiradikelish vaqti boʻyicha
concat(a, b)avval birinchisi tugaydi, keyin ikkinchisiga subscribe qiladimanbalar ketma-ket

map ichidagi funksiya oddiy qiymat qaytaradi va darhol ishlaydi. Funksiya oʻzi Mono qaytarsa — masalan, boshqa servisni chaqirsa — map Flux<Mono<R>> beradi va ichki Monoʼlarga hech kim subscribe qilmaydi. Bunday holatda flatMap kerak: u ichki publisherʼga subscribe qiladi va uning elementlarini umumiy oqimga chiqaradi. Bu Stream APIʼdagi flatMap bilan bir xil gʻoya, faqat bu yerda ichki ish asinxron va vaqt boʻyicha choʻziladi.

flatMap default holatda bir vaqtda 256 tagacha ichki publisherʼga subscribe qiladi, natijalar esa tayyor boʻlish tartibida chiqadi. Masalan, uchta chaqiruv 300, 100 va 200 ms davom etsa:

// fetch(1) 300 ms, fetch(2) 100 ms, fetch(3) 200 ms
Flux<Integer> ids = Flux.just(1, 2, 3);

// subscribe qilinganda chiqish tartibi va vaqti:
ids.flatMap(this::fetch);           // 2, 3, 1 ≈ 300 ms
ids.concatMap(this::fetch);         // 1, 2, 3 ≈ 600 ms
ids.flatMapSequential(this::fetch); // 1, 2, 3 ≈ 300 ms

zip bir nechta mustaqil ishning natijasini kutib, ularni birlashtiradi: masalan, foydalanuvchi va uning buyurtmalarini parallel olib, bitta javob qurish. merge esa bir xil turdagi bir nechta oqimni bitta oqimga aralashtiradi, concat — ularni ketma-ket ulaydi.

Tushunganingizni tekshiring

map va flatMap farqi nima?Javob
Qisqa javob

map har bir elementni sinxron funksiya bilan boshqa qiymatga aylantiradi. flatMap har bir element uchun yangi publisher yaratadi, unga subscribe qiladi va uning natijalarini umumiy oqimga chiqaradi. Funksiya Mono yoki Flux qaytarsa — flatMap.

map(user -> user.name()) — oddiy oʻzgartirish: chaqiruv tez va bloklamaydi. map(id -> client.get(id)) esa Flux<Mono<User>> beradi: ichki Monoʼlarga hech qachon subscribe qilinmaydi va HTTP soʻrovlar ketmaydi. Tur Mono<Mono<...>> yoki Flux<Mono<...>> boʻlib qolsa, deyarli doim flatMap kerak edi.

flatMap ichki publisherʼlarga darhol, bir vaqtda subscribe qiladi — default holatda 256 tagacha, bu concurrency parametri. Shuning uchun natijalar manba tartibida emas, tayyor boʻlish tartibida chiqadi. Oʻn ming ID boʻyicha tashqi servisni chaqirsangiz, bir vaqtda 256 ta soʻrov ketadi: servisni haddan tashqari yuklamaslik uchun flatMap(f, 8) kabi chegara beriladi.

Monoda flatMap bitta ichki Mono beradi, shuning uchun tartib muammosi yoʻq. Monodan Flux olish uchun esa flatMapMany ishlatiladi.

Flux<Order> orders = userIds
        // bir vaqtda koʻpi bilan 8 ta soʻrov
        .flatMap(id -> orderClient.findByUser(id), 8);
flatMap, concatMap va flatMapSequential qachon ishlatiladi?Javob
Qisqa javob

flatMap — tartib muhim boʻlmasa va ishlar parallel ketishi kerak boʻlsa. concatMap — ketma-ketlik muhim boʻlsa: keyingi ichki ish oldingisi tugagandan keyin boshlanadi. flatMapSequential — parallel ishlash ham, manba tartibi ham kerak boʻlsa.

concatMap bir vaqtda faqat bitta ichki publisherʼga subscribe qiladi. Bitta hisobga ketma-ket yozish, eventʼlarni kelgan tartibda qayta ishlash yoki tashqi tizimga bittadan murojaat qilish kerak boʻlgan joyda bu toʻgʻri tanlov. Narxi — umumiy vaqt: uchta 100 ms li chaqiruv 300 ms oladi.

flatMapSequential ichki publisherʼlarga flatMap kabi darhol subscribe qiladi, lekin natijalarni manba tartibida chiqaradi: erta tugagan natija oldingilari tugaguncha buferda kutadi. Bitta ichki ish juda sekin boʻlsa, undan keyingi hamma natijalar buferda yigʻilib qoladi.

Tanlash uchun ikki savol beriladi: natija tartibi muhimmi va ichki ishlar bir-biriga bogʻliqmi. Bogʻliq boʻlmasa va tartib kerak boʻlmasa — flatMap, tartib kerak boʻlsa — flatMapSequential, ishlar qatʼiy ketma-ket bajarilishi shart boʻlsa — concatMap.

zip va merge farqi nima? Mono.zipning qanday tuzogʻi bor?Javob
Qisqa javob

zip har bir manbadan bittadan element kutib, ularni juftlaydi yoki funksiya bilan birlashtiradi. merge bir nechta oqim elementlarini kelishi bilan bitta oqimga aralashtiradi. Mono.zipda manbalardan biri boʻsh tugasa, natija ham boʻsh boʻladi.

Mono.zip(userMono, ordersMono) ikkala manbaga bir vaqtda subscribe qiladi va ikkalasi ham qiymat berganda Tuple2 chiqaradi. Mustaqil chaqiruvlarni parallel bajarishning odatiy usuli shu: umumiy vaqt eng sekin chaqiruvga teng, yigʻindisiga emas. Manbalardan biri xato bersa, qolganlari cancel qilinadi va natija xato bilan tugaydi.

Tuzoq: manbalardan biri elementsiz tugasa, zip qolganlarini cancel qiladi va natija ham boʻsh tugaydi — xato ham, qiymat ham yoʻq. Controllerʼda bu boʻsh javob boʻlib koʻrinadi. Ixtiyoriy maʼlumot uchun manbaga defaultIfEmpty(...) qoʻshiladi.

Flux.zip eng qisqa manba bilan tugaydi: uch va ikki elementli oqimlardan ikkita juft chiqadi. merge esa hamma manbani birga oʻqiydi — masalan, bir nechta navbatdan kelgan eventʼlarni bitta oqimga yigʻish uchun; manbalar ketma-ket kelishi kerak boʻlsa, concat ishlatiladi.

Mono<Profile> profile = Mono.zip(
        users.find(id),
        orders.findByUser(id).collectList(),
        // reyting boʻlmasa ham profil chiqsin
        ratings.find(id).defaultIfEmpty(Rating.NONE))
    .map(t -> new Profile(
            t.getT1(), t.getT2(), t.getT3()));

4Xatolar, retry va timeout

Reactive zanjirda exception chaqiruvchiga throw boʻlib koʻtarilmaydi — u onError signaliga aylanadi va pastga, subscriber tomon oqadi. Operator ichidagi lambda exception tashlasa, Reactor uni ushlaydi, manbaga cancel yuboradi va pastga onError beradi. onError — terminal signal: undan keyin bu oqimdan boshqa element kelmaydi.

Shuning uchun Flux.just(1, 2, 0, 4).map(x -> 10 / x) 10 va 5 qiymatlarini beradi va xato bilan tugaydi — 4 hech qachon ishlanmaydi. Xatoni ushlaydigan operatorlar oqimni davom ettirmaydi, ular xatodan keyin nima boʻlishini almashtiradi:

OperatorNima qiladi
onErrorReturn(x)xato oʻrniga bitta qiymat beradi va oqimni tugatadi
onErrorResume(e -> pub)xato oʻrniga boshqa publisherʼga oʻtadi: zaxira manba, keshdagi qiymat yoki boshqa xato
onErrorMap(e -> e2)xato turini almashtiradi, masalan past darajadagi exceptionʼni domain exceptionʼga
doOnError(e -> ...)xatoni oʻzgartirmaydi: log yoki metrika uchun
retry(n), retryWhen(spec)manbaga qayta subscribe qiladi: ish boshidan takrorlanadi
timeout(d)belgilangan vaqtda keyingi signal kelmasa, manbani cancel qiladi va TimeoutException beradi

Xato faqat bitta elementga taʼsir qilishi kerak boʻlsa, u ichki publisherʼda ushlanadi: flatMap(x -> call(x).onErrorResume(e -> Mono.empty())) — xato bergan element tushib qoladi, qolganlari ishlanaveradi. onErrorContinue operatori ham bor, lekin u yuqoridagi operatorlar bilan kutilmagan tarzda ishlaydi va Reactor hujjatlari uning oʻrniga ichki publisherʼda onErrorResume ishlatishni tavsiya qiladi.

Tashqi chaqiruvda eng xavfli xato — javob umuman kelmasligi: zanjir abadiy kutadi, ulanish va xotira band boʻlib qoladi. timeout operatoridan tashqari tarmoq darajasidagi timeoutʼlar ham bor. Reactor Netty HttpClientida connect timeout default holatda 30 soniya, responseTimeout esa default holatda umuman qoʻyilmagan:

HttpClient http = HttpClient.create()
        .option(ChannelOption.CONNECT_TIMEOUT_MILLIS,
                2_000)
        .responseTimeout(Duration.ofSeconds(3));

WebClient client = builder
        .baseUrl("https://prices.example.com")
        .clientConnector(
                new ReactorClientHttpConnector(http))
        .build();

Spring Boot 3.5 da auto-configured WebClient.Builder uchun spring.http.reactiveclient.connect-timeout va read-timeout xossalari bor; Spring Boot 4 da ular blocking va reactive clientʼlar uchun umumiy spring.http.clients.connect-timeout va read-timeout boʻldi. Spring Boot 4 da auto-configured WebClient.Builder uchun spring-boot-starter-webclient alohida qoʻshiladi. Tarmoq timeoutʼlari bitta urinishni cheklaydi, operator darajasidagi timeout esa butun amalga — retry va pauzalar bilan birga — chegara qoʻyishi mumkin.

Tushunganingizni tekshiring

Reactive zanjirda xato qanday tarqaladi? onErrorResume, onErrorReturn va onErrorMap farqi nima?Javob
Qisqa javob

Exception onError signaliga aylanadi va pastga tarqaladi, manba esa cancel qilinadi: oqim shu yerda tugaydi. onErrorReturn xato oʻrniga bitta qiymat beradi, onErrorResume zaxira publisherʼga oʻtadi, onErrorMap esa xatoni boshqa xatoga almashtiradi — oqim baribir xato bilan tugaydi.

Reactive Streams shartnomasiga koʻra onError va onComplete — terminal signallar. Xatodan keyin oqim tiklanmaydi: onErrorResume asl manbani davom ettirmaydi, uning oʻrniga yangi publisherʼga subscribe qiladi. Flux.just(1, 2, 0, 4).map(x -> 10 / x).onErrorResume(e -> Flux.just(-1)) natijasi — 10, 5, -1, 4 esa yoʻqoladi.

onErrorMap qatlamlar chegarasida foydali: maʼlumotlar bazasi yoki HTTP client exceptionʼini UserNotFoundException kabi domain xatosiga aylantirib, uni controller darajasida @ExceptionHandler bilan javobga aylantirish mumkin. Bu operatorlarga exception klassi yoki predicate ham beriladi, shunda faqat kerakli xatolar ushlanadi.

Xatoni hech kim ushlamasa, u subscriberʼga yetadi. WebFluxʼda subscriber — server: controller xatosi @ExceptionHandler va WebExceptionHandlerʼlarga tushadi va 500 yoki mos status boʻladi. subscribe()ga xato handler berilmagan boʻlsa, Reactor xatoni ErrorCallbackNotImplemented bilan log qiladi va u yoʻqolib ketadi.

Mono<User> user = repository.findById(id)
        .switchIfEmpty(Mono.error(
                new UserNotFoundException(id)))
        .onErrorMap(DataAccessException.class,
                e -> new StorageException(e));
retryWhen va timeout qanday ishlaydi? Nega backoff kerak va timeout qayerga qoʻyiladi?Javob
Qisqa javob

retry va retryWhen xato kelganda manbaga qayta subscribe qiladi, yaʼni ishni boshidan takrorlaydi: WebClient uchun bu yangi HTTP soʻrov. Retry.backoff urinishlar orasidagi pauzani har safar ikki baravar oshiradi va jitter qoʻshadi. timeout retryWhendan yuqorida boʻlsa — har bir urinishga, pastda boʻlsa — hammasiga umumiy chegara boʻladi.

Retry faqat cold publisherʼda maʼnoga ega: qayta subscribe ishni qayta boshlashi kerak. WebClient chaqiruvi va R2DBC soʻrovi shunday — har subscribeʼda yangi soʻrov ketadi. retry(3) jami toʻrt marta subscribe qiladi: birinchi urinish va uchta qayta urinish. Retry oʻzidan yuqoridagi butun zanjirni takrorlaydi, shuning uchun uni qayerga qoʻyish muhim.

Darhol qayta urinish xavfli: servis yuk ostida qiynalayotgan boʻlsa, minglab clientʼning bir vaqtdagi retryʼi uni butunlay yiqitadi. Retry.backoff(3, Duration.ofMillis(200)) pauzani 200, 400, 800 ms qilib oshiradi va default holatda ±50% jitter qoʻshadi, shunda clientʼlar bir lahzada qaytib kelmaydi. maxBackoff bilan yuqori chegara qoʻyiladi, filter bilan esa faqat vaqtinchalik xatolarda qayta uriniladi: timeout yoki 503 javobidan keyin qayta urinish mumkin, 400 va 404 javoblarini takrorlashdan esa foyda yoʻq.

Urinishlar tugasa, Reactor asl xatoni RetryExhaustedException ichiga oʻrab beradi, xabari — Retries exhausted: 3/3; uni Exceptions.isRetryExhausted(e) bilan aniqlash mumkin. Asl xatoning oʻzi kerak boʻlsa, onRetryExhaustedThrow qoʻshiladi. Faqat idempotent amallarni qayta urinish mumkin: POST /paymentsni retry qilish ikki marta toʻlovga olib kelishi mumkin.

timeout faqat kutishni toʻxtatmaydi, yuqoriga cancel ham yuboradi, shuning uchun kechikkan javob kutilmaydi va resurslar boʻshatiladi. Vaqt default holatda Schedulers.parallel() timeri bilan oʻlchanadi, xato signali ham parallel threadʼida keladi. timeout(d, fallback) varianti xato oʻrniga zaxira publisherʼga oʻtadi.

Mono<Price> price = client.get()
        .uri("/prices/{id}", id)
        .retrieve()
        .bodyToMono(Price.class)
        // har bir urinishga 2 soniya
        .timeout(Duration.ofSeconds(2))
        .retryWhen(Retry
                .backoff(3, Duration.ofMillis(200))
                .maxBackoff(Duration.ofSeconds(2))
                .filter(this::isTransient)
                .onRetryExhaustedThrow(
                        (spec, rs) -> rs.failure()))
        .onErrorResume(e -> cache.lastKnown(id));

boolean isTransient(Throwable e) {
    if (e instanceof WebClientResponseException r) {
        return r.getStatusCode().is5xxServerError();
    }
    return e instanceof WebClientRequestException
            || e instanceof TimeoutException;
}

5Schedulerʼlar, bloklovchi kod va R2DBC

Reactor oʻzi thread yaratmaydi va threadʼni almashtirmaydi — buni faqat operator yoki scheduler aniq soʻraganda qiladi. Default holatda operator signal kelgan threadʼda bajariladi: Flux.range(1, 3).map(...).subscribe() main threadʼda ishlaydi, WebClient javobidan keyingi operatorlar esa Netty event loop threadʼida. delayElements va interval kabi vaqt operatorlari default holatda Schedulers.parallel()da ishlaydi va zanjirning qolgan qismi ham oʻsha threadʼda davom etadi.

SchedulerNima uchunThreadʼlar
Schedulers.parallel()CPU ishi, qisqa non-blocking vazifalaryadrolar sonicha, NonBlocking
Schedulers.boundedElastic()bloklovchi chaqiruvlar: JDBC, fayl, eski SDKdefault holatda yadrolar × 10 tagacha, har biriga 100 000 tagacha navbatdagi vazifa; 60 soniya ishlatilmagan thread yopiladi
Schedulers.single()bitta umumiy thread kerak boʻlganda1 ta, NonBlocking
Schedulers.immediate()threadʼni almashtirmaydijoriy thread
Schedulers.fromExecutorService(e)oʻz executorʼingizexecutorʼga bogʻliq

Threadʼni almashtirish uchun ikki operator bor. publishOn(s) oʻzidan keyingi operatorlarni — zanjirning pastki qismini — s threadʼiga oʻtkazadi. subscribeOn(s) esa subscribe jarayonini, demak manbaning ishini sga oʻtkazadi; u zanjirning qayerida turishidan qatʼi nazar manbaga taʼsir qiladi.

1/5Zanjir: manba, map, publishOn(parallel()), yana map va oxirida subscribeOn(boundedElastic()). subscribe() main threadʼda chaqirildi.

Bloklovchi kodni ishlatish shart boʻlsa — eski SDK, JDBC, fayl tizimi — uni Mono.fromCallable bilan oʻrab, subscribeOn(Schedulers.boundedElastic()) bilan event loopʼdan chiqariladi. Bu muammoni yashiradi, lekin yoʻq qilmaydi: endi bir vaqtdagi bloklovchi chaqiruvlar soni boundedElastic chegarasi va JDBC pool oʻlchami bilan cheklanadi, xuddi thread-per-request modelidagi kabi. Reactor 3.6 dan Java 21 da reactor.schedulers.defaultBoundedElasticOnVirtualThreads=true system property bilan boundedElastic virtual threadʼlarda ishlaydi.

Toʻgʻri yechim — non-blocking drayver. Relational bazalar uchun bu R2DBC: Reactive Relational Database Connectivity, JDBCʼning reactive muqobili. Drayverlar PostgreSQL, MySQL, MariaDB, SQL Server, Oracle va H2 uchun bor. Spring Boot spring-boot-starter-data-r2dbc bilan ConnectionFactory, r2dbc-pool connection poolʼi (default holatda 10 ta connection), DatabaseClient va Spring Data R2DBC repositoryʼlarini sozlaydi:

interface UserRepository
        extends ReactiveCrudRepository<User, Long> {

    Flux<User> findByCity(String city);
}

Mono<Long> deactivate(long id) {
    return db.sql("UPDATE users SET active = false"
                    + " WHERE id = :id")
            .bind("id", id)
            .fetch()
            .rowsUpdated();
}

Tushunganingizni tekshiring

publishOn va subscribeOn farqi nima?Javob
Qisqa javob

publishOn oʻzidan pastdagi operatorlarni boshqa schedulerʼga oʻtkazadi: undan keyingi onNext signallari yangi threadʼda keladi. subscribeOn subscribe jarayonini boshqa threadʼga oʻtkazadi, shuning uchun manba oʻsha threadʼda ishlay boshlaydi — operator zanjirning qayerida turganidan qatʼi nazar.

Signallar ikki yoʻnalishda yuradi: subscribe va request — pastdan yuqoriga, maʼlumot — yuqoridan pastga. subscribeOn birinchi yoʻnalishga taʼsir qiladi: subscribe signali manbaga subscribeOn bergan threadʼda yetib boradi va manba elementlarni shu threadʼda chiqaradi. publishOn ikkinchisiga taʼsir qiladi: u elementlarni navbatga qoʻyadi va pastga boshqa threadʼdan beradi.

Bitta zanjirda bir nechta subscribeOn boʻlsa, manbaga eng yaqini — yaʼni eng yuqoridagisi — gʻolib chiqadi. publishOn esa har safar oʻzi turgan joydan boshlab threadʼni almashtiradi. subscribeOn manba bloklovchi boʻlganda kerak — Mono.fromCallable ichidagi JDBC — publishOn esa zanjirning bir qismini, masalan ogʻir hisob-kitobni, boshqa threadʼga koʻchirish uchun.

Manba oʻzi threadʼni almashtirsa — WebClient javobi Netty threadʼida keladi, Mono.delay parallelda — subscribeOn elementlar qaysi threadʼda kelishini oʻzgartirmaydi: u faqat subscribe qilish joyini koʻchiradi. publishOn esa bunday holatda ham pastki qismni oʻz threadʼiga oʻtkazadi.

Flux.range(1, 2)
        .map(i -> log("map1", i))  // boundedElastic-1
        .publishOn(Schedulers.parallel())
        .map(i -> log("map2", i))  // parallel-1
        .subscribeOn(Schedulers.boundedElastic())
        .subscribe();
WebFlux ilovasida bloklovchi kutubxonani qanday ishlatish kerak?Javob
Qisqa javob

Chaqiruvni Mono.fromCallable(...) bilan oʻrab, subscribeOn(Schedulers.boundedElastic()) bilan event loopʼdan tashqariga chiqarish kerak. Natijani block() bilan kutish emas: Reactor buni non-blocking threadʼlarda IllegalStateException bilan taqiqlaydi.

fromCallable chaqiruvni subscribe paytiga qoldiradi va uning exceptionʼini onErrorga aylantiradi, subscribeOn esa uni boundedElastic threadʼida bajaradi. Zanjirning qolgan qismi ham oʻsha threadʼda davom etadi; javobni tarmoqqa yozishni WebFlux baribir Nettyʼga topshiradi.

boundedElastic — ataylab cheklangan pool: default holatda yadrolar × 10 thread va har biriga 100 000 tagacha navbatdagi vazifa. Bloklovchi chaqiruvlar koʻpaysa, ular navbatda kutadi, navbat ham toʻlsa, vazifa RejectedExecutionException bilan rad etiladi. Haqiqiy tor joy esa koʻpincha boshqa yerda: HikariCP poolʼi default holatda 10 ta connection.

block(), blockFirst() va blockLast() Reactorʼning NonBlocking threadʼlarida — parallel, single va Reactor Netty event loopʼlarida — chaqirilsa, Reactor odatda IllegalStateException tashlaydi: «block()/blockFirst()/blockLast() are blocking, which is not supported in thread reactor-http-nio-2». boundedElasticda esa block() ishlaydi, lekin u ham threadʼni band qiladi. Reactive va bloklovchi kod chegarasidagi bitta joydan tashqarida block() deyarli doim xato belgisi.

Mono<Report> report(long id) {
    return Mono.fromCallable(() -> legacy.load(id))
            .subscribeOn(Schedulers.boundedElastic())
            .map(Report::from);
}
Nega WebFluxʼda JDBC event loopʼni bloklaydi? R2DBC nima beradi va uning cheklovlari qanday?Javob
Qisqa javob

JDBC — sinxron API: executeQuery natija kelguncha chaqirgan threadʼni ushlab turadi, WebFluxʼda bu koʻpincha event loop threadʼi. R2DBC — relational bazalar uchun non-blocking API: soʻrov Publisher qaytaradi va thread kutmaydi. Lekin Spring Data R2DBC ORM emas: unda relationʼlar, lazy loading va dirty checking yoʻq.

JPA yoki JdbcTemplateni controllerʼdan toʻgʻridan-toʻgʻri chaqirish ishlaydi, lekin har bir soʻrov event loopʼni soʻrov vaqti davomida toʻxtatadi va yuk ostida server qotib qoladi. boundedElasticga chiqarish bilan ishlatsa boʻladi, faqat unda WebFluxʼning asosiy foydasi — kam thread — yoʻqoladi.

Spring Data R2DBC ReactiveCrudRepository beradi: findById — Mono<T>, findAll — Flux<T>, save — Mono<T>; metod nomidan soʻrov yasash va @Query ham ishlaydi. Murakkabroq SQL uchun DatabaseClient va R2dbcEntityTemplate bor.

Cheklovlar. Entityʼlar orasida @OneToMany kabi bogʻlanishlar yoʻq: bogʻliq maʼlumot alohida soʻrov bilan olinadi va zip yoki flatMap bilan yigʻiladi. Persistence context va dirty checking yoʻq — oʻzgarish faqat save bilan yoziladi. save default holatda entity yangimi yoki yoʻqligini id boʻyicha aniqlaydi: id qoʻlda berilgan boʻlsa, INSERT emas, UPDATE ketadi — buning uchun Persistable yoki R2dbcEntityTemplate.insert ishlatiladi. Flyway va Liquibase JDBC orqali ishlaydi, shuning uchun migratsiya uchun JDBC drayver ham kerak boʻladi.

Reactive tranzaksiya qanday ishlaydi? @Transactional va TransactionalOperator farqi nima?Javob
Qisqa javob

@Transactional Mono yoki Flux qaytaradigan metodda ham ishlaydi: Spring ReactiveTransactionManager — R2DBC uchun R2dbcTransactionManager — bilan tranzaksiyani subscribe paytida ochadi va zanjir tugaganda commit yoki rollback qiladi. TransactionalOperator xuddi shuni kod bilan, proxyʼsiz qiladi. Tranzaksiya holati ThreadLocalda emas, Reactor Contextda saqlanadi.

Imperativ kodda tranzaksiya threadʼga bogʻlanadi. Reactive zanjir esa threadʼdan threadʼga oʻtadi, shuning uchun Spring connection va tranzaksiyani subscriberʼning Contextiga qoʻyadi: zanjirdagi har bir R2DBC chaqiruvi oʻsha connectionʼni oladi. Natijada tranzaksiya faqat qaytarilgan publisher ichidagi ishlarni qamraydi: metod ichida alohida subscribe() qilingan zanjir unga kirmaydi.

Commit zanjir onComplete bergandan keyin boʻladi, rollback — onErrorda: @Transactional default holatda RuntimeException va Error uchun rollback qiladi, imperativ kod bilan bir xil, TransactionalOperator esa har qanday xatoda. Subscriber zanjirni oxirigacha oʻqimay cancel qilsa — masalan, take(1) yoki client uzilsa — Spring Framework 5.3 dan beri tranzaksiya rollback qilinadi.

TransactionalOperator (operator.transactional(mono)) kerak boʻladigan joylar: tranzaksiya chegarasini metoddan kichikroq qilish, proxy ishlamaydigan holatlar — masalan, oʻsha klass ichidan chaqiruv — yoki functional uslubdagi kod. Spring Boot bitta ReactiveTransactionManager boʻlsa, TransactionalOperator beanʼini oʻzi yaratadi.

@Transactional
public Mono<Void> transfer(long from, long to,
                           long amount) {
    return accounts.withdraw(from, amount)
            .then(accounts.deposit(to, amount))
            .then(audit.log(from, to, amount));
}

// xuddi shuni kod bilan
Mono<Void> transfer2(long from, long to, long amount) {
    return accounts.withdraw(from, amount)
            .then(accounts.deposit(to, amount))
            .as(operator::transactional);
}

6Hot publisher, Server-Sent Events va backpressure

Hozirgacha koʻrgan publisherʼlarimiz cold: har bir subscriber uchun ish boshidan boshlanadi. WebClient chaqiruvi, R2DBC soʻrovi, Flux.range — ikki subscriber ikki alohida bajarilishni oladi va har biri hamma elementni koʻradi. Hot publisher esa subscriberʼlarga bogʻliq boʻlmagan oqim: narxlar, foydalanuvchi eventʼlari, broker xabarlari. Kech kelgan subscriber faqat oʻzidan keyingi elementlarni oladi.

Manba yoki operatorXatti-harakati
cold Flux: WebClient, R2DBC, Flux.rangehar subscriber uchun ish qaytadan boshlanadi, hamma elementlar keladi
share()birinchi subscriber kelganda manbaga bitta subscribe qiladi, qolganlar shu oqimga qoʻshiladi; kech kelgan oldingi elementlarni koʻrmaydi; hamma subscriber ketganda manba cancel qilinadi
cache()birinchi subscribeʼda manbani ishga tushiradi va hamma signalni eslab qoladi; kech kelganlarga ham hammasini qayta beradi
Sinks.many().multicast()koddan qoʻlda event chiqarish; subscriber faqat oʻzidan keyingisini oladi
Sinks.many().replay().limit(n)yangi subscriberʼga oxirgi n ta elementni ham beradi

Sinks — Reactorʼda hot oqimni koddan boshqarish usuli: tryEmitNext(x) element chiqaradi, asFlux() esa oqimni subscriberʼlarga beradi. Sink signallarning ketma-ket kelishini talab qiladi: tryEmitNext bir vaqtda bir nechta threadʼdan chaqirilsa, ulardan biri FAIL_NON_SERIALIZED natijasini olishi mumkin. Server-Sent Events esa shunday hot oqimni brauzerga yuborishning eng oddiy yoʻli: HTTP javob ochiq qoladi va har bir element alohida event boʻlib yoziladi.

Backpressure — subscriberʼning oqim tezligini boshqarishi. Reactive Streams shartnomasida publisher subscriber request(n) bilan soʻraganidan koʻp element bera olmaydi. Cold manbalar bunga oson moslashadi: Flux.range yoki Flux.generate keyingi elementni faqat talab boʻlganda chiqaradi.

1/6Producer sekundiga 1000 ta element chiqara oladi, consumer esa sekundiga 10 tasini ishlaydi. Backpressure boʻlmasa, bu farq qayerdadir yigʻilib qoladi.

subscribe(consumer) va block() esa request(Long.MAX_VALUE) yuboradi — bu «cheklovsiz» degani. Amalda backpressureʼni zanjirdagi operatorlar beradi: publishOn yuqoridan 256 ta soʻrab, keyin 192 tadan toʻldiradi, flatMap bir vaqtda 256 tagacha ichki publisherʼga subscribe qiladi, limitRate(100) esa avval 100, keyin 75 tadan soʻraydi. WebFlux javob yozganda ham Reactor Netty elementlarni Fluxdan boʻlib-boʻlib soʻraydi va ulanish yozishga tayyor boʻlmasa, yozishni toʻxtatib turadi.

Flux.range(1, 300)
        .doOnRequest(n -> log.info("request({})", n))
        .limitRate(100)
        .subscribe();
// request(100), request(75), request(75), ...

Muammo hot manbada: narxlar oqimi yoki Flux.interval subscriber sekinlashdi deb toʻxtab turolmaydi. Spring hujjatlari aytganidek, bunday publisher ortiqcha elementlarni buferlashi, tashlab yuborishi yoki xato berishi kerak — va bu tanlovni siz qilasiz. Tanlamasangiz, xatti-harakat manbaga bogʻliq: masalan, Flux.interval talab yetmaganda OverflowException bilan tugaydi.

Tushunganingizni tekshiring

Cold va hot publisher farqi nima? share() va cache() qachon kerak?Javob
Qisqa javob

Cold publisher har bir subscriber uchun ishni boshidan boshlaydi va hammaga barcha elementlarni beradi. Hot publisher subscriberʼlardan qatʼi nazar chiqadi, kech kelgan subscriber faqat keyingi elementlarni oladi. Flux.share() bitta bajarilishni hozirgi subscriberʼlar orasida boʻlishadi, cache() esa natijani eslab qolib, keyingilarga ham qayta beradi. Mono.share() esa natijani kech kelganga ham beradi.

Koʻp uchraydigan xato — bitta Mononi ikki joyda ishlatib, unga ikki marta subscribe qilish: Mono<Token> token = auth.fetch(); keyin token ham zipda, ham flatMapda ishlatilsa, HTTP soʻrov ikki marta ketadi. token.cache() birinchi natijani eslab qoladi va ikkinchi subscriber uni qayta soʻramaydi.

cache() cheksiz eslab qoladi — xatoni ham. Token yoki konfiguratsiya kabi muddatli qiymat uchun cache(Duration ttl) ishlatiladi, cache(value -> ttl, error -> Duration.ZERO, () -> Duration.ZERO) esa xatoni va boʻsh natijani eslab qolmaslikka imkon beradi. Katta Fluxni cache() qilish uning hamma elementini xotirada ushlab turadi.

share() — bu publish().refCount(): birinchi subscriber kelganda manbaga ulanadi, oxirgisi ketganda uni cancel qiladi. Kech kelgan subscriber oldin chiqqan elementlarni koʻrmaydi. Bitta qimmat oqimni — masalan, broker bilan ulanishni — bir nechta subscriberʼga tarqatish uchun qulay.

Flux<Long> ticks = Flux
        .interval(Duration.ofMillis(100))
        .take(5);

Flux<Long> shared = ticks.share();
// birinchisi: 0 1 2 3 4, 250 ms dan keyingisi: 2 3 4

Flux<Long> cached = ticks.cache();
// ikkalasi ham: 0 1 2 3 4
Server-Sent Events endpoint qanday yoziladi? Eventʼlar qayerdan keladi?Javob
Qisqa javob

Controller text/event-stream media type bilan Flux qaytaradi: WebFlux har bir elementni alohida event qilib yozadi va darhol flush qiladi, ulanish esa ochiq qoladi. Eventʼlar odatda hot manbadan — Sinks.Many yoki broker oqimidan — keladi va har bir yangi client oʻsha oqimga subscribe qiladi.

Sinks.many().multicast().directBestEffort() har bir eventʼni hozir ulangan hamma clientʼga yuboradi; client sekin boʻlsa, faqat oʻsha clientʼga tegishli eventʼlar tashlab yuboriladi. Hech kim ulanmagan paytda tryEmitNext FAIL_ZERO_SUBSCRIBER qaytaradi va event yoʻqoladi. onBackpressureBuffer() varianti esa birinchi subscriber kelguncha 256 tagacha eventʼni buferda saqlaydi, lekin default holatda oxirgi client ketishi bilan sink oʻzini cancel qiladi: keyingi tryEmitNext koʻpincha OK qaytaradi-yu event hech kimga bormaydi, yangi client esa darhol onComplete oladi. SSE uchun onBackpressureBuffer(Queues.SMALL_BUFFER_SIZE, false) ishlatiladi. replay().limit(n) yangi clientʼga oxirgi n ta eventʼni beradi.

Client uzilganda WebFlux subscriptionʼni cancel qiladi va oqim shu client uchun toʻxtaydi. Lekin uzilish koʻpincha faqat keyingi yozishda seziladi, shuning uchun Spring hujjatlari davriy heartbeat yuborishni tavsiya qiladi — masalan, har 15 soniyada boʻsh comment event. Bu proxy va load balancerʼlar boʻsh turgan ulanishni yopib qoʻymasligi uchun ham kerak.

SSE bir tomonlama: server → client, oddiy HTTP ustida. Brauzerdagi EventSource uzilganda oʻzi qayta ulanadi va oxirgi event idsini Last-Event-ID headerʼida yuboradi. Ikki tomonlama aloqa kerak boʻlsa — WebSocket. Har bir client — ochiq ulanish, lekin event loop modelida u thread band qilmaydi: minglab SSE clientʼi uchun WebFlux shu sababli qulay.

@GetMapping(value = "/prices",
        produces = MediaType.TEXT_EVENT_STREAM_VALUE)
Flux<ServerSentEvent<PriceEvent>> prices() {
    Flux<ServerSentEvent<PriceEvent>> events = sink
            .asFlux()
            .map(e -> ServerSentEvent.builder(e)
                    .event("price")
                    .build());

    // har 15 soniyada boʻsh comment: heartbeat
    Flux<ServerSentEvent<PriceEvent>> ping = Flux
            .interval(Duration.ofSeconds(15))
            .map(i -> ServerSentEvent
                    .<PriceEvent>builder()
                    .comment("ping")
                    .build());

    return Flux.merge(events, ping);
}
Producer tez, consumer sekin boʻlsa nima qilinadi? onBackpressureBuffer va onBackpressureDrop farqi nima?Javob
Qisqa javob

Cold manba consumerʼning request(n) talabiga moslashadi va oʻzi sekinlashadi. Hot manba — eventʼlar, sensorlar, Flux.interval — talab tugagani uchun toʻxtab turolmaydi, shuning uchun ortiqcha elementlar bilan nima qilishni aniq aytish kerak: onBackpressureBuffer ularni navbatga qoʻyadi, onBackpressureDrop talab yoʻq paytda kelganlarini tashlab yuboradi, onBackpressureLatest esa faqat eng oxirgisini saqlaydi.

onBackpressureBuffer() argumentsiz — cheklanmagan bufer: consumer doim sekin boʻlsa, navbat oʻsib boradi va oxiri xotira tugaydi. Shuning uchun hajm beriladi: onBackpressureBuffer(10_000) bufer toʻlganda OverflowException bilan xato beradi, BufferOverflowStrategy.DROP_OLDEST yoki DROP_LATEST bilan esa xato oʻrniga eng eski yoki eng yangi element tashlanadi.

onBackpressureDrop(dropped -> ...) tashlangan har bir element uchun callback chaqiradi — metrika yoki log uchun. Tashlash qachon mumkin: keyingi qiymat oldingisini eskirtirsa — narx, sensor koʻrsatkichi, progress — yoki namunaning bir qismi yetarli boʻlsa. Toʻlovlar, buyurtmalar kabi har biri muhim eventʼlarni tashlab boʻlmaydi: u yerda manbaning oʻzini sekinlashtirish kerak, masalan broker xabarni consumer soʻragandagina beradi.

Hot manbalarning oʻz default xatti-harakati bor: Flux.interval talab yetmaganda OverflowException bilan tugaydi, Sinks.many().multicast().onBackpressureBuffer() bufer toʻlganda tryEmitNextdan FAIL_OVERFLOW qaytaradi, Flux.create esa default holatda BUFFER strategiyasini, yaʼni yana cheklanmagan buferni ishlatadi.

Flux<Price> prices = priceFeed.stream()
        // narx eskiradi: sekin subscriberʼga
        // faqat eng oxirgisi
        .onBackpressureLatest();

Flux<Event> events = eventFeed.stream()
        .onBackpressureBuffer(10_000,
                e -> log.warn("tashlandi: {}", e),
                BufferOverflowStrategy.DROP_OLDEST);

7Testlash va productionʼda debug: StepVerifier, BlockHound va Context

Reactive metodni testda oddiy chaqirish hech narsani tekshirmaydi: u faqat publisher qaytaradi. block() bilan natijani olish mumkin, lekin u elementlar ketma-ketligini, tugash signalini va xato turini koʻrsatmaydi. Buning uchun reactor-test kutubxonasida StepVerifier bor: u publisherʼga subscribe qiladi va kutilgan signallarni tartib bilan tekshiradi.

@Test
void findsActiveUsers() {
    StepVerifier.create(service.active())
            .expectNext(ali)
            .expectNextMatches(User::active)
            .verifyComplete();
}

@Test
void failsForUnknownUser() {
    StepVerifier.create(service.find(42))
            .expectError(UserNotFoundException.class)
            .verify(Duration.ofSeconds(1));
}

Zanjir verify... bilan tugashi shart: StepVerifier.create(...) va expect... faqat ssenariy quradi, subscribe esa verify() yoki verifyComplete() chaqirilganda boʻladi. verify() default holatda cheksiz kutadi, shuning uchun tugamaydigan oqim testni osib qoʻyadi — verify(Duration) yoki thenCancel() bilan chegara qoʻyiladi. Vaqtga bogʻliq kod — delayElements, interval, retry pauzalari — uchun StepVerifier.withVirtualTime bor: u Reactor vaqt operatorlarini virtual soat bilan ishlatadi, bir soatlik pauza test ichida millisekundlarda tekshiriladi. HTTP darajasida esa WebTestClient ishlatiladi.

Productionʼda reactive koddagi muammolar alohida vositalar talab qiladi. Birinchisi — yashirin bloklanish: kutubxona ichidagi sinxron chaqiruv event loopʼni sekinlashtiradi, lekin hech qanday xato chiqarmaydi. BlockHound uni test va staging muhitida xatoga aylantiradi. Ikkinchisi — oʻqib boʻlmaydigan stack trace: xato operatorlarning ichki klasslari orasidan chiqadi va sizning qaysi zanjiringiz ekanini koʻrsatmaydi. Buni checkpoint() va ReactorDebugAgent hal qiladi.

Uchinchisi — kontekst. ThreadLocalga tayanadigan narsalar — MDC, trace ID, xavfsizlik konteksti — reactive kodda threadʼga emas, Reactor Contextga bogʻlanadi: bu subscriber bilan birga zanjir boʻylab yuradigan immutable key-value. Masalan, WebFlux uchun Spring Security joriy foydalanuvchini ReactiveSecurityContextHolder orqali aynan shu Contextdan oladi.

Tushunganingizni tekshiring

StepVerifier qanday ishlaydi? Xato signali va backpressure qanday tekshiriladi?Javob
Qisqa javob

StepVerifier.create(publisher) kutilgan signallar ssenariysini quradi: expectNext, expectNextMatches, assertNext, keyin tugash yoki xato. verify... chaqirilganda u publisherʼga subscribe qiladi va signallarni birma-bir solishtiradi. Xato uchun expectError(Class), expectErrorMessage yoki expectErrorMatches ishlatiladi.

Har bir expect... keyingi signalga mos kelishi kerak: ortiqcha element, kutilmagan tugash yoki xato testni yiqitadi va xabar qaysi qadamda nima kelganini koʻrsatadi. verifyComplete() — expectComplete().verify()ning qisqasi, verifyError(Class) ham shunday.

Backpressureʼni ham tekshirish mumkin: StepVerifier.create(flux, 2) boshida faqat 2 ta element soʻraydi, thenRequest(n) keyin yana soʻraydi. Shunda publisher talabdan ortiq element chiqarmasligi koʻrinadi. Cheksiz oqimning kerakli qismini tekshirib, thenCancel().verify() bilan tugatiladi.

Koʻp uchraydigan xato — verifyni unutish: test yashil koʻrinadi, lekin hech narsa tekshirilmagan, chunki subscribe boʻlmagan. Yana biri — block() bilan tekshirish: Fluxda blockLast() faqat oxirgi elementni qaytaradi, boʻsh Mono esa null beradi va testda bu xatodek koʻrinmaydi.

StepVerifier.create(Flux.range(1, 10), 2)
        .expectNext(1, 2)
        .thenRequest(1)
        .expectNext(3)
        .thenCancel()
        .verify();
Vaqtga bogʻliq reactive kodni kutmasdan qanday testlash mumkin? Endpoint qanday tekshiriladi?Javob
Qisqa javob

StepVerifier.withVirtualTime(() -> ...) Reactor schedulerʼlarini virtual vaqtli scheduler bilan almashtiradi, thenAwait(Duration) va expectNoEvent(Duration) esa soatni darhol oldinga suradi. Endpoint uchun WebTestClient soʻrov yuboradi va status, header va bodyʼni tekshiradi.

Publisher supplier ichida yaratilishi shart: virtual scheduler faqat test boshlangandan keyin qurilgan operatorlarga taʼsir qiladi. Publisherʼni oldindan yaratib, supplierʼdan uni qaytarsangiz, delay yoki interval haqiqiy parallel schedulerʼni olib boʻlgan boʻladi va test haqiqiy vaqtni kutadi yoki osilib qoladi.

expectNoEvent subscribe signalini ham event deb hisoblaydi, shuning uchun undan oldin expectSubscription() yoziladi. Bu usul retry backoff, timeout va intervalga asoslangan logikani soniyalarda emas, millisekundlarda tekshirishga imkon beradi.

@WebFluxTest(UserController.class) faqat web qatlamini koʻtaradi: controllerʼlar, @ControllerAdvice, codecʼlar va WebTestClient; servislar @MockitoBean bilan almashtiriladi (Spring Boot 3.4 dan oldin — @MockBean). @SpringBootTest(webEnvironment = RANDOM_PORT) bilan esa haqiqiy server ishga tushadi va WebTestClient unga HTTP orqali soʻrov yuboradi; Spring Boot 4 da buning uchun @AutoConfigureWebTestClient ham qoʻyiladi. Streaming endpoint uchun returnResult(Price.class).getResponseBody() Flux qaytaradi va uni yana StepVerifier bilan tekshirish mumkin.

@Test
void emitsEveryMinute() {
    StepVerifier.withVirtualTime(() -> Flux
                    .interval(Duration.ofMinutes(1))
                    .take(3))
            .expectSubscription()
            .expectNoEvent(Duration.ofMinutes(1))
            .expectNext(0L)
            .thenAwait(Duration.ofMinutes(2))
            .expectNext(1L, 2L)
            .verifyComplete();
}

@Test
void returnsUser() {
    webTestClient.get().uri("/users/1")
            .exchange()
            .expectStatus().isOk()
            .expectBody(User.class)
            .isEqualTo(new User(1, "Ali", true));
}
Event loop bloklanishini va reactive xatoning manbasini qanday topasiz?Javob
Qisqa javob

Bloklanishni BlockHound topadi: u Java agent sifatida bloklovchi metodlarni kuzatadi va ular non-blocking threadʼda chaqirilsa, BlockingOperationError tashlaydi. Xato manbasi uchun checkpoint("...") qoʻyiladi: u xato oʻtgan joyni stack traceʼga qoʻshadi, chunki reactive stack trace odatda faqat operatorlarning ichki klasslaridan iborat boʻladi.

BlockHound BlockHound.install() bilan yoqiladi — odatda testlar boshida yoki staging muhitida. U Thread.sleep, socket va fayl bilan ishlash kabi bloklovchi metodlarni instrument qiladi va ular Reactorʼning NonBlocking threadʼlarida — parallel, single, Reactor Netty event loopʼlarida — chaqirilganini sezadi. Xabar aniq — Java 21 da Blocking call! java.lang.Thread.sleep0 — ostida esa chaqiruv joyi. JDK 13 dan boshlab unga -XX:+AllowRedefinitionToAddDeleteMethods JVM flagʼi kerak.

Reactive kodda exception chiqqan joy bilan zanjir qurilgan joy har xil: xato parallel-3 threadʼida operator ichidan chiqadi, stack traceʼda esa sizning metodingiz koʻrinmaydi. checkpoint("narx-chegirma") xato oʻsha nuqtadan oʻtganda stack traceʼga «Error has been observed at the following site(s)» boʻlimini va unda shu tavsifni qoʻshadi. Tavsifli variant arzon: u default holatda stack trace yigʻmaydi.

Butun ilova boʻylab bunday maʼlumot kerak boʻlsa, Hooks.onOperatorDebug() bor, lekin u har bir operator yaratilganda stack trace oladi va productionʼda juda qimmat. Productionʼga mos variant — reactor-tools kutubxonasidagi ReactorDebugAgent: u assembly maʼlumotini bytecode darajasida qoʻshadi. Spring Boot reactor-tools classpathʼda boʻlsa, uni oʻzi yoqadi (spring.reactor.debug-agent.enabled, default true).

Mono<Price> price(long id) {
    return prices.find(id)
            .map(p -> p.discounted(rate))
            .checkpoint("narx-chegirma");
}

// xato boʻlsa, stack traceʼda:
// Error has been observed at the following site(s):
//   *__checkpoint ⇢ narx-chegirma
Reactive kodda ThreadLocal va MDC nega ishlamaydi? Trace kontekst qanday uzatiladi?Javob
Qisqa javob

Reactive zanjir bitta soʻrov davomida bir nechta threadʼdan oʻtadi, bitta thread esa koʻp soʻrovga xizmat qiladi, shuning uchun ThreadLocaldagi qiymat yoʻqolishi yoki boshqa soʻrovniki boʻlib chiqishi mumkin. Uning oʻrnida Reactor Context ishlatiladi. MDC va trace ID esa Micrometer context-propagation kutubxonasi orqali Contextdan ThreadLocalga qayta tiklanadi.

Context subscriberʼga bogʻlangan: contextWrite(Context.of("userId", id)) qiymatni yozadi, Mono.deferContextual(ctx -> ...) esa oʻqiydi. Muhim nuqta — contextWrite oʻzidan yuqoridagi operatorlarga koʻrinadi, chunki context subscribe paytida pastdan yuqoriga uzatiladi. Shuning uchun uni zanjir oxiriga yoki WebFlux filterʼiga qoʻyishadi.

Logging kutubxonalari esa MDCʼni ThreadLocaldan oʻqiydi. Micrometer context-propagation ikki dunyoni ThreadLocalAccessorʼlar orqali bogʻlaydi: Spring Bootʼda spring.reactor.context-propagation=auto qoʻyilsa, Reactor — Hooks.enableAutomaticContextPropagation() — har bir operator atrofida roʻyxatdan oʻtgan ThreadLocalʼlarni Contextdan tiklaydi. Default qiymat — limited: unda tiklash faqat handle va tap operatorlarida boʻladi.

Micrometer Tracing bilan WebFlux har bir soʻrov uchun observation ochadi va u Context orqali yuradi. auto rejimda log qatorlaridagi traceId va spanId operatorlar boshqa threadʼda ishlaganda ham toʻgʻri chiqadi. Oʻz MDC kalitlaringiz uchun context-propagationʼda Slf4jThreadLocalAccessor bor yoki oʻz ThreadLocalAccessoringizni roʻyxatdan oʻtkazasiz.

// WebFilter: soʻrov boshida yozadi
return chain.filter(exchange)
        .contextWrite(Context.of("userId", userId));

// zanjirning istalgan joyida oʻqiydi
Mono<Order> create(OrderRequest r) {
    return Mono.deferContextual(ctx -> {
        String userId = ctx.get("userId");
        return repository.save(r.toOrder(userId));
    });
}

8WebFlux, Spring MVC yoki virtual threadʼlar

Java 21 gacha bloklovchi kod bilan oʻn minglab bir vaqtdagi ulanishga xizmat qilish uchun reactive yondashuv deyarli yagona amaliy yoʻl edi. Virtual threadʼlar vaziyatni oʻzgartirdi: bloklovchi chaqiruv endi OS threadʼini emas, faqat arzon virtual threadʼni toʻxtatadi. Spring Boot 3.2 dan spring.threads.virtual.enabled=true bilan Tomcat har bir soʻrovni virtual threadʼda bajaradi — oddiy sinxron kod, JDBC va RestClient bilan. Virtual threadʼlar qanday ishlashi Concurrency mavzusida batafsil koʻrilgan.

JihatSpring MVCSpring MVC + virtual threadʼlarWebFlux
Kod uslubioddiy, sinxronoddiy, sinxronreactive zanjir: Mono, Flux, operatorlar
Kutish paytidaOS threadʼi bandfaqat virtual thread band, carrier boʻshthread band emas, holat zanjirda
Bir vaqtdagi soʻrovlar chegarasithread pool, Tomcat default 200connection pool va tashqi servislarulanishlar, xotira va tashqi servislar
Maʼlumotlar bazasiJDBC, JPAJDBC, JPAR2DBC yoki boshqa reactive drayver
Streaming va backpressureSseEmitter, StreamingResponseBody yoki Flux qaytarish, lekin javobga yozish bloklovchixuddi shundayFlux, SSE, backpressure butun yoʻl boʻylab
Debug va stack traceoddiyoddiymurakkabroq: checkpoint, BlockHound, Context

Virtual threadʼlar «reactive endi kerak emas» degani emas. Ular kutishni arzon qiladi, backpressure vazifasini esa oddiy bloklanish bajaradi — chaqiruvchi kutadi. Lekin bir nechta asinxron oqimni birlashtirish, cancel va tezlikni boshqarish uchun Reactor operatorlaridek tayyor vositalar bermaydi. Boshqa tomondan, reactive kod hamma qatlamni — drayverlar, clientʼlar, kutubxonalar — non-blocking boʻlishini talab qiladi va jamoadan yangi fikrlash tarzini soʻraydi.

WebFlux ilovasida ham virtual threadʼlar foydali boʻlishi mumkin: Spring Framework 6.1 dan WebFlux reactive tur qaytarmaydigan controller metodlarini alohida executorʼda chaqira oladi, Spring Boot esa spring.threads.virtual.enabled=true boʻlsa, buning uchun virtual threadʼli applicationTaskExecutorni beradi. boundedElasticni ham virtual threadʼlarga oʻtkazish mumkin — schedulerʼlar boʻlimida aytilgan system property bilan.

Tushunganingizni tekshiring

Virtual threadʼlar WebFluxʼni keraksiz qiladimi? Reactive qachon oʻzini oqlaydi?Javob
Qisqa javob

Koʻp oddiy servislar uchun — soʻrov keladi, bir nechta bazaga va servisga murojaat qiladi, javob qaytaradi — virtual threadʼlar sinxron kod bilan shunga yaqin masshtab beradi va reactiveʼga oʻtishning asosiy sababini olib tashlaydi. Reactive esa streaming, backpressure, juda koʻp uzoq yashaydigan ulanishlar (SSE, WebSocket) va koʻp asinxron manbani birlashtirish kerak boʻlganda oʻzini oqlaydi.

Ikkalasi ham bitta muammoni hal qiladi — kutish paytida OS threadʼini band qilmaslik. Virtual threadʼda kod oʻzgarmaydi: jdbcTemplate.query bloklanadi, JVM esa virtual threadʼni carrierʼdan tushirib, OS threadʼini boshqa ishga beradi. Reactive kodda bunga butun zanjirni Mono va Flux bilan yozish orqali erishiladi.

Virtual threadʼlarning ham chegaralari bor. Tor joy endi connection pool va tashqi servislar boʻladi: 10 ta JDBC connectionʼga minglab virtual thread navbatga turadi, shuning uchun Semaphore yoki pool sozlamasi bilan chegara kerak. Java 21–23 da synchronized ichidagi bloklanish carrierʼni pin qiladi, Java 24 da bu tuzatilgan. Bloklovchi kodda bloklanishning oʻzi tabiiy backpressure: chaqiruvchi kutadi. Lekin oqimni boʻlib-boʻlib olish, bir nechta oqimni birlashtirish va tezlikni boshqarish uchun tayyor operatorlar yoʻq — ularni oʻzingiz yozasiz.

Reactive afzal boʻladigan joylar: API gateway va agregatorlar (Spring Cloud Gatewayʼning dastlabki varianti WebFlux ustida qurilgan), real vaqtdagi eventʼlar va SSE, Kafka yoki broker oqimlarini qayta ishlash, backpressure muhim boʻlgan pipelineʼlar.

Ishlab turgan servisni WebFluxʼga koʻchirish qanchaga tushadi? Qachon Spring MVCʼda qolish kerak?Javob
Qisqa javob

Koʻchirish faqat controllerʼlarni almashtirish emas: JDBC va JPA oʻrniga R2DBC, RestTemplate oʻrniga WebClient, bloklovchi SDKʼlar uchun yechim, yangi testlar va jamoaning reactive fikrlashi kerak. Servis yaxshi ishlab tursa, bloklovchi kutubxonalarga tayansa yoki yuk thread-per-request chegarasiga yetmasa, Spring MVC — koʻpincha virtual threadʼlar bilan — toʻgʻriroq tanlov.

Reactive faqat butun zanjir non-blocking boʻlganda foyda beradi. Har bir bloklovchi qatlam — JPA, eski SDK, sinxron cache client — boundedElasticga chiqarilishi kerak va oʻsha joyda thread-per-request modeli qaytadi. JPAʼdagi relationʼlar, lazy loading va dirty checking R2DBCʼda yoʻq, shuning uchun maʼlumot qatlami qayta yoziladi.

Jamoa uchun narx: debug — stack trace va checkpoint; «nega hech narsa bajarilmadi» xatolari, chunki subscribe unutilgan; ThreadLocal oʻrniga Context; flatMap va concatMap farqi kabi nozik joylar. Code review ham qiyinlashadi: bitta block() yoki map ichidagi bloklovchi chaqiruv butun serverni sekinlashtirishi mumkin.

Oraliq yoʻl ham bor: Spring MVC ilovasida WebClient ishlatish va controllerʼdan Mono qaytarish mumkin — Spring MVC reactive turlarni qoʻllab-quvvatlaydi. Spring hujjatlari ham ishlab turgan MVC ilovasini sababsiz koʻchirmaslikni, reactiveʼni kichikdan, masalan WebClient bilan boshlab, foydasini oʻlchashni tavsiya qiladi. Qaror taxminga emas, oʻlchovga asoslanadi: yuk testi, kechikish va xotira.

Tushunganingizni suhbatda sinab koʻring

Mavzuli mock intervyuda «Reactive va WebFlux»ni tanlang. AI shu kabi savollarni beradi, javobingizga qarab chuqurroq savol soʻraydi va har javobingizga fikr bildiradi.

Mock intervyuni boshlash