L22-webflux

2023-03/spring-22-webflux/.gitignore

@@ -0,0 +1,4 @@
+.idea/
+*.iml
+
+target/

2023-03/spring-22-webflux/HttpRequests.http

@@ -0,0 +1,42 @@
+###
+GET http://localhost:8080/flux/one
+Accept: */*
+Content-Type: application/json
+Cache-Control: no-cache
+
+###
+GET http://localhost:8080/flux/ten
+Accept: */*
+Content-Type: application/json
+Cache-Control: no-cache
+
+###
+GET http://localhost:8080/stream
+Accept: */*
+Content-Type: application/json
+Cache-Control: no-cache
+
+###
+GET http://localhost:8080/person
+Accept: */*
+Content-Type: application/json
+Cache-Control: no-cache
+
+###
+GET http://localhost:8080/person/1
+Accept: */*
+Content-Type: application/json
+Cache-Control: no-cache
+
+###
+GET http://localhost:8080/func/person?name=Lermontov
+Accept: */*
+Content-Type: application/json
+Cache-Control: no-cache
+
+###
+GET http://localhost:8080/func/person?age=22
+Accept: */*
+Content-Type: application/json
+Cache-Control: no-cache
+

2023-03/spring-22-webflux/docker/runDb.src

@@ -0,0 +1,6 @@
+docker run --rm --name pg-docker \
+-e POSTGRES_PASSWORD=pwd \
+-e POSTGRES_USER=usr \
+-e POSTGRES_DB=demoDB \
+-p 5430:5432 \
+postgres:13

2023-03/spring-22-webflux/pom.xml

@@ -0,0 +1,77 @@
+<?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>ru.otus</groupId>
+    <artifactId>spring-22-webflux</artifactId>
+    <version>1.0</version>
+
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>3.1.0</version>
+    </parent>
+
+    <properties>
+        <maven.compiler.source>17</maven.compiler.source>
+        <maven.compiler.target>17</maven.compiler.target>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-webflux</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-jdbc</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-r2dbc</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.flywaydb</groupId>
+            <artifactId>flyway-core</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>io.r2dbc</groupId>
+            <artifactId>r2dbc-postgresql</artifactId>
+            <version>0.8.13.RELEASE</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.postgresql</groupId>
+            <artifactId>postgresql</artifactId>
+            <version>42.6.0</version>
+        </dependency>
+
+
+        <!-- Тестирование -->
+        <dependency>
+            <groupId>io.projectreactor</groupId>
+            <artifactId>reactor-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+</project>

2023-03/spring-22-webflux/src/main/java/ru/otus/spring/DataFiller.java

@@ -0,0 +1,30 @@
+package ru.otus.spring;
+
+import java.util.Arrays;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.boot.ApplicationArguments;
+import org.springframework.boot.ApplicationRunner;
+import org.springframework.stereotype.Component;
+import ru.otus.spring.domain.Person;
+import ru.otus.spring.repository.PersonRepository;
+
+@Component
+public class DataFiller implements ApplicationRunner {
+    private static final Logger logger = LoggerFactory.getLogger(DataFiller.class);
+
+    private final PersonRepository personRepository;
+
+    public DataFiller(PersonRepository personRepository) {
+        this.personRepository = personRepository;
+    }
+
+    @Override
+    public void run(ApplicationArguments args) {
+        personRepository.saveAll(Arrays.asList(
+                new Person("Pushkin", 22),
+                new Person("Lermontov", 22),
+                new Person("Tolstoy", 60)
+        )).subscribe(savedPerson -> logger.info("saved person:{}", savedPerson));
+    }
+}

2023-03/spring-22-webflux/src/main/java/ru/otus/spring/FunctionalEndpointsConfig.java

@@ -0,0 +1,68 @@
+package ru.otus.spring;
+
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.reactive.function.server.RouterFunction;
+import org.springframework.web.reactive.function.server.ServerRequest;
+import org.springframework.web.reactive.function.server.ServerResponse;
+import reactor.core.publisher.Mono;
+import ru.otus.spring.domain.Person;
+import ru.otus.spring.repository.PersonRepository;
+
+import static org.springframework.http.MediaType.APPLICATION_JSON;
+import static org.springframework.web.reactive.function.BodyInserters.fromValue;
+import static org.springframework.web.reactive.function.server.RequestPredicates.accept;
+import static org.springframework.web.reactive.function.server.RequestPredicates.queryParam;
+import static org.springframework.web.reactive.function.server.RouterFunctions.route;
+import static org.springframework.web.reactive.function.server.ServerResponse.badRequest;
+import static org.springframework.web.reactive.function.server.ServerResponse.notFound;
+import static org.springframework.web.reactive.function.server.ServerResponse.ok;
+
+@Configuration
+public class FunctionalEndpointsConfig {
+    @Bean
+    public RouterFunction<ServerResponse> composedRoutes(PersonRepository repository) {
+        return route()
+                // эта функция должна стоять раньше findAll - порядок следования роутов - важен
+                .GET("/func/person",
+                        queryParam("name", StringUtils::isNotEmpty),
+                        request -> request.queryParam("name")
+                                .map(repository::findAllByLastName)
+                                .map(person -> ok().body(person, Person.class))
+                                .orElse(badRequest().build())
+                )
+                // пример другой реализации - начиная с запроса репозитория
+                .GET("/func/person", queryParam("age", StringUtils::isNotEmpty),
+                        req ->
+                                repository
+                                        .findAllByAge(req.queryParam("age").map(Integer::parseInt)
+                                                .orElseThrow(IllegalArgumentException::new))
+                                        .collectList()
+                                        .transform(persons -> ok().contentType(APPLICATION_JSON).body(persons, Person.class))
+                )
+                // Обратите внимание на использование хэндлера
+                .GET("/func/person", accept(APPLICATION_JSON), new PersonHandler(repository)::list)
+                // Обратите внимание на использование pathVariable
+                .GET("/func/person/{id}", accept(APPLICATION_JSON),
+                        request -> repository.findById(request.pathVariable("id"))
+                                .flatMap(person -> ok().contentType(APPLICATION_JSON).body(fromValue(person)))
+                                .switchIfEmpty(notFound().build())
+                ).build();
+    }
+
+    // Это пример хэндлера, который даже не бин
+    static class PersonHandler {
+
+        private final PersonRepository repository;
+
+        PersonHandler(PersonRepository repository) {
+            this.repository = repository;
+        }
+
+        Mono<ServerResponse> list(ServerRequest request) {
+            // Обратите внимание на пример другого порядка создания response от Flux
+            return ok().contentType(APPLICATION_JSON).body(repository.findAll(), Person.class);
+        }
+    }
+}

2023-03/spring-22-webflux/src/main/java/ru/otus/spring/WebfluxDemo.java

@@ -0,0 +1,16 @@
+package ru.otus.spring;
+
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+
+@SpringBootApplication
+public class WebfluxDemo {
+
+
+    public static void main(String[] args) {
+     SpringApplication.run(WebfluxDemo.class);
+    }
+}
+

2023-03/spring-22-webflux/src/main/java/ru/otus/spring/config/ApplConfig.java

@@ -0,0 +1,39 @@
+package ru.otus.spring.config;
+
+import io.netty.channel.nio.NioEventLoopGroup;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.atomic.AtomicLong;
+import org.springframework.boot.web.embedded.netty.NettyReactiveWebServerFactory;
+import org.springframework.boot.web.reactive.server.ReactiveWebServerFactory;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import reactor.core.scheduler.Scheduler;
+import reactor.core.scheduler.Schedulers;
+import reactor.util.annotation.NonNull;
+
+@Configuration
+public class ApplConfig {
+    private static final int THREAD_POOL_SIZE = 2;
+
+    @Bean
+    public ReactiveWebServerFactory reactiveWebServerFactory() {
+        var eventLoopGroup = new NioEventLoopGroup(THREAD_POOL_SIZE,
+                new ThreadFactory() {
+                    private final AtomicLong threadIdGenerator = new AtomicLong(0);
+                    @Override
+                    public Thread newThread(@NonNull Runnable task) {
+                        return new Thread(task, "server-thread-" + threadIdGenerator.incrementAndGet());
+                    }
+                });
+
+        var factory = new NettyReactiveWebServerFactory();
+        factory.addServerCustomizers(builder -> builder.runOn(eventLoopGroup));
+
+        return factory;
+    }
+
+    @Bean
+    public Scheduler workerPool() {
+        return Schedulers.newParallel("processor-thread", THREAD_POOL_SIZE);
+    }
+}

2023-03/spring-22-webflux/src/main/java/ru/otus/spring/domain/Person.java

@@ -0,0 +1,51 @@
+package ru.otus.spring.domain;
+
+import org.springframework.data.annotation.Id;
+import org.springframework.data.annotation.PersistenceCreator;
+import org.springframework.data.relational.core.mapping.Table;
+
+@Table("person")
+public class Person {
+
+    @Id
+    private final Long id;
+
+    private final String lastName;
+
+    private final int age;
+
+
+    @PersistenceCreator
+    private Person(Long id, String lastName, int age) {
+        this.id = id;
+        this.lastName = lastName;
+        this.age = age;
+    }
+
+    public Person(String lastName, int age) {
+        this(null, lastName,  age);
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+
+    public String getLastName() {
+        return lastName;
+    }
+
+
+    public int getAge() {
+        return age;
+    }
+
+    @Override
+    public String toString() {
+        return "Person{" +
+                "id=" + id +
+                ", lastName='" + lastName + '\'' +
+                ", age=" + age +
+                '}';
+    }
+}

2023-03/spring-22-webflux/src/main/java/ru/otus/spring/domain/PersonDto.java

@@ -0,0 +1,6 @@
+package ru.otus.spring.domain;
+
+
+public record PersonDto(String id, String name, int age) {
+
+}

2023-03/spring-22-webflux/src/main/java/ru/otus/spring/repository/PersonRepository.java

@@ -0,0 +1,19 @@
+package ru.otus.spring.repository;
+
+import org.springframework.data.repository.reactive.ReactiveCrudRepository;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+import ru.otus.spring.domain.Person;
+
+public interface PersonRepository extends ReactiveCrudRepository<Person, Long> {
+
+    Flux<Person> findAll();
+
+    Mono<Person> findById(String id);
+
+    Mono<Person> save(Mono<Person> person);
+
+    Flux<Person> findAllByLastName(String lastName);
+
+    Flux<Person> findAllByAge(int age);
+}

2023-03/spring-22-webflux/src/main/java/ru/otus/spring/rest/AnnotatedController.java

@@ -0,0 +1,38 @@
+package ru.otus.spring.rest;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.MediaType;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.time.Duration;
+
+
+@RestController
+public class AnnotatedController {
+    private static final Logger logger = LoggerFactory.getLogger(AnnotatedController.class);
+    @GetMapping("/flux/one")
+    public Mono<String> one() {
+        return Mono.just("one");
+    }
+
+    @GetMapping(path ="/flux/ten", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
+    public Flux<Integer> list() {
+        return Flux.range(1, 10).delayElements(Duration.ofSeconds(1));
+    }
+
+    @GetMapping(path = "/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
+    public Flux<String> stream() {
+        logger.info("stream");
+        return Flux.generate(() -> 0, (state, emitter) -> {
+                    emitter.next(state);
+                    return state + 1;
+                })
+                .delayElements(Duration.ofSeconds(1L))
+                .map(Object::toString)
+                .map(val -> String.format("valStr:%s", val));
+    }
+}

2023-03/spring-22-webflux/src/main/java/ru/otus/spring/rest/PersonController.java

@@ -0,0 +1,47 @@
+package ru.otus.spring.rest;
+
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+import ru.otus.spring.domain.Person;
+import ru.otus.spring.domain.PersonDto;
+import ru.otus.spring.repository.PersonRepository;
+
+@RestController
+public class PersonController {
+
+    private final PersonRepository repository;
+
+    public PersonController(PersonRepository repository) {
+        this.repository = repository;
+    }
+
+    @GetMapping("/person")
+    public Flux<PersonDto> all() {
+        return repository.findAll()
+                .map(this::toDto);
+    }
+
+    @GetMapping("/person/{id}")
+    public Mono<ResponseEntity<PersonDto>> byId(@PathVariable("id") String id) {
+        return repository.findById(id)
+                .map(this::toDto)
+                .map(ResponseEntity::ok)
+                .switchIfEmpty(Mono.fromCallable(() -> ResponseEntity.notFound().build()));
+    }
+
+    @PostMapping("/person")
+    public Mono<Person> save(@RequestBody Mono<Person> dto) {
+        return repository.save(dto);
+    }
+
+    @GetMapping("/person/find")
+    public Flux<Person> byName(@RequestParam("name") String name) {
+        return repository.findAllByLastName(name);
+    }
+
+    private PersonDto toDto(Person person) {
+        return new PersonDto(String.valueOf(person.getId()), person.getLastName(), person.getAge());
+    }
+}

2023-03/spring-22-webflux/src/main/resources/application.yml

@@ -0,0 +1,17 @@
+server:
+  port: 8080
+
+spring:
+  r2dbc:
+    url: r2dbc:postgresql://localhost:5430/demoDB
+    username: usr
+    password: pwd
+  flyway:
+    url: jdbc:postgresql://localhost:5430/demoDB
+    user: usr
+    password: pwd
+
+
+logging:
+  level:
+    org.springframework.jdbc.core.JdbcTemplate: TRACE

2023-03/spring-22-webflux/src/main/resources/db/migration/V1__initial_schema.sql

@@ -0,0 +1,6 @@
+create table person
+(
+    id         bigserial    not null primary key,
+    last_name  varchar(50)  not null,
+    age        int not null
+);

2023-03/spring-22-webflux/src/main/resources/logback.xml

@@ -0,0 +1,11 @@
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+        </encoder>
+    </appender>
+
+    <root level="info">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>

2023-03/spring-22-webflux/src/test/java/ru/otus/spring/repository/PersonRepositoryTest.java

@@ -0,0 +1,29 @@
+package ru.otus.spring.repository;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.data.mongo.DataMongoTest;
+import org.springframework.boot.test.context.SpringBootTest;
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+import ru.otus.spring.domain.Person;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+@SpringBootTest
+class PersonRepositoryTest {
+
+    @Autowired
+    private PersonRepository repository;
+
+    @Test
+    void shouldSetIdOnSave() {
+        Mono<Person> personMono = repository.save(new Person("Bill", 12));
+
+        StepVerifier
+                .create(personMono)
+                .assertNext(person -> assertNotNull(person.getId()))
+                .expectComplete()
+                .verify();
+    }
+}

2023-03/spring-22-webflux/src/test/java/ru/otus/spring/rest/AnnotatedControllerTest.java

@@ -0,0 +1,96 @@
+package ru.otus.spring.rest;
+
+import java.time.Duration;
+import java.util.List;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.web.server.LocalServerPort;
+import org.springframework.http.MediaType;
+import org.springframework.test.web.reactive.server.WebTestClient;
+import org.springframework.web.reactive.function.client.WebClient;
+import reactor.test.StepVerifier;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+class AnnotatedControllerTest {
+
+    @Autowired
+    private WebTestClient webTestClient;
+    @LocalServerPort
+    private int port;
+
+
+    @Test
+    void oneTest() {
+        //given
+        var client = WebClient.create(String.format("http://localhost:%d", port));
+
+        //when
+        var result = client
+                .get().uri("/flux/one")
+                .accept(MediaType.APPLICATION_JSON)
+                .retrieve()
+                .bodyToMono(String.class)
+                .timeout(Duration.ofSeconds(3))
+                .block();
+
+        //then
+        assertThat(result).isEqualTo("one");
+    }
+
+    @Test
+    void streamTest() {
+        //given
+        var client = WebClient.create(String.format("http://localhost:%d", port));
+        var expectedSize = 5;
+
+        //when
+        List<String> result = client
+                .get().uri("/stream")
+                .accept(MediaType.TEXT_EVENT_STREAM)
+                .retrieve()
+                .bodyToFlux(String.class)
+                .take(expectedSize)
+                .timeout(Duration.ofSeconds(3))
+                .collectList()
+                .block();
+
+        //then
+        assertThat(result).hasSize(expectedSize)
+                .contains(String.format("valStr:%s", 0),
+                        String.format("valStr:%s", 1),
+                        String.format("valStr:%s", 2),
+                        String.format("valStr:%s", 3),
+                        String.format("valStr:%s", 4));
+    }
+
+    @Test
+    void dataTest() {
+        //given
+        var webTestClientForTest = webTestClient.mutate()
+                .responseTimeout(Duration.ofSeconds(20))
+                .build();
+
+        //when
+        var result = webTestClientForTest
+                .get().uri("/flux/ten")
+                .accept(MediaType.TEXT_EVENT_STREAM)
+                .exchange()
+                .expectStatus().isOk()
+                .returnResult(Integer.class)
+                .getResponseBody();
+
+        //then
+        var step = StepVerifier.create(result);
+        StepVerifier.Step<Integer> stepResult = null;
+        for (var idx = 1; idx <= 10; idx++) {
+            stepResult = step.expectNext(idx);
+        }
+        stepResult.verifyComplete();
+    }
+
+}

2023-03/spring-22-webflux/src/test/java/ru/otus/spring/rest/PersonControllerTest.java

@@ -0,0 +1,28 @@
+package ru.otus.spring.rest;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.web.reactive.server.WebTestClient;
+import org.springframework.web.reactive.function.server.RouterFunction;
+import org.springframework.web.reactive.function.server.ServerResponse;
+
+@SpringBootTest
+class PersonControllerTest {
+
+    @Autowired
+    private RouterFunction<ServerResponse> route;
+
+    @Test
+    void testRoute() {
+        WebTestClient client = WebTestClient
+                .bindToRouterFunction(route)
+                .build();
+
+        client.get()
+                .uri("/func/person")
+                .exchange()
+                .expectStatus()
+                .isOk();
+    }
+}