Merge pull request #8125 from eugenp/revert-8119-BAEL-3275-2

Revert "BAEL-3275: Using blocking queue for pub-sub"

spring-5-reactive-2/src/main/java/com/baeldung/debugging/consumer/ConsumerDebuggingApplication.java

@@ -0,0 +1,34 @@
+package com.baeldung.debugging.consumer;
+
+import java.util.Collections;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.autoconfigure.mongo.MongoReactiveAutoConfiguration;
+import org.springframework.context.annotation.Bean;
+import org.springframework.scheduling.annotation.EnableScheduling;
+import org.springframework.security.config.web.server.ServerHttpSecurity;
+import org.springframework.security.web.server.SecurityWebFilterChain;
+
+import reactor.core.publisher.Hooks;
+
+@SpringBootApplication(exclude = MongoReactiveAutoConfiguration.class)
+@EnableScheduling
+public class ConsumerDebuggingApplication {
+
+    public static void main(String[] args) {
+        Hooks.onOperatorDebug();
+        SpringApplication app = new SpringApplication(ConsumerDebuggingApplication.class);
+        app.setDefaultProperties(Collections.singletonMap("server.port", "8082"));
+        app.run(args);
+    }
+
+    @Bean
+    public SecurityWebFilterChain debuggingConsumerSpringSecurityFilterChain(ServerHttpSecurity http) {
+        http.authorizeExchange()
+            .anyExchange()
+            .permitAll();
+        http.csrf().disable();
+        return http.build();
+    }
+}

spring-5-reactive-2/src/main/java/com/baeldung/debugging/consumer/chronjobs/ChronJobs.java

@@ -0,0 +1,154 @@
+package com.baeldung.debugging.consumer.chronjobs;
+
+import java.time.Duration;
+import java.util.concurrent.ThreadLocalRandom;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.MediaType;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+import org.springframework.web.reactive.function.client.WebClient;
+
+import com.baeldung.debugging.consumer.model.Foo;
+import com.baeldung.debugging.consumer.model.FooDto;
+import com.baeldung.debugging.consumer.service.FooService;
+
+import reactor.core.publisher.Flux;
+
+@Component
+public class ChronJobs {
+
+    private static Logger logger = LoggerFactory.getLogger(ChronJobs.class);
+    private WebClient client = WebClient.create("http://localhost:8081");
+
+    @Autowired
+    private FooService service;
+
+    @Scheduled(fixedRate = 10000)
+    public void consumeInfiniteFlux() {
+        Flux<Foo> fluxFoo = client.get()
+            .uri("/functional-reactive/periodic-foo")
+            .accept(MediaType.TEXT_EVENT_STREAM)
+            .retrieve()
+            .bodyToFlux(FooDto.class)
+            .delayElements(Duration.ofMillis(100))
+            .map(dto -> {
+                logger.debug("process 1 with dto id {} name{}", dto.getId(), dto.getName());
+                return new Foo(dto);
+            });
+        Integer random = ThreadLocalRandom.current()
+            .nextInt(0, 3);
+        switch (random) {
+        case 0:
+            logger.info("process 1 with approach 1");
+            service.processFoo(fluxFoo);
+            break;
+        case 1:
+            logger.info("process 1 with approach 1 EH");
+            service.processUsingApproachOneWithErrorHandling(fluxFoo);
+            break;
+        default:
+            logger.info("process 1 with approach 2");
+            service.processFooInAnotherScenario(fluxFoo);
+            break;
+
+        }
+    }
+
+    @Scheduled(fixedRate = 20000)
+    public void consumeFiniteFlux2() {
+        Flux<Foo> fluxFoo = client.get()
+            .uri("/functional-reactive/periodic-foo-2")
+            .accept(MediaType.TEXT_EVENT_STREAM)
+            .retrieve()
+            .bodyToFlux(FooDto.class)
+            .delayElements(Duration.ofMillis(100))
+            .map(dto -> {
+                logger.debug("process 2 with dto id {} name{}", dto.getId(), dto.getName());
+                return new Foo(dto);
+            });
+        Integer random = ThreadLocalRandom.current()
+            .nextInt(0, 3);
+        switch (random) {
+        case 0:
+            logger.info("process 2 with approach 1");
+            service.processFoo(fluxFoo);
+            break;
+        case 1:
+            logger.info("process 2 with approach 1 EH");
+            service.processUsingApproachOneWithErrorHandling(fluxFoo);
+            break;
+        default:
+            logger.info("process 2 with approach 2");
+            service.processFooInAnotherScenario(fluxFoo);
+            break;
+
+        }
+    }
+
+    @Scheduled(fixedRate = 20000)
+    public void consumeFiniteFlux3() {
+        Flux<Foo> fluxFoo = client.get()
+            .uri("/functional-reactive/periodic-foo-2")
+            .accept(MediaType.TEXT_EVENT_STREAM)
+            .retrieve()
+            .bodyToFlux(FooDto.class)
+            .delayElements(Duration.ofMillis(100))
+            .map(dto -> {
+                logger.debug("process 3 with dto id {} name{}", dto.getId(), dto.getName());
+                return new Foo(dto);
+            });
+        logger.info("process 3 with approach 3");
+        service.processUsingApproachThree(fluxFoo);
+    }
+
+    @Scheduled(fixedRate = 20000)
+    public void consumeFiniteFluxWithCheckpoint4() {
+        Flux<Foo> fluxFoo = client.get()
+            .uri("/functional-reactive/periodic-foo-2")
+            .accept(MediaType.TEXT_EVENT_STREAM)
+            .retrieve()
+            .bodyToFlux(FooDto.class)
+            .delayElements(Duration.ofMillis(100))
+            .map(dto -> {
+                logger.debug("process 4 with dto id {} name{}", dto.getId(), dto.getName());
+                return new Foo(dto);
+            });
+        logger.info("process 4 with approach 4");
+        service.processUsingApproachFourWithCheckpoint(fluxFoo);
+    }
+
+    @Scheduled(fixedRate = 20000)
+    public void consumeFiniteFluxWitParallelScheduler() {
+        Flux<Foo> fluxFoo = client.get()
+            .uri("/functional-reactive/periodic-foo-2")
+            .accept(MediaType.TEXT_EVENT_STREAM)
+            .retrieve()
+            .bodyToFlux(FooDto.class)
+            .delayElements(Duration.ofMillis(100))
+            .map(dto -> {
+                logger.debug("process 5-parallel with dto id {} name{}", dto.getId(), dto.getName());
+                return new Foo(dto);
+            });
+        logger.info("process 5-parallel with approach 5-parallel");
+        service.processUsingApproachFivePublishingToDifferentParallelThreads(fluxFoo);
+    }
+
+    @Scheduled(fixedRate = 20000)
+    public void consumeFiniteFluxWithSingleSchedulers() {
+        Flux<Foo> fluxFoo = client.get()
+            .uri("/functional-reactive/periodic-foo-2")
+            .accept(MediaType.TEXT_EVENT_STREAM)
+            .retrieve()
+            .bodyToFlux(FooDto.class)
+            .delayElements(Duration.ofMillis(100))
+            .map(dto -> {
+                logger.debug("process 5-single with dto id {} name{}", dto.getId(), dto.getName());
+                return new Foo(dto);
+            });
+        logger.info("process 5-single with approach 5-single");
+        service.processUsingApproachFivePublishingToDifferentSingleThreads(fluxFoo);
+    }
+}

spring-5-reactive-2/src/main/java/com/baeldung/debugging/consumer/controllers/ReactiveConfigsToggleRestController.java

@@ -0,0 +1,23 @@
+package com.baeldung.debugging.consumer.controllers;
+
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import reactor.core.publisher.Hooks;
+
+@RestController
+public class ReactiveConfigsToggleRestController {
+
+    @GetMapping("/debug-hook-on")
+    public String setReactiveDebugOn() {
+        Hooks.onOperatorDebug();
+        return "DEBUG HOOK ON";
+    }
+
+    @GetMapping("/debug-hook-off")
+    public String setReactiveDebugOff() {
+        Hooks.resetOnOperatorDebug();
+        return "DEBUG HOOK OFF";
+    }
+
+}

spring-5-reactive-2/src/main/java/com/baeldung/debugging/consumer/model/Foo.java

@@ -0,0 +1,27 @@
+package com.baeldung.debugging.consumer.model;
+
+import java.util.concurrent.ThreadLocalRandom;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+public class Foo {
+
+    private Integer id;
+    private String formattedName;
+    private Integer quantity;
+
+    public Foo(FooDto dto) {
+        this.id = (ThreadLocalRandom.current()
+            .nextInt(0, 100) == 0) ? null : dto.getId();
+        this.formattedName = dto.getName();
+        this.quantity = ThreadLocalRandom.current()
+            .nextInt(0, 10);
+    }
+}

spring-5-reactive-2/src/main/java/com/baeldung/debugging/consumer/model/FooDto.java

@@ -0,0 +1,16 @@
+package com.baeldung.debugging.consumer.model;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+public class FooDto {
+
+    private Integer id;
+    private String name;
+}

spring-5-reactive-2/src/main/java/com/baeldung/debugging/consumer/service/FooNameHelper.java

@@ -0,0 +1,45 @@
+package com.baeldung.debugging.consumer.service;
+
+import java.util.concurrent.ThreadLocalRandom;
+
+import com.baeldung.debugging.consumer.model.Foo;
+
+import reactor.core.publisher.Flux;
+
+public class FooNameHelper {
+
+    public static Flux<Foo> concatAndSubstringFooName(Flux<Foo> flux) {
+        flux = concatFooName(flux);
+        flux = substringFooName(flux);
+        return flux;
+    }
+
+    public static Flux<Foo> concatFooName(Flux<Foo> flux) {
+        flux = flux.map(foo -> {
+            String processedName = null;
+            Integer random = ThreadLocalRandom.current()
+                .nextInt(0, 80);
+            processedName = (random != 0) ? foo.getFormattedName() : foo.getFormattedName() + "-bael";
+            foo.setFormattedName(processedName);
+            return foo;
+        });
+        return flux;
+    }
+
+    public static Flux<Foo> substringFooName(Flux<Foo> flux) {
+        return flux.map(foo -> {
+            String processedName;
+            Integer random = ThreadLocalRandom.current()
+                .nextInt(0, 100);
+
+            processedName = (random == 0) ? foo.getFormattedName()
+                .substring(10, 15)
+                : foo.getFormattedName()
+                    .substring(0, 5);
+
+            foo.setFormattedName(processedName);
+            return foo;
+        });
+    }
+
+}

spring-5-reactive-2/src/main/java/com/baeldung/debugging/consumer/service/FooQuantityHelper.java

@@ -0,0 +1,31 @@
+package com.baeldung.debugging.consumer.service;
+
+import java.util.concurrent.ThreadLocalRandom;
+
+import com.baeldung.debugging.consumer.model.Foo;
+
+import reactor.core.publisher.Flux;
+
+public class FooQuantityHelper {
+
+    public static Flux<Foo> processFooReducingQuantity(Flux<Foo> flux) {
+        flux = flux.map(foo -> {
+            Integer result;
+            Integer random = ThreadLocalRandom.current()
+                .nextInt(0, 90);
+            result = (random == 0) ? result = 0 : foo.getQuantity() + 2;
+            foo.setQuantity(result);
+            return foo;
+        });
+        return divideFooQuantity(flux);
+    }
+
+    public static Flux<Foo> divideFooQuantity(Flux<Foo> flux) {
+        return flux.map(foo -> {
+            Integer result = Math.round(5 / foo.getQuantity());
+            foo.setQuantity(result);
+            return foo;
+        });
+    }
+
+}

spring-5-reactive-2/src/main/java/com/baeldung/debugging/consumer/service/FooReporter.java

@@ -0,0 +1,26 @@
+package com.baeldung.debugging.consumer.service;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.baeldung.debugging.consumer.model.Foo;
+
+import reactor.core.publisher.Flux;
+
+public class FooReporter {
+
+    private static Logger logger = LoggerFactory.getLogger(FooReporter.class);
+
+    public static Flux<Foo> reportResult(Flux<Foo> input, String approach) {
+        return input.map(foo -> {
+            if (foo.getId() == null)
+                throw new IllegalArgumentException("Null id is not valid!");
+            logger.info("Reporting for approach {}: Foo with id '{}' name '{}' and quantity '{}'", approach, foo.getId(), foo.getFormattedName(), foo.getQuantity());
+            return foo;
+        });
+    }
+
+    public static Flux<Foo> reportResult(Flux<Foo> input) {
+        return reportResult(input, "default");
+    }
+}

spring-5-reactive-2/src/main/java/com/baeldung/debugging/consumer/service/FooService.java

@@ -0,0 +1,120 @@
+package com.baeldung.debugging.consumer.service;
+
+import static com.baeldung.debugging.consumer.service.FooNameHelper.concatAndSubstringFooName;
+import static com.baeldung.debugging.consumer.service.FooNameHelper.substringFooName;
+import static com.baeldung.debugging.consumer.service.FooQuantityHelper.divideFooQuantity;
+import static com.baeldung.debugging.consumer.service.FooQuantityHelper.processFooReducingQuantity;
+import static com.baeldung.debugging.consumer.service.FooReporter.reportResult;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+
+import com.baeldung.debugging.consumer.model.Foo;
+
+import reactor.core.publisher.Flux;
+import reactor.core.scheduler.Schedulers;
+
+@Component
+public class FooService {
+
+    private static Logger logger = LoggerFactory.getLogger(FooService.class);
+
+    public void processFoo(Flux<Foo> flux) {
+        flux = FooNameHelper.concatFooName(flux);
+        flux = FooNameHelper.substringFooName(flux);
+        flux = flux.log();
+        flux = FooReporter.reportResult(flux);
+        flux = flux.doOnError(error -> {
+            logger.error("The following error happened on processFoo method!", error);
+        });
+        flux.subscribe();
+    }
+
+    public void processFooInAnotherScenario(Flux<Foo> flux) {
+        flux = FooNameHelper.substringFooName(flux);
+        flux = FooQuantityHelper.divideFooQuantity(flux);
+        flux.subscribe();
+    }
+
+    public void processUsingApproachOneWithErrorHandling(Flux<Foo> flux) {
+        logger.info("starting approach one w error handling!");
+        flux = concatAndSubstringFooName(flux);
+        flux = concatAndSubstringFooName(flux);
+        flux = substringFooName(flux);
+        flux = processFooReducingQuantity(flux);
+        flux = processFooReducingQuantity(flux);
+        flux = processFooReducingQuantity(flux);
+        flux = reportResult(flux, "ONE w/ EH");
+        flux = flux.doOnError(error -> {
+            logger.error("Approach 1 with Error Handling failed!", error);
+        });
+        flux.subscribe();
+    }
+
+    public void processUsingApproachThree(Flux<Foo> flux) {
+        logger.info("starting approach three!");
+        flux = concatAndSubstringFooName(flux);
+        flux = reportResult(flux, "THREE");
+        flux = flux.doOnError(error -> {
+            logger.error("Approach 3 failed!", error);
+        });
+        flux.subscribe();
+    }
+
+    public void processUsingApproachFourWithCheckpoint(Flux<Foo> flux) {
+        logger.info("starting approach four!");
+        flux = concatAndSubstringFooName(flux);
+        flux = flux.checkpoint("CHECKPOINT 1");
+        flux = concatAndSubstringFooName(flux);
+        flux = divideFooQuantity(flux);
+        flux = flux.checkpoint("CHECKPOINT 2", true);
+        flux = reportResult(flux, "FOUR");
+        flux = concatAndSubstringFooName(flux).doOnError(error -> {
+            logger.error("Approach 4 failed!", error);
+        });
+        flux.subscribe();
+    }
+
+    public void processUsingApproachFourWithInitialCheckpoint(Flux<Foo> flux) {
+        logger.info("starting approach four!");
+        flux = concatAndSubstringFooName(flux);
+        flux = flux.checkpoint("CHECKPOINT 1", true);
+        flux = concatAndSubstringFooName(flux);
+        flux = divideFooQuantity(flux);
+        flux = reportResult(flux, "FOUR");
+        flux = flux.doOnError(error -> {
+            logger.error("Approach 4-2 failed!", error);
+        });
+        flux.subscribe();
+    }
+
+    public void processUsingApproachFivePublishingToDifferentParallelThreads(Flux<Foo> flux) {
+        logger.info("starting approach five-parallel!");
+        flux = concatAndSubstringFooName(flux).publishOn(Schedulers.newParallel("five-parallel-foo"))
+            .log();
+        flux = concatAndSubstringFooName(flux);
+        flux = divideFooQuantity(flux);
+        flux = reportResult(flux, "FIVE-PARALLEL").publishOn(Schedulers.newSingle("five-parallel-bar"));
+        flux = concatAndSubstringFooName(flux).doOnError(error -> {
+            logger.error("Approach 5-parallel failed!", error);
+        });
+        flux.subscribeOn(Schedulers.newParallel("five-parallel-starter"))
+            .subscribe();
+    }
+
+    public void processUsingApproachFivePublishingToDifferentSingleThreads(Flux<Foo> flux) {
+        logger.info("starting approach five-single!");
+        flux = flux.log()
+            .subscribeOn(Schedulers.newSingle("five-single-starter"));
+        flux = concatAndSubstringFooName(flux).publishOn(Schedulers.newSingle("five-single-foo"));
+        flux = concatAndSubstringFooName(flux);
+        flux = divideFooQuantity(flux);
+        flux = reportResult(flux, "FIVE-SINGLE").publishOn(Schedulers.newSingle("five-single-bar"));
+        flux = concatAndSubstringFooName(flux).doOnError(error -> {
+            logger.error("Approach 5-single failed!", error);
+        });
+        flux.subscribe();
+    }
+
+}

spring-5-reactive-2/src/main/java/com/baeldung/debugging/server/ServerDebuggingApplication.java

@@ -0,0 +1,29 @@
+package com.baeldung.debugging.server;
+
+import java.util.Collections;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.Bean;
+import org.springframework.security.config.web.server.ServerHttpSecurity;
+import org.springframework.security.web.server.SecurityWebFilterChain;
+import org.springframework.web.reactive.config.EnableWebFlux;
+
+@EnableWebFlux
+@SpringBootApplication
+public class ServerDebuggingApplication {
+    
+    public static void main(String[] args) {
+        SpringApplication app = new SpringApplication(ServerDebuggingApplication.class);
+        app.setDefaultProperties(Collections.singletonMap("server.port", "8081"));
+        app.run(args);
+    }
+    
+    @Bean
+    public SecurityWebFilterChain debuggingServerSpringSecurityFilterChain(ServerHttpSecurity http) {
+        http.authorizeExchange()
+            .anyExchange()
+            .permitAll();
+        return http.build();
+    }
+}

spring-5-reactive-2/src/main/java/com/baeldung/debugging/server/handlers/ServerHandler.java

@@ -0,0 +1,47 @@
+package com.baeldung.debugging.server.handlers;
+
+import java.time.Duration;
+import java.util.concurrent.ThreadLocalRandom;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.MediaType;
+import org.springframework.stereotype.Component;
+import org.springframework.web.reactive.function.server.ServerRequest;
+import org.springframework.web.reactive.function.server.ServerResponse;
+
+import com.baeldung.debugging.server.model.Foo;
+
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+@Component
+public class ServerHandler {
+
+    private static Logger logger = LoggerFactory.getLogger(ServerHandler.class);
+
+    public Mono<ServerResponse> useHandler(final ServerRequest request) {
+        // there are chances that something goes wrong here...
+        return ServerResponse.ok()
+            .contentType(MediaType.TEXT_EVENT_STREAM)
+            .body(Flux.interval(Duration.ofSeconds(1))
+                .map(sequence -> {
+                    logger.info("retrieving Foo. Sequence: {}", sequence);
+                    if (ThreadLocalRandom.current()
+                        .nextInt(0, 50) == 1) {
+                        throw new RuntimeException("There was an error retrieving the Foo!");
+                    }
+                    return new Foo(sequence, "name" + sequence);
+
+                }), Foo.class);
+    }
+
+    public Mono<ServerResponse> useHandlerFinite(final ServerRequest request) {
+        return ServerResponse.ok()
+            .contentType(MediaType.TEXT_EVENT_STREAM)
+            .body(Flux.range(0, 50)
+                .map(sequence -> {
+                    return new Foo(new Long(sequence), "theFooNameNumber" + sequence);
+                }), Foo.class);
+    }
+}

spring-5-reactive-2/src/main/java/com/baeldung/debugging/server/model/Foo.java

@@ -0,0 +1,13 @@
+package com.baeldung.debugging.server.model;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+@Data
+@AllArgsConstructor
+public class Foo {
+
+    private Long id;
+    private String name;
+
+}

spring-5-reactive-2/src/main/java/com/baeldung/debugging/server/routers/ServerRouter.java

@@ -0,0 +1,22 @@
+package com.baeldung.debugging.server.routers;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.reactive.function.server.RequestPredicates;
+import org.springframework.web.reactive.function.server.RouterFunction;
+import org.springframework.web.reactive.function.server.RouterFunctions;
+import org.springframework.web.reactive.function.server.ServerResponse;
+
+import com.baeldung.debugging.server.handlers.ServerHandler;
+
+@Configuration
+public class ServerRouter {
+
+	@Bean
+	public RouterFunction<ServerResponse> responseRoute(@Autowired ServerHandler handler) {
+		return RouterFunctions.route(RequestPredicates.GET("/functional-reactive/periodic-foo"), handler::useHandler)
+				.andRoute(RequestPredicates.GET("/functional-reactive/periodic-foo-2"), handler::useHandlerFinite);
+	}
+
+}

spring-5-reactive-2/src/main/java/com/baeldung/staticcontent/StaticContentApplication.java

@@ -0,0 +1,28 @@
+package com.baeldung.staticcontent;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.Bean;
+import org.springframework.security.config.web.server.ServerHttpSecurity;
+import org.springframework.security.web.server.SecurityWebFilterChain;
+
+import java.util.Collections;
+
+@SpringBootApplication
+public class StaticContentApplication {
+
+    public static void main(String[] args) {
+        SpringApplication app = new SpringApplication(StaticContentApplication.class);
+        app.setDefaultProperties(Collections.singletonMap("server.port", "8084"));
+        app.run(args);
+    }
+
+    @Bean
+    public SecurityWebFilterChain staticContentSpringSecurityFilterChain(ServerHttpSecurity http) {
+        http.authorizeExchange()
+                .anyExchange()
+                .permitAll();
+        return http.build();
+    }
+
+}

spring-5-reactive-2/src/main/java/com/baeldung/staticcontent/StaticContentConfig.java

@@ -0,0 +1,35 @@
+package com.baeldung.staticcontent;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.core.io.ClassPathResource;
+import org.springframework.core.io.Resource;
+import org.springframework.http.MediaType;
+import org.springframework.web.reactive.function.server.RouterFunction;
+import org.springframework.web.reactive.function.server.RouterFunctions;
+import org.springframework.web.reactive.function.server.ServerResponse;
+
+import static org.springframework.web.reactive.function.server.RequestPredicates.GET;
+import static org.springframework.web.reactive.function.server.RouterFunctions.route;
+import static org.springframework.web.reactive.function.server.ServerResponse.ok;
+
+@Configuration
+public class StaticContentConfig {
+
+    @Bean
+    public RouterFunction<ServerResponse> htmlRouter(@Value("classpath:/public/index.html") Resource html) {
+        return route(
+                GET("/"),
+                request -> ok()
+                        .contentType(MediaType.TEXT_HTML)
+                        .syncBody(html)
+        );
+    }
+
+    @Bean
+    public RouterFunction<ServerResponse> imgRouter() {
+        return RouterFunctions.resources("/img/**", new ClassPathResource("img/"));
+    }
+
+}

spring-5-reactive-2/src/main/java/com/baeldung/validations/functional/FunctionalValidationsApplication.java

@@ -0,0 +1,24 @@
+package com.baeldung.validations.functional;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.Bean;
+import org.springframework.security.config.web.server.ServerHttpSecurity;
+import org.springframework.security.web.server.SecurityWebFilterChain;
+
+@SpringBootApplication
+public class FunctionalValidationsApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(FunctionalValidationsApplication.class, args);
+    }
+    
+    @Bean
+    public SecurityWebFilterChain functionalValidationsSpringSecurityFilterChain(ServerHttpSecurity http) {
+        http.authorizeExchange()
+            .anyExchange()
+            .permitAll();
+        http.csrf().disable();
+        return http.build();
+    }
+}

spring-5-reactive-2/src/main/java/com/baeldung/validations/functional/handlers/AbstractValidationHandler.java

@@ -0,0 +1,45 @@
+package com.baeldung.validations.functional.handlers;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.validation.BeanPropertyBindingResult;
+import org.springframework.validation.Errors;
+import org.springframework.validation.Validator;
+import org.springframework.web.reactive.function.server.ServerRequest;
+import org.springframework.web.reactive.function.server.ServerResponse;
+import org.springframework.web.server.ResponseStatusException;
+
+import reactor.core.publisher.Mono;
+
+public abstract class AbstractValidationHandler<T, U extends Validator> {
+
+    private final Class<T> validationClass;
+
+    private final U validator;
+
+    protected AbstractValidationHandler(Class<T> clazz, U validator) {
+        this.validationClass = clazz;
+        this.validator = validator;
+    }
+
+    abstract protected Mono<ServerResponse> processBody(T validBody, final ServerRequest originalRequest);
+
+    public final Mono<ServerResponse> handleRequest(final ServerRequest request) {
+        return request.bodyToMono(this.validationClass)
+            .flatMap(body -> {
+                Errors errors = new BeanPropertyBindingResult(body, this.validationClass.getName());
+                this.validator.validate(body, errors);
+
+                if (errors == null || errors.getAllErrors()
+                    .isEmpty()) {
+                    return processBody(body, request);
+                } else {
+                    return onValidationErrors(errors, body, request);
+                }
+            });
+    }
+
+    protected Mono<ServerResponse> onValidationErrors(Errors errors, T invalidBody, final ServerRequest request) {
+        throw new ResponseStatusException(HttpStatus.BAD_REQUEST, errors.getAllErrors()
+            .toString());
+    }
+}

spring-5-reactive-2/src/main/java/com/baeldung/validations/functional/handlers/FunctionalHandler.java

@@ -0,0 +1,43 @@
+package com.baeldung.validations.functional.handlers;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.stereotype.Component;
+import org.springframework.validation.BeanPropertyBindingResult;
+import org.springframework.validation.Errors;
+import org.springframework.validation.Validator;
+import org.springframework.web.reactive.function.server.ServerRequest;
+import org.springframework.web.reactive.function.server.ServerResponse;
+import org.springframework.web.server.ResponseStatusException;
+
+import com.baeldung.validations.functional.model.CustomRequestEntity;
+import com.baeldung.validations.functional.validators.CustomRequestEntityValidator;
+
+import reactor.core.publisher.Mono;
+
+@Component
+public class FunctionalHandler {
+
+    public Mono<ServerResponse> handleRequest(final ServerRequest request) {
+        Validator validator = new CustomRequestEntityValidator();
+        Mono<String> responseBody = request.bodyToMono(CustomRequestEntity.class)
+            .map(body -> {
+                Errors errors = new BeanPropertyBindingResult(body, CustomRequestEntity.class.getName());
+                validator.validate(body, errors);
+
+                if (errors == null || errors.getAllErrors()
+                    .isEmpty()) {
+                    return String.format("Hi, %s [%s]!", body.getName(), body.getCode());
+
+                } else {
+                    throw new ResponseStatusException(HttpStatus.BAD_REQUEST, errors.getAllErrors()
+                        .toString());
+                }
+
+            });
+        return ServerResponse.ok()
+            .contentType(MediaType.APPLICATION_JSON)
+            .body(responseBody, String.class);
+
+    }
+}

spring-5-reactive-2/src/main/java/com/baeldung/validations/functional/handlers/impl/AnnotatedRequestEntityValidationHandler.java

@@ -0,0 +1,29 @@
+package com.baeldung.validations.functional.handlers.impl;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.MediaType;
+import org.springframework.stereotype.Component;
+import org.springframework.validation.Validator;
+import org.springframework.web.reactive.function.server.ServerRequest;
+import org.springframework.web.reactive.function.server.ServerResponse;
+
+import com.baeldung.validations.functional.handlers.AbstractValidationHandler;
+import com.baeldung.validations.functional.model.AnnotatedRequestEntity;
+
+import reactor.core.publisher.Mono;
+
+@Component
+public class AnnotatedRequestEntityValidationHandler extends AbstractValidationHandler<AnnotatedRequestEntity, Validator> {
+
+    private AnnotatedRequestEntityValidationHandler(@Autowired Validator validator) {
+        super(AnnotatedRequestEntity.class, validator);
+    }
+
+    @Override
+    protected Mono<ServerResponse> processBody(AnnotatedRequestEntity validBody, ServerRequest originalRequest) {
+        String responseBody = String.format("Hi, %s. Password: %s!", validBody.getUser(), validBody.getPassword());
+        return ServerResponse.ok()
+            .contentType(MediaType.APPLICATION_JSON)
+            .body(Mono.just(responseBody), String.class);
+    }
+}

spring-5-reactive-2/src/main/java/com/baeldung/validations/functional/handlers/impl/CustomRequestEntityValidationHandler.java

@@ -0,0 +1,37 @@
+package com.baeldung.validations.functional.handlers.impl;
+
+import org.springframework.http.MediaType;
+import org.springframework.stereotype.Component;
+import org.springframework.validation.Errors;
+import org.springframework.web.reactive.function.server.ServerRequest;
+import org.springframework.web.reactive.function.server.ServerResponse;
+
+import com.baeldung.validations.functional.handlers.AbstractValidationHandler;
+import com.baeldung.validations.functional.model.CustomRequestEntity;
+import com.baeldung.validations.functional.validators.CustomRequestEntityValidator;
+
+import reactor.core.publisher.Mono;
+
+@Component
+public class CustomRequestEntityValidationHandler extends AbstractValidationHandler<CustomRequestEntity, CustomRequestEntityValidator> {
+
+    private CustomRequestEntityValidationHandler() {
+        super(CustomRequestEntity.class, new CustomRequestEntityValidator());
+    }
+
+    @Override
+    protected Mono<ServerResponse> processBody(CustomRequestEntity validBody, ServerRequest originalRequest) {
+        String responseBody = String.format("Hi, %s [%s]!", validBody.getName(), validBody.getCode());
+        return ServerResponse.ok()
+            .contentType(MediaType.APPLICATION_JSON)
+            .body(Mono.just(responseBody), String.class);
+    }
+
+    @Override
+    protected Mono<ServerResponse> onValidationErrors(Errors errors, CustomRequestEntity invalidBody, final ServerRequest request) {
+        return ServerResponse.badRequest()
+            .contentType(MediaType.APPLICATION_JSON)
+            .body(Mono.just(String.format("Custom message showing the errors: %s", errors.getAllErrors()
+                .toString())), String.class);
+    }
+}

spring-5-reactive-2/src/main/java/com/baeldung/validations/functional/handlers/impl/OtherEntityValidationHandler.java

@@ -0,0 +1,28 @@
+package com.baeldung.validations.functional.handlers.impl;
+
+import org.springframework.http.MediaType;
+import org.springframework.stereotype.Component;
+import org.springframework.web.reactive.function.server.ServerRequest;
+import org.springframework.web.reactive.function.server.ServerResponse;
+
+import com.baeldung.validations.functional.handlers.AbstractValidationHandler;
+import com.baeldung.validations.functional.model.OtherEntity;
+import com.baeldung.validations.functional.validators.OtherEntityValidator;
+
+import reactor.core.publisher.Mono;
+
+@Component
+public class OtherEntityValidationHandler extends AbstractValidationHandler<OtherEntity, OtherEntityValidator> {
+
+    private OtherEntityValidationHandler() {
+        super(OtherEntity.class, new OtherEntityValidator());
+    }
+
+    @Override
+    protected Mono<ServerResponse> processBody(OtherEntity validBody, ServerRequest originalRequest) {
+        String responseBody = String.format("Other object with item %s and quantity %s!", validBody.getItem(), validBody.getQuantity());
+        return ServerResponse.ok()
+            .contentType(MediaType.APPLICATION_JSON)
+            .body(Mono.just(responseBody), String.class);
+    }
+}

spring-5-reactive-2/src/main/java/com/baeldung/validations/functional/model/AnnotatedRequestEntity.java

@@ -0,0 +1,23 @@
+package com.baeldung.validations.functional.model;
+
+import javax.validation.constraints.NotNull;
+import javax.validation.constraints.Size;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@AllArgsConstructor
+@NoArgsConstructor
+@Getter
+@Setter
+public class AnnotatedRequestEntity {
+    @NotNull
+    private String user;
+
+    @NotNull
+    @Size(min = 4, max = 7)
+    private String password;
+
+}

spring-5-reactive-2/src/main/java/com/baeldung/validations/functional/model/CustomRequestEntity.java

@@ -0,0 +1,17 @@
+package com.baeldung.validations.functional.model;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@AllArgsConstructor
+@NoArgsConstructor
+@Getter
+@Setter
+public class CustomRequestEntity {
+    
+    private String name;
+    private String code;
+    
+}

spring-5-reactive-2/src/main/java/com/baeldung/validations/functional/model/OtherEntity.java

@@ -0,0 +1,17 @@
+package com.baeldung.validations.functional.model;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@AllArgsConstructor
+@NoArgsConstructor
+@Getter
+@Setter
+public class OtherEntity {
+    
+    private String item;
+    private Integer quantity;
+    
+}

spring-5-reactive-2/src/main/java/com/baeldung/validations/functional/routers/ValidationsRouters.java

@@ -0,0 +1,29 @@
+package com.baeldung.validations.functional.routers;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.reactive.function.server.RequestPredicates;
+import org.springframework.web.reactive.function.server.RouterFunction;
+import org.springframework.web.reactive.function.server.RouterFunctions;
+import org.springframework.web.reactive.function.server.ServerResponse;
+
+import com.baeldung.validations.functional.handlers.FunctionalHandler;
+import com.baeldung.validations.functional.handlers.impl.AnnotatedRequestEntityValidationHandler;
+import com.baeldung.validations.functional.handlers.impl.CustomRequestEntityValidationHandler;
+import com.baeldung.validations.functional.handlers.impl.OtherEntityValidationHandler;
+
+@Configuration
+public class ValidationsRouters {
+
+    @Bean
+    public RouterFunction<ServerResponse> validationsRouter(@Autowired CustomRequestEntityValidationHandler dryHandler,
+        @Autowired FunctionalHandler complexHandler,
+        @Autowired OtherEntityValidationHandler otherHandler,
+        @Autowired AnnotatedRequestEntityValidationHandler annotatedEntityHandler) {
+        return RouterFunctions.route(RequestPredicates.POST("/complex-handler-functional-validation"), complexHandler::handleRequest)
+            .andRoute(RequestPredicates.POST("/dry-functional-validation"), dryHandler::handleRequest)
+            .andRoute(RequestPredicates.POST("/other-dry-functional-validation"), otherHandler::handleRequest)
+            .andRoute(RequestPredicates.POST("/annotated-functional-validation"), annotatedEntityHandler::handleRequest);
+    }
+}

spring-5-reactive-2/src/main/java/com/baeldung/validations/functional/validators/CustomRequestEntityValidator.java

@@ -0,0 +1,29 @@
+package com.baeldung.validations.functional.validators;
+
+import org.springframework.validation.Errors;
+import org.springframework.validation.ValidationUtils;
+import org.springframework.validation.Validator;
+
+import com.baeldung.validations.functional.model.CustomRequestEntity;
+
+public class CustomRequestEntityValidator implements Validator {
+
+    private static final int MINIMUM_CODE_LENGTH = 6;
+    
+    @Override
+    public boolean supports(Class<?> clazz) {
+        return CustomRequestEntity.class.isAssignableFrom(clazz);
+    }
+
+    @Override
+    public void validate(Object target, Errors errors) {
+        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "name", "field.required");
+        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "code", "field.required");
+        CustomRequestEntity request = (CustomRequestEntity) target;
+        if (request.getCode() != null && request.getCode()
+            .trim()
+            .length() < MINIMUM_CODE_LENGTH) {
+            errors.rejectValue("code", "field.min.length", new Object[] { Integer.valueOf(MINIMUM_CODE_LENGTH) }, "The code must be at least [" + MINIMUM_CODE_LENGTH + "] characters in length.");
+        }
+    }
+}

spring-5-reactive-2/src/main/java/com/baeldung/validations/functional/validators/OtherEntityValidator.java

@@ -0,0 +1,27 @@
+package com.baeldung.validations.functional.validators;
+
+import org.springframework.validation.Errors;
+import org.springframework.validation.ValidationUtils;
+import org.springframework.validation.Validator;
+
+import com.baeldung.validations.functional.model.OtherEntity;
+
+public class OtherEntityValidator implements Validator {
+
+    private static final int MIN_ITEM_QUANTITY = 1;
+
+    @Override
+    public boolean supports(Class<?> clazz) {
+        return OtherEntity.class.isAssignableFrom(clazz);
+    }
+
+    @Override
+    public void validate(Object target, Errors errors) {
+        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "item", "field.required");
+        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "quantity", "field.required");
+        OtherEntity request = (OtherEntity) target;
+        if (request.getQuantity() != null && request.getQuantity() < MIN_ITEM_QUANTITY) {
+            errors.rejectValue("quantity", "field.min.length", new Object[] { Integer.valueOf(MIN_ITEM_QUANTITY) }, "There must be at least one item");
+        }
+    }
+}

spring-5-reactive-2/src/main/java/com/baeldung/webclient/Tweet.java

@@ -0,0 +1,13 @@
+package com.baeldung.webclient;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class Tweet {
+    private String text;
+    private String username;
+}

spring-5-reactive-2/src/main/java/com/baeldung/webclient/TweetsSlowServiceController.java

@@ -0,0 +1,20 @@
+package com.baeldung.webclient;
+
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.Arrays;
+import java.util.List;
+
+@RestController
+public class TweetsSlowServiceController {
+
+    @GetMapping("/slow-service-tweets")
+    private List<Tweet> getAllTweets() throws Exception {
+        Thread.sleep(2000L); // delay
+        return Arrays.asList(
+          new Tweet("RestTemplate rules", "@user1"),
+          new Tweet("WebClient is better", "@user2"),
+          new Tweet("OK, both are useful", "@user1"));
+    }
+}

spring-5-reactive-2/src/main/java/com/baeldung/webclient/WebClientApplication.java

@@ -0,0 +1,23 @@
+package com.baeldung.webclient;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.Bean;
+import org.springframework.security.config.web.server.ServerHttpSecurity;
+import org.springframework.security.web.server.SecurityWebFilterChain;
+
+@SpringBootApplication
+public class WebClientApplication {
+    public static void main(String[] args) {
+        SpringApplication.run(WebClientApplication.class, args);
+    }
+    
+    @Bean
+    public SecurityWebFilterChain functionalValidationsSpringSecurityFilterChain(ServerHttpSecurity http) {
+        http.authorizeExchange()
+            .anyExchange()
+            .permitAll();
+        http.csrf().disable();
+        return http.build();
+    }
+}

spring-5-reactive-2/src/main/java/com/baeldung/webclient/WebController.java

@@ -0,0 +1,60 @@
+package com.baeldung.webclient;
+
+import lombok.Setter;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.core.ParameterizedTypeReference;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.client.RestTemplate;
+import org.springframework.web.reactive.function.client.WebClient;
+import reactor.core.publisher.Flux;
+
+import java.util.List;
+
+@Slf4j
+@RestController
+public class WebController {
+
+    private static final int DEFAULT_PORT = 8080;
+
+    @Setter
+    private int serverPort = DEFAULT_PORT;
+
+    @GetMapping("/tweets-blocking")
+    public List<Tweet> getTweetsBlocking() {
+        log.info("Starting BLOCKING Controller!");
+        final String uri = getSlowServiceUri();
+
+        RestTemplate restTemplate = new RestTemplate();
+        ResponseEntity<List<Tweet>> response = restTemplate.exchange(
+          uri, HttpMethod.GET, null,
+          new ParameterizedTypeReference<List<Tweet>>(){});
+
+        List<Tweet> result = response.getBody();
+        result.forEach(tweet -> log.info(tweet.toString()));
+        log.info("Exiting BLOCKING Controller!");
+        return result;
+    }
+
+    @GetMapping(value = "/tweets-non-blocking", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
+    public Flux<Tweet> getTweetsNonBlocking() {
+        log.info("Starting NON-BLOCKING Controller!");
+        Flux<Tweet> tweetFlux = WebClient.create()
+          .get()
+          .uri(getSlowServiceUri())
+          .retrieve()
+          .bodyToFlux(Tweet.class);
+
+        tweetFlux.subscribe(tweet -> log.info(tweet.toString()));
+        log.info("Exiting NON-BLOCKING Controller!");
+        return tweetFlux;
+    }
+
+    private String getSlowServiceUri() {
+        return "http://localhost:" + serverPort + "/slow-service-tweets";
+    }
+
+}

spring-5-reactive-2/src/main/java/com/baeldung/webclient/filter/WebClientFilters.java

@@ -0,0 +1,57 @@
+package com.baeldung.webclient.filter;
+
+import java.io.PrintStream;
+import java.net.URI;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.HttpMethod;
+import org.springframework.web.reactive.function.client.ClientRequest;
+import org.springframework.web.reactive.function.client.ExchangeFilterFunction;
+
+public class WebClientFilters {
+
+    private static final Logger LOG = LoggerFactory.getLogger(WebClientFilters.class);
+
+    public static ExchangeFilterFunction demoFilter() {
+        ExchangeFilterFunction filterFunction = (clientRequest, nextFilter) -> {
+            LOG.info("WebClient fitler executed");
+            return nextFilter.exchange(clientRequest);
+        };
+        return filterFunction;
+    }
+
+    public static ExchangeFilterFunction countingFilter(AtomicInteger getCounter) {
+        ExchangeFilterFunction countingFilter = (clientRequest, nextFilter) -> {
+            HttpMethod httpMethod = clientRequest.method();
+            if (httpMethod == HttpMethod.GET) {
+                getCounter.incrementAndGet();
+            }
+            return nextFilter.exchange(clientRequest);
+        };
+        return countingFilter;
+    }
+
+    public static ExchangeFilterFunction urlModifyingFilter(String version) {
+        ExchangeFilterFunction urlModifyingFilter = (clientRequest, nextFilter) -> {
+            String oldUrl = clientRequest.url()
+                .toString();
+            URI newUrl = URI.create(oldUrl + "/" + version);
+            ClientRequest filteredRequest = ClientRequest.from(clientRequest)
+                .url(newUrl)
+                .build();
+            return nextFilter.exchange(filteredRequest);
+        };
+        return urlModifyingFilter;
+    }
+
+    public static ExchangeFilterFunction loggingFilter(PrintStream printStream) {
+        ExchangeFilterFunction loggingFilter = (clientRequest, nextFilter) -> {
+            printStream.print("Sending request " + clientRequest.method() + " " + clientRequest.url());
+            return nextFilter.exchange(clientRequest);
+        };
+        return loggingFilter;
+    }
+
+}

spring-5-reactive-2/src/main/java/com/baeldung/webflux/logging/WebFluxLoggingExample.java

@@ -0,0 +1,21 @@
+package com.baeldung.webflux.logging;
+
+import reactor.core.publisher.Flux;
+
+public class WebFluxLoggingExample {
+
+    public static void main(String[] args) {
+        Flux<Integer> reactiveStream = Flux.range(1, 5).log();
+
+        reactiveStream.subscribe();
+
+        reactiveStream = Flux.range(1, 5).log().take(3);
+
+        reactiveStream.subscribe();
+
+        reactiveStream = Flux.range(1, 5).take(3).log();
+
+        reactiveStream.subscribe();
+    }
+
+}