move to reactive, extract mongodb ex

spring-5-mongodb/.gitignore

@@ -0,0 +1,12 @@
+#folders#
+.idea
+/target
+/neoDb*
+/data
+/src/main/webapp/WEB-INF/classes
+*/META-INF/*
+
+# Packaged files #
+*.jar
+*.war
+*.ear

spring-5-mongodb/README.md

@@ -0,0 +1,20 @@
+## Spring REST Example Project
+
+### The Course
+The "REST With Spring" Classes: http://bit.ly/restwithspring
+
+### Relevant Articles
+
+- [Concurrent Test Execution in Spring 5](http://www.baeldung.com/spring-5-concurrent-tests)
+- [Introduction to the Functional Web Framework in Spring 5](http://www.baeldung.com/spring-5-functional-web)
+- [Exploring the Spring 5 MVC URL Matching Improvements](http://www.baeldung.com/spring-5-mvc-url-matching)
+- [Spring 5 WebClient](http://www.baeldung.com/spring-5-webclient)
+- [Spring 5 Functional Bean Registration](http://www.baeldung.com/spring-5-functional-beans)
+- [The SpringJUnitConfig and SpringJUnitWebConfig Annotations in Spring 5](http://www.baeldung.com/spring-5-junit-config)
+- [Spring Security 5 for Reactive Applications](http://www.baeldung.com/spring-security-5-reactive)
+- [Spring 5 Testing with @EnabledIf Annotation](https://github.com/eugenp/tutorials/tree/master/spring-5)
+- [Reactive WebSockets with Spring 5](http://www.baeldung.com/spring-5-reactive-websockets)
+- [Spring Boot Actuator](http://www.baeldung.com/spring-boot-actuators)
+- [Spring Webflux Filters](http://www.baeldung.com/spring-webflux-filters)
+- [Reactive Flow with MongoDB, Kotlin, and Spring WebFlux](http://www.baeldung.com/kotlin-mongodb-spring-webflux)
+- [Spring Data Reactive Repositories with MongoDB](http://www.baeldung.com/spring-data-mongodb-reactive)

spring-5-mongodb/pom.xml

@@ -0,0 +1,157 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.baeldung</groupId>
+    <artifactId>spring-5-mongodb</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <packaging>jar</packaging>
+    <name>spring-5-mongodb</name>
+    <description>spring 5 mongodb sample project</description>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-boot-2</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+        <relativePath>../parent-boot-2</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-validation</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-tomcat</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-webflux</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.projectreactor</groupId>
+            <artifactId>reactor-spring</artifactId>
+            <version>${reactor-spring.version}</version>
+        </dependency>
+        <!-- utils -->
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+        </dependency>
+
+        <!-- runtime and test scoped -->
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-test</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-collections4</artifactId>
+            <version>${commons-collections4.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <scope>compile</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-engine</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.platform</groupId>
+            <artifactId>junit-platform-surefire-provider</artifactId>
+            <version>${junit.platform.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.platform</groupId>
+            <artifactId>junit-platform-runner</artifactId>
+            <version>${junit.platform.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-mongodb-reactive</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>de.flapdoodle.embed</groupId>
+            <artifactId>de.flapdoodle.embed.mongo</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.reactivex.rxjava2</groupId>
+            <artifactId>rxjava</artifactId>
+            <version>${rxjava-version}</version>
+        </dependency>
+        <dependency>
+            <groupId>io.projectreactor</groupId>
+            <artifactId>reactor-test</artifactId>
+            <version>${project-reactor-test}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <configuration>
+                    <mainClass>com.baeldung.reactive.Spring5ReactiveApplication</mainClass>
+                    <layout>JAR</layout>
+                </configuration>
+            </plugin>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <configuration>
+                    <forkCount>3</forkCount>
+                    <reuseForks>true</reuseForks>
+                    <parallel>methods</parallel>
+                    <useUnlimitedThreads>true</useUnlimitedThreads>
+                    <excludes>
+                        <exclude>**/*IntegrationTest.java</exclude>
+                        <exclude>**/*IntTest.java</exclude>
+                        <exclude>**/*LiveTest.java</exclude>
+                    </excludes>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <junit.platform.version>1.0.0</junit.platform.version>
+        <junit.jupiter.version>5.0.2</junit.jupiter.version>
+        <maven-surefire-plugin.version>2.20</maven-surefire-plugin.version>
+        <reactor-spring.version>1.0.1.RELEASE</reactor-spring.version>
+        <rxjava-version>2.1.12</rxjava-version>
+        <commons-collections4.version>4.1</commons-collections4.version>
+        <project-reactor-test>3.1.6.RELEASE</project-reactor-test>
+          <johnzon.version>1.1.3</johnzon.version>
+        <jsonb-api.version>1.0</jsonb-api.version>
+        <geronimo-json_1.1_spec.version>1.0</geronimo-json_1.1_spec.version>
+    </properties>
+
+</project>

spring-5-mongodb/src/main/java/com/baeldung/reactive/Spring5ReactiveApplication.java

@@ -0,0 +1,25 @@
+package com.baeldung.reactive;
+
+import com.mongodb.reactivestreams.client.MongoClient;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.Bean;
+import org.springframework.data.mongodb.core.ReactiveMongoTemplate;
+
+@SpringBootApplication
+public class Spring5ReactiveApplication{
+
+    public static void main(String[] args) {
+        SpringApplication.run(Spring5ReactiveApplication.class, args);
+    }
+
+    @Autowired
+    MongoClient mongoClient;
+
+    @Bean
+    public ReactiveMongoTemplate reactiveMongoTemplate() {
+        return new ReactiveMongoTemplate(mongoClient, "test");
+    }
+
+}

spring-5-mongodb/src/main/resources/application.properties

@@ -0,0 +1,5 @@
+logging.level.root=INFO
+
+management.endpoints.web.exposure.include.=*
+
+info.app.name=Spring Boot 2 actuator Application

spring-5-mongodb/src/main/webapp/WEB-INF/web.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
+         version="3.1">
+
+    <display-name>Spring Functional Application</display-name>
+
+    <servlet>
+        <servlet-name>functional</servlet-name>
+        <servlet-class>com.baeldung.functional.RootServlet</servlet-class>
+        <load-on-startup>1</load-on-startup>
+        <async-supported>true</async-supported>
+    </servlet>
+    <servlet-mapping>
+        <servlet-name>functional</servlet-name>
+        <url-pattern>/</url-pattern>
+    </servlet-mapping>
+
+
+</web-app>

spring-5-reactive/pom.xml

@@ -127,15 +127,6 @@
             <artifactId>commons-lang3</artifactId>
         </dependency>
 
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-data-mongodb-reactive</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>de.flapdoodle.embed</groupId>
-            <artifactId>de.flapdoodle.embed.mongo</artifactId>
-            <scope>test</scope>
-        </dependency>
         <dependency>
             <groupId>io.reactivex.rxjava2</groupId>
             <artifactId>rxjava</artifactId>

spring-5-reactive/src/main/java/com/baeldung/functional/Actor.java

@@ -0,0 +1,23 @@
+package com.baeldung.functional;
+
+class Actor {
+    private String firstname;
+    private String lastname;
+
+    public Actor() {
+    }
+
+    public Actor(String firstname, String lastname) {
+        this.firstname = firstname;
+        this.lastname = lastname;
+    }
+
+    public String getFirstname() {
+        return firstname;
+    }
+
+    public String getLastname() {
+        return lastname;
+    }
+
+}

spring-5-reactive/src/main/java/com/baeldung/functional/FormHandler.java

@@ -0,0 +1,41 @@
+package com.baeldung.functional;
+
+import org.springframework.core.io.buffer.DataBuffer;
+import org.springframework.util.MultiValueMap;
+import org.springframework.web.reactive.function.server.ServerRequest;
+import org.springframework.web.reactive.function.server.ServerResponse;
+import reactor.core.publisher.Mono;
+
+import java.util.List;
+import java.util.concurrent.atomic.AtomicLong;
+
+import static org.springframework.web.reactive.function.BodyExtractors.toDataBuffers;
+import static org.springframework.web.reactive.function.BodyExtractors.toFormData;
+import static org.springframework.web.reactive.function.BodyInserters.fromObject;
+import static org.springframework.web.reactive.function.server.ServerResponse.ok;
+
+public class FormHandler {
+
+    Mono<ServerResponse> handleLogin(ServerRequest request) {
+        return request.body(toFormData())
+            .map(MultiValueMap::toSingleValueMap)
+            .filter(formData -> "baeldung".equals(formData.get("user")))
+            .filter(formData -> "you_know_what_to_do".equals(formData.get("token")))
+            .flatMap(formData -> ok().body(Mono.just("welcome back!"), String.class))
+            .switchIfEmpty(ServerResponse.badRequest()
+                .build());
+    }
+
+    Mono<ServerResponse> handleUpload(ServerRequest request) {
+        return request.body(toDataBuffers())
+            .collectList()
+            .flatMap(dataBuffers -> ok().body(fromObject(extractData(dataBuffers).toString())));
+    }
+
+    private AtomicLong extractData(List<DataBuffer> dataBuffers) {
+        AtomicLong atomicLong = new AtomicLong(0);
+        dataBuffers.forEach(d -> atomicLong.addAndGet(d.asByteBuffer()
+            .array().length));
+        return atomicLong;
+    }
+}

spring-5-reactive/src/main/java/com/baeldung/functional/FunctionalSpringBootApplication.java

@@ -0,0 +1,87 @@
+package com.baeldung.functional;
+
+import static org.springframework.web.reactive.function.BodyInserters.fromObject;
+import static org.springframework.web.reactive.function.server.RequestPredicates.GET;
+import static org.springframework.web.reactive.function.server.RequestPredicates.POST;
+import static org.springframework.web.reactive.function.server.RequestPredicates.path;
+import static org.springframework.web.reactive.function.server.RouterFunctions.route;
+import static org.springframework.web.reactive.function.server.RouterFunctions.toHttpHandler;
+import static org.springframework.web.reactive.function.server.ServerResponse.ok;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.web.servlet.ServletRegistrationBean;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Profile;
+import org.springframework.core.io.ClassPathResource;
+import org.springframework.http.server.reactive.HttpHandler;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
+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 org.springframework.web.server.WebHandler;
+import org.springframework.web.server.adapter.WebHttpHandlerBuilder;
+
+import reactor.core.publisher.Flux;
+
+@SpringBootApplication
+@ComponentScan(basePackages = { "com.baeldung.functional" })
+public class FunctionalSpringBootApplication {
+
+    private static final Actor BRAD_PITT = new Actor("Brad", "Pitt");
+    private static final Actor TOM_HANKS = new Actor("Tom", "Hanks");
+    private static final List<Actor> actors = new CopyOnWriteArrayList<>(Arrays.asList(BRAD_PITT, TOM_HANKS));
+
+    private RouterFunction<ServerResponse> routingFunction() {
+        FormHandler formHandler = new FormHandler();
+
+        RouterFunction<ServerResponse> restfulRouter = route(GET("/"), serverRequest -> ok().body(Flux.fromIterable(actors), Actor.class)).andRoute(POST("/"), serverRequest -> serverRequest.bodyToMono(Actor.class)
+            .doOnNext(actors::add)
+            .then(ok().build()));
+
+        return route(GET("/test"), serverRequest -> ok().body(fromObject("helloworld"))).andRoute(POST("/login"), formHandler::handleLogin)
+            .andRoute(POST("/upload"), formHandler::handleUpload)
+            .and(RouterFunctions.resources("/files/**", new ClassPathResource("files/")))
+            .andNest(path("/actor"), restfulRouter)
+            .filter((request, next) -> {
+                System.out.println("Before handler invocation: " + request.path());
+                return next.handle(request);
+            });
+    }
+
+    @Bean
+    public ServletRegistrationBean servletRegistrationBean() throws Exception {
+        HttpHandler httpHandler = WebHttpHandlerBuilder.webHandler((WebHandler) toHttpHandler(routingFunction()))
+            .filter(new IndexRewriteFilter())
+            .build();
+        ServletRegistrationBean registrationBean = new ServletRegistrationBean<>(new RootServlet(httpHandler), "/");
+        registrationBean.setLoadOnStartup(1);
+        registrationBean.setAsyncSupported(true);
+        return registrationBean;
+    }
+
+    @Configuration
+    @EnableWebSecurity
+    @Profile("!https")
+    static class SecurityConfig extends WebSecurityConfigurerAdapter {
+        @Override
+        protected void configure(final HttpSecurity http) throws Exception {
+            http.authorizeRequests()
+                .anyRequest()
+                .permitAll();
+        }
+    }
+
+    public static void main(String[] args) {
+        SpringApplication.run(FunctionalSpringBootApplication.class, args);
+    }
+
+}

spring-5-reactive/src/main/java/com/baeldung/functional/FunctionalWebApplication.java

@@ -0,0 +1,80 @@
+package com.baeldung.functional;
+
+import static org.springframework.web.reactive.function.BodyInserters.fromObject;
+import static org.springframework.web.reactive.function.server.RequestPredicates.GET;
+import static org.springframework.web.reactive.function.server.RequestPredicates.POST;
+import static org.springframework.web.reactive.function.server.RequestPredicates.path;
+import static org.springframework.web.reactive.function.server.RouterFunctions.route;
+import static org.springframework.web.reactive.function.server.RouterFunctions.toHttpHandler;
+import static org.springframework.web.reactive.function.server.ServerResponse.ok;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+import org.apache.catalina.Context;
+import org.apache.catalina.startup.Tomcat;
+import org.springframework.boot.web.embedded.tomcat.TomcatWebServer;
+import org.springframework.boot.web.server.WebServer;
+import org.springframework.core.io.ClassPathResource;
+import org.springframework.http.server.reactive.HttpHandler;
+import org.springframework.http.server.reactive.ServletHttpHandlerAdapter;
+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 org.springframework.web.server.WebHandler;
+import org.springframework.web.server.adapter.WebHttpHandlerBuilder;
+
+import reactor.core.publisher.Flux;
+
+public class FunctionalWebApplication {
+
+    private static final Actor BRAD_PITT = new Actor("Brad", "Pitt");
+    private static final Actor TOM_HANKS = new Actor("Tom", "Hanks");
+    private static final List<Actor> actors = new CopyOnWriteArrayList<>(Arrays.asList(BRAD_PITT, TOM_HANKS));
+
+    private RouterFunction<ServerResponse> routingFunction() {
+        FormHandler formHandler = new FormHandler();
+
+        RouterFunction<ServerResponse> restfulRouter = route(GET("/"), serverRequest -> ok().body(Flux.fromIterable(actors), Actor.class)).andRoute(POST("/"), serverRequest -> serverRequest.bodyToMono(Actor.class)
+            .doOnNext(actors::add)
+            .then(ok().build()));
+
+        return route(GET("/test"), serverRequest -> ok().body(fromObject("helloworld"))).andRoute(POST("/login"), formHandler::handleLogin)
+            .andRoute(POST("/upload"), formHandler::handleUpload)
+            .and(RouterFunctions.resources("/files/**", new ClassPathResource("files/")))
+            .andNest(path("/actor"), restfulRouter)
+            .filter((request, next) -> {
+                System.out.println("Before handler invocation: " + request.path());
+                return next.handle(request);
+            });
+    }
+
+    WebServer start() throws Exception {
+        WebHandler webHandler = (WebHandler) toHttpHandler(routingFunction());
+        HttpHandler httpHandler = WebHttpHandlerBuilder.webHandler(webHandler)
+            .filter(new IndexRewriteFilter())
+            .build();
+
+        Tomcat tomcat = new Tomcat();
+        tomcat.setHostname("localhost");
+        tomcat.setPort(9090);
+        Context rootContext = tomcat.addContext("", System.getProperty("java.io.tmpdir"));
+        ServletHttpHandlerAdapter servlet = new ServletHttpHandlerAdapter(httpHandler);
+        Tomcat.addServlet(rootContext, "httpHandlerServlet", servlet);
+        rootContext.addServletMappingDecoded("/", "httpHandlerServlet");
+
+        TomcatWebServer server = new TomcatWebServer(tomcat);
+        server.start();
+        return server;
+
+    }
+
+    public static void main(String[] args) {
+        try {
+            new FunctionalWebApplication().start();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}

spring-5-reactive/src/main/java/com/baeldung/functional/IndexRewriteFilter.java

@@ -0,0 +1,25 @@
+package com.baeldung.functional;
+
+import org.springframework.http.server.reactive.ServerHttpRequest;
+import org.springframework.web.server.ServerWebExchange;
+import org.springframework.web.server.WebFilter;
+import org.springframework.web.server.WebFilterChain;
+import reactor.core.publisher.Mono;
+
+class IndexRewriteFilter implements WebFilter {
+
+    @Override
+    public Mono<Void> filter(ServerWebExchange serverWebExchange, WebFilterChain webFilterChain) {
+        ServerHttpRequest request = serverWebExchange.getRequest();
+        if (request.getURI()
+            .getPath()
+            .equals("/")) {
+            return webFilterChain.filter(serverWebExchange.mutate()
+                .request(builder -> builder.method(request.getMethod())
+                    .path("/test"))
+                .build());
+        }
+        return webFilterChain.filter(serverWebExchange);
+    }
+
+}

spring-5-reactive/src/main/java/com/baeldung/functional/MyService.java

@@ -0,0 +1,11 @@
+package com.baeldung.functional;
+
+import java.util.Random;
+
+public class MyService {
+
+    public int getRandomNumber() {
+        return (new Random().nextInt(10));
+    }
+
+}

spring-5-reactive/src/main/java/com/baeldung/functional/RootServlet.java

@@ -0,0 +1,82 @@
+package com.baeldung.functional;
+
+import static org.springframework.web.reactive.function.BodyExtractors.toDataBuffers;
+import static org.springframework.web.reactive.function.BodyExtractors.toFormData;
+import static org.springframework.web.reactive.function.BodyInserters.fromObject;
+import static org.springframework.web.reactive.function.server.RequestPredicates.GET;
+import static org.springframework.web.reactive.function.server.RequestPredicates.POST;
+import static org.springframework.web.reactive.function.server.RequestPredicates.path;
+import static org.springframework.web.reactive.function.server.RouterFunctions.route;
+import static org.springframework.web.reactive.function.server.RouterFunctions.toHttpHandler;
+import static org.springframework.web.reactive.function.server.ServerResponse.ok;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicLong;
+
+import org.springframework.core.io.ClassPathResource;
+import org.springframework.http.server.reactive.HttpHandler;
+import org.springframework.http.server.reactive.ServletHttpHandlerAdapter;
+import org.springframework.util.MultiValueMap;
+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 org.springframework.web.server.WebHandler;
+import org.springframework.web.server.adapter.WebHttpHandlerBuilder;
+
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+public class RootServlet extends ServletHttpHandlerAdapter {
+
+    public RootServlet() {
+        this(WebHttpHandlerBuilder.webHandler((WebHandler) toHttpHandler(routingFunction()))
+            .filter(new IndexRewriteFilter())
+            .build());
+    }
+
+    RootServlet(HttpHandler httpHandler) {
+        super(httpHandler);
+    }
+
+    private static final Actor BRAD_PITT = new Actor("Brad", "Pitt");
+    private static final Actor TOM_HANKS = new Actor("Tom", "Hanks");
+    private static final List<Actor> actors = new CopyOnWriteArrayList<>(Arrays.asList(BRAD_PITT, TOM_HANKS));
+
+    private static RouterFunction<?> routingFunction() {
+
+        return route(GET("/test"), serverRequest -> ok().body(fromObject("helloworld"))).andRoute(POST("/login"), serverRequest -> serverRequest.body(toFormData())
+            .map(MultiValueMap::toSingleValueMap)
+            .map(formData -> {
+                System.out.println("form data: " + formData.toString());
+                if ("baeldung".equals(formData.get("user")) && "you_know_what_to_do".equals(formData.get("token"))) {
+                    return ok().body(Mono.just("welcome back!"), String.class)
+                        .block();
+                }
+                return ServerResponse.badRequest()
+                    .build()
+                    .block();
+            }))
+            .andRoute(POST("/upload"), serverRequest -> serverRequest.body(toDataBuffers())
+                .collectList()
+                .map(dataBuffers -> {
+                    AtomicLong atomicLong = new AtomicLong(0);
+                    dataBuffers.forEach(d -> atomicLong.addAndGet(d.asByteBuffer()
+                        .array().length));
+                    System.out.println("data length:" + atomicLong.get());
+                    return ok().body(fromObject(atomicLong.toString()))
+                        .block();
+                }))
+            .and(RouterFunctions.resources("/files/**", new ClassPathResource("files/")))
+            .andNest(path("/actor"), route(GET("/"), serverRequest -> ok().body(Flux.fromIterable(actors), Actor.class)).andRoute(POST("/"), serverRequest -> serverRequest.bodyToMono(Actor.class)
+                .doOnNext(actors::add)
+                .then(ok().build())))
+            .filter((request, next) -> {
+                System.out.println("Before handler invocation: " + request.path());
+                return next.handle(request);
+            });
+
+    }
+
+}

spring-5-reactive/src/main/java/com/baeldung/reactive/Spring5ReactiveApplication.java

@@ -1,11 +1,9 @@
 package com.baeldung.reactive;
 
-import com.mongodb.reactivestreams.client.MongoClient;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.context.annotation.Bean;
-import org.springframework.data.mongodb.core.ReactiveMongoTemplate;
 
 @SpringBootApplication
 public class Spring5ReactiveApplication{
@@ -14,12 +12,4 @@ public class Spring5ReactiveApplication{
         SpringApplication.run(Spring5ReactiveApplication.class, args);
     }
 
-    @Autowired
-    MongoClient mongoClient;
-
-    @Bean
-    public ReactiveMongoTemplate reactiveMongoTemplate() {
-        return new ReactiveMongoTemplate(mongoClient, "test");
-    }
-
 }

spring-5-reactive/src/main/java/com/baeldung/reactive/SpringSecurity5Application.java

@@ -0,0 +1,34 @@
+package com.baeldung.reactive;
+
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.http.server.reactive.HttpHandler;
+import org.springframework.http.server.reactive.ReactorHttpHandlerAdapter;
+import org.springframework.web.reactive.config.EnableWebFlux;
+import org.springframework.web.server.adapter.WebHttpHandlerBuilder;
+import reactor.ipc.netty.NettyContext;
+import reactor.ipc.netty.http.server.HttpServer;
+
+@ComponentScan(basePackages = {"com.baeldung.security"})
+@EnableWebFlux
+public class SpringSecurity5Application {
+
+    public static void main(String[] args) {
+        try (AnnotationConfigApplicationContext context =
+                     new AnnotationConfigApplicationContext(SpringSecurity5Application.class)) {
+            context.getBean(NettyContext.class).onClose().block();
+        }
+    }
+
+    @Bean
+    public NettyContext nettyContext(ApplicationContext context) {
+        HttpHandler handler = WebHttpHandlerBuilder.applicationContext(context)
+                .build();
+        ReactorHttpHandlerAdapter adapter = new ReactorHttpHandlerAdapter(handler);
+        HttpServer httpServer = HttpServer.create("localhost", 8080);
+        return httpServer.newHandler(adapter).block();
+    }
+
+}

spring-5-reactive/src/main/java/com/baeldung/reactive/actuator/WebSecurityConfig.java

@@ -0,0 +1,28 @@
+package com.baeldung.reactive.actuator;
+
+import org.springframework.boot.actuate.autoconfigure.security.reactive.EndpointRequest;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
+import org.springframework.security.config.annotation.web.reactive.EnableWebFluxSecurity;
+import org.springframework.security.config.web.server.ServerHttpSecurity;
+import org.springframework.security.web.server.SecurityWebFilterChain;
+
+@Configuration
+@EnableWebFluxSecurity
+public class WebSecurityConfig {
+ 
+    
+    @Bean
+    public SecurityWebFilterChain securitygWebFilterChain(
+      ServerHttpSecurity http) {
+        return  http
+     
+            .authorizeExchange()
+                .matchers(EndpointRequest.to(
+                       FeaturesEndpoint.class
+                )).permitAll().and().csrf().disable().build();
+    }
+    
+}

spring-5-reactive/src/main/java/com/baeldung/reactive/cors/annotated/CorsOnAnnotatedElementsApplication.java

@@ -4,16 +4,8 @@ import java.util.Collections;
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
-import org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration;
-import org.springframework.boot.autoconfigure.data.mongo.MongoReactiveDataAutoConfiguration;
-import org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration;
-import org.springframework.boot.autoconfigure.mongo.MongoReactiveAutoConfiguration;
 
-@SpringBootApplication(exclude = { MongoAutoConfiguration.class,
-        MongoDataAutoConfiguration.class,
-        MongoReactiveDataAutoConfiguration.class,
-        MongoReactiveAutoConfiguration.class }
-)
+@SpringBootApplication
 public class CorsOnAnnotatedElementsApplication {
 
     public static void main(String[] args) {

spring-5-reactive/src/main/java/com/baeldung/reactive/cors/webfilter/controllers/FurtherCorsConfigsController.java

@@ -8,8 +8,8 @@ import org.springframework.web.bind.annotation.RestController;
 
 import reactor.core.publisher.Mono;
 
-@RestController
-@RequestMapping("/web-filter-and-more-on-annotated")
+//@RestController
+//@RequestMapping("/web-filter-and-more-on-annotated")
 public class FurtherCorsConfigsController {
 
     @DeleteMapping("/further-mixed-config-endpoint")

spring-5-reactive/src/main/java/com/baeldung/reactive/cors/webfilter/controllers/RegularRestController.java

@@ -7,8 +7,8 @@ import org.springframework.web.bind.annotation.RestController;
 
 import reactor.core.publisher.Mono;
 
-@RestController
-@RequestMapping("/web-filter-on-annotated")
+//@RestController
+//@RequestMapping("/web-filter-on-annotated")
 public class RegularRestController {
 
     @PutMapping("/regular-put-endpoint")

spring-5-reactive/src/main/java/com/baeldung/reactive/security/GreetController.java

@@ -0,0 +1,37 @@
+package com.baeldung.reactive.security;
+
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+import reactor.core.publisher.Mono;
+
+import java.security.Principal;
+
+@RestController
+public class GreetController {
+
+    private GreetService greetService;
+
+    public GreetController(GreetService greetService) {
+        this.greetService = greetService;
+    }
+
+    @GetMapping("/")
+    public Mono<String> greet(Mono<Principal> principal) {
+        return principal
+                .map(Principal::getName)
+                .map(name -> String.format("Hello, %s", name));
+    }
+
+    @GetMapping("/admin")
+    public Mono<String> greetAdmin(Mono<Principal> principal) {
+        return principal
+                .map(Principal::getName)
+                .map(name -> String.format("Admin access: %s", name));
+    }
+
+    @GetMapping("/greetService")
+    public Mono<String> greetService() {
+        return greetService.greet();
+    }
+
+}