Introduction to Spring WebFlux #jsug #sf_a1

1
Introduction to Spring WebFlux
2017-11-24
Toshiaki Maki (@making) #jsug #sf_a1

Who am I ?
2
Toshiaki Maki (@making) https://blog.ik.am
Sr. Solutions Architect @Pivotal Japan
Spring Framework 💖
Cloud Foundry 💖

4
📱📱📱📱📱📱📱📱📱
📱📱📱📱📱📱📱📱📱4
📱📱📱📱📱📱📱📱📱4
🗄
📈
Devices Dashboard
HTTP POST
Server-Sent Events
∞🔄
http://bit.ly/demoiot

❓How many threads are this app using?
5

❓How many threads are this app using?
5
1. 200 -
2. 100 - 200
3. 50 - 100
4. 10 - 50
5. 1 - 10

Web Stacks in Spring 5
7
Servlet Container
Servlet API
Spring MVC
Servlet Stack

7
Servlet Container
Servlet API
Spring MVC
Reactive Stack
Netty, Servlet 3.1+,
Undertow
Reactive Streams
Spring WebFlux
Servlet Stack

7
Servlet Container
Servlet API
Spring MVC
Reactive Stack
Undertow
Reactive Streams
Spring WebFlux
Servlet StackBlocking

7
Servlet Container
Servlet API
Spring MVC
Reactive Stack
Undertow
Reactive Streams
Spring WebFlux
Servlet StackBlocking
Non-Blocking

8
Servlet StackThread
Thread
Thread
Thread
Thread
…⏳

9
Reactive Stack
🔄 Thread
🔄 Thread
🔄 Thread
🔄 Thread

❓Why are we introducing Spring WebFlux?
10

10
The goal of Spring WebFlux is to offer Spring
developers a non-blocking event-loop style
programming model similar to node.js.

the non-blocking async programming model is more
efficient for latency-sensitive workloads.
– Blocking threads consume resources
– mobile applications and interconnected
microservices
10
The goal of Spring WebFlux is to offer Spring
developers a non-blocking event-loop style
programming model similar to node.js.

11
Servlet Container
Servlet API
Spring MVC
Reactive Stack
Undertow
Reactive Streams
Spring WebFlux
Servlet Stack

Publisher Subscriber
Reactive Streams
2

subscribe
Reactive Streams
2

request(n)
Backpressure
Reactive Streams
2

Backpressure
onNext(data)
onNext(data)
onNext(data)
Reactive Streams
2

Backpressure
Error|Complete
Reactive Streams
2

5
Flux<T> is a Publisher<T> for 0..n elements

7
Mono<T> is a Publisher<T> for 0..1 element

Reactor
18
Flux<String> s = Flux
.just("a", "b", "c", "d")
.map(String::toUpperCase);
s.log("demo").subscribe();

Reactor
18
.just("a", "b", "c", "d")
Need to be subscribed!

Reactor
18
.just("a", "b", "c", "d")
Need to be subscribed!
00:58:33.902 [main] INFO demo - | request(unbounded)
00:58:33.903 [main] INFO demo - | onNext(A)
00:58:33.903 [main] INFO demo - | onNext(B)
00:58:33.903 [main] INFO demo - | onNext(C)
00:58:33.903 [main] INFO demo - | onNext(D)
00:58:33.903 [main] INFO demo - | onComplete()

Reactor
19
.just("a", "b", "c", "d")
.map(String::toUpperCase)
.delayElements(Duration.ofSeconds(1));

Reactor
19
.just("a", "b", "c", "d")
.delayElements(Duration.ofSeconds(1));
00:59:42.949 [main] INFO demo - request(unbounded)
00:59:43.992 [parallel-1] INFO demo - onNext(A)
00:59:44.994 [parallel-2] INFO demo - onNext(B)
00:59:45.997 [parallel-3] INFO demo - onNext(C)
00:59:46.999 [parallel-4] INFO demo - onNext(D)
00:59:47.001 [parallel-4] INFO demo - onComplete()

Reactor (Hot Stream♨)
20
Flux<String> s = Flux.<String>create(sink ->
sink.next(...);
});

21
twitter4j.TwiterStream tw = ...;
sink.next(status.getText());
});
s.log("tweet").subscribe();

22
twitter4j.TwiterStream tw = ...;
tw.addListener(new StatusAdapter() {
public void onStatus(Status status) {
sink.next(status.getText()); }
public void onException(Exception e) {
sink.error(e); }});
sink.onCancel(tw::shutdown);
tw.sample();
});
s.log("tweet").subscribe();

Operators in Reactor
23
• map / indexed / flatMap / flatMapMany
• collectList / collectMap / count
• concat / merge / zip / when / combineLatest
• repeat / interval
• filter / sample / take / skip
• window / windowWhile / buffer
• ...
https://projectreactor.io/docs/core/release/reference/docs/index.html#which-operator

zip
25
Flux<GHUser> github = findGitHubUsers("foo", "bar",
"hoge"); 
Flux<FBUser> facebook = findFacebookUsers("foo",
"bar", "hoge");
Flux<User> users = Flux.zip(github, facebook)
.map(tpl -> new User(tpl.getT1(), tpl.getT2()));
users.subscribe();

flatMap
27
"hoge"); 
Flux<User> users = github.flatMap(g
-> findTweets(g)
.collectList()
.map(tweets -> new User(g, tweets)));
users.subscribe();

flatMap
28
"hoge"); 
Flux<User> users = github.map(g
-> findTweets(g)
.collectList()
users.subscribe();

flatMap
28
"hoge"); 
Flux<User> users = github.map(g
-> findTweets(g)
.collectList()
users.subscribe();
⚠ Can be compiled but
findTweets won't be
subscribed

flatMap
29
"hoge");
Flux<User> users = github.map(g -> {
Mono<User> u = findTweets(g)
.collectList()
.map(tweets -> new User(g, tweets));
u.subscribe();
return u;
});
users.subscribe();
This will work,
but use flatMap instead

30
Servlet Container
Servlet API
Spring MVC
Reactive Stack
Undertow
Reactive Streams
Spring WebFlux
Servlet Stack

Spring MVC controller
31
@RestController
public class HelloController {
private final Hello hello;
public HelloController(Hello hello) {
this.hello = hello;
}
@GetMapping("hello")
public String hello() {
return hello.sayHello();
}
}

31
@RestController
this.hello = hello;
}
}
}
Blocking / Synchronous

Spring WebFlux controller
32
@RestController
this.hello = hello;
}
}
}

32
@RestController
this.hello = hello;
}
}
}
Non-blocking / Synchronous

33
@RestController
this.hello = hello;
}
public Mono<String> hello() {
return Mono.fromCallable(hello::sayHello);
}
}

33
@RestController
this.hello = hello;
}
}
}
Non-blocking / Asynchronous

33
@RestController
this.hello = hello;
}
}
}
You don't need to subscribe the stream

34
@RestController
this.hello = hello;
}
return Mono.fromCallable(hello::sayHello)
.flatMap(foo::abc)
.map(bar::xyz);}

34
@RestController
this.hello = hello;
}
.flatMap(foo::abc)
.map(bar::xyz);}
Could be executed
in the other thread

35
@RestController
this.hello = hello;
}
.flatMap(foo::abc)
.map(bar::xyz);}
Blocking / Asynchronous

35
@RestController
this.hello = hello;
}
.flatMap(foo::abc)
.map(bar::xyz);}
Blocking / Asynchronous
Async support in
Servlet 3

∞ Stream
36
@RestController
public Flux<String> hello() {
Flux<String> hello = Flux.just("hello")
.delayElement(Duration.ofMillis(100));
hello.subscribe();
return hello.repeat(); // ∞ Stream
}
}

Content Negotiation
38
Accept: text/event-stream
Accept: application/stream+json
Accept: application/json

Content Negotiation
38
Accept: application/stream+json
Accept: application/json
✅ Backpressure
✅ Backpressure
❌ Backpressure

Content Negotiation
39
public Flux<Message> hello() {
return Mono.just(new Message("a"))
.repeat()
.take(100)
.log("message");
}

40
$ curl -v -H "Accept: text/event-stream" localhost:8080/messages
> GET /messages HTTP/1.1
> Host: localhost:8080
> Accept: text/event-stream
>
< HTTP/1.1 200 OK
< transfer-encoding: chunked
< Content-Type: text/event-stream
<
data:{"text":"a"}
data:{"text":"a"}
data:{"text":"a"}
...

40
>
< HTTP/1.1 200 OK
<
data:{"text":"a"}
data:{"text":"a"}
data:{"text":"a"}
...
INFO 48330 --- [ctor-http-nio-2] message : request(1)
INFO 48330 --- [ctor-http-nio-2] message : onNext(a)
... ...
... ...
... ...
INFO 48330 --- [ctor-http-nio-2] message : onComplete()

40
>
< HTTP/1.1 200 OK
<
data:{"text":"a"}
data:{"text":"a"}
data:{"text":"a"}
...
... ...
... ...
... ...
Backpressure

(FYI) In case of Servlet Stack
41

41
INFO 61528 --- [nio-8080-exec-1] message : request(1)
INFO 61528 --- [nio-8080-exec-1] message : onNext(a)
INFO 61528 --- [ MvcAsync1] message : request(1)
INFO 61528 --- [ MvcAsync1] message : onNext(a)
... ...
INFO 61528 --- [ MvcAsync99] message : onComplete()

41
INFO 61528 --- [nio-8080-exec-1] message : request(1)
INFO 61528 --- [nio-8080-exec-1] message : onNext(a)
... ...
INFO 61528 --- [ MvcAsync99] message : onComplete()
✅ Backpressure

42
$ curl -v -H "Accept: application/stream+json" localhost:8080/
messages
> Accept: application/stream+json
>
< HTTP/1.1 200 OK
< Content-Type: application/stream+json;charset=UTF-8
<
{"text":"a"}
{"text":"a"}
{"text":"a"}
...

42
messages
>
< HTTP/1.1 200 OK
<
{"text":"a"}
{"text":"a"}
{"text":"a"}
...
... ...
... ...
... ...

42
messages
>
< HTTP/1.1 200 OK
<
{"text":"a"}
{"text":"a"}
{"text":"a"}
...
... ...
... ...
... ...
✅ Backpressure

43
$ curl -v -H "Accept: application/json" localhost:8080/messages
> Accept: application/json
>
< HTTP/1.1 200 OK
< Content-Type: application/json;charset=UTF-8
<
[{"text":"a"},{"text":"a"},...,{"text":"a"},{"text":"a"},
{"text":"a"},{"text":"a"}]

43
>
< HTTP/1.1 200 OK
<
{"text":"a"},{"text":"a"}]
INFO 48330 --- [ctor-http-nio-3] message : request(unbounded)
... ...

43
>
< HTTP/1.1 200 OK
<
{"text":"a"},{"text":"a"}]
INFO 48330 --- [ctor-http-nio-3] message : request(unbounded)
... ...
❌ Backpressure

Flux -> Mono
44
public Mono<List<Message>> hello() {
.repeat()
.take(100)
.collectList()
.log("message");
}

Flux -> Mono
45
.repeat()
.take(100)
.collectList()
.log("message");
}
messages
>
< HTTP/1.1 200 OK
<
{"text":"a"},{"text":"a"}]

Flux -> Mono
45
.repeat()
.take(100)
.collectList()
.log("message");
}
messages
>
< HTTP/1.1 200 OK
<
{"text":"a"},{"text":"a"}]
INFO 48330 --- [ctor-http-nio-3] message : | request(1)
INFO 48330 --- [ctor-http-nio-3] message : | onNext([a, a, a, a,
a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,
a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a])
INFO 48330 --- [ctor-http-nio-3] message : | onComplete()

Flux -> Mono
45
.repeat()
.take(100)
.collectList()
.log("message");
}
messages
>
< HTTP/1.1 200 OK
<
{"text":"a"},{"text":"a"}]
INFO 48330 --- [ctor-http-nio-3] message : | onNext([a, a, a, a,
a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a])
INFO 48330 --- [ctor-http-nio-3] message : | onComplete()
❌ Backpressure

Spring WebFlux controller (Receiving Flux)
46
@RestController
@PostMapping("upper")
public Flux<String>
upper(@RequestBody Flux<String> input) {
Flux<String> output = input
return output;
}
}

47
$ telnet localhost 8080
POST /upper HTTP/1.1
Host: localhost:8080
Transfer-Encoding: chunked
Content-Type: text/plain
3
foo
HTTP/1.1 200 OK
transfer-encoding: chunked
Content-Type: text/event-stream
5
data:
4
FOO
1
4
java
5
data:
5
JAVA
1

47
3
foo
HTTP/1.1 200 OK
5
data:
4
FOO
1
4
java
5
data:
5
JAVA
1
Request Body

47
3
foo
HTTP/1.1 200 OK
5
data:
4
FOO
1
4
java
5
data:
5
JAVA
1
Request Body
Response Body

Spring WebFlux controller (Receiving Flux)
48
public Flux<String>
upper(@RequestBody Flux<String> input) {
.flatMap(s -> Flux
.interval(Duration.ofSeconds(1))
.map(i -> s + i)
.take(3));
return output;
}

49
3
foo
HTTP/1.1 200 OK
5
data:
5
FOO0
1
5
data:
5
FOO1
1
5
data:
5
FOO2
1

Spring MVC controller (Receiving Flux)
51
@RestController
public Flux<String>
hello(@RequestBody Flux<String> input) {
return output;
}
}

51
@RestController
public Flux<String>
return output;
}
}
🙅

51
@RestController
public Flux<String>
return output;
}
}
🙅Reactive type are supported only as
controller method return values

Broadcast stream
52
@RestController
private final Flux<String> flux;
public HelloController() {
this.flux = this.createHotStream().share();
this.flux.subscribe();
}
return this.flux;
}}

Broadcast stream
52
@RestController
private final Flux<String> flux;
public HelloController() {
this.flux = this.createHotStream().share();
this.flux.subscribe();
}
return this.flux;
}}
this stream is shared by all http
clients!

53
📱📱📱📱📱📱📱📱📱
📱📱📱📱📱📱📱📱📱53
📱📱📱📱📱📱📱📱📱53
🗄
📈
Devices Dashboard
HTTP POST
Server-Sent Events
∞🔄
♨

54
📱📱📱📱📱📱📱📱📱
📱📱📱📱📱📱📱📱📱54
📱📱📱📱📱📱📱📱📱54
🗄
📈
Devices Dashboard
HTTP POST
Server-Sent Events
∞🔄
📈📈📈
♨

54
📱📱📱📱📱📱📱📱📱
📱📱📱📱📱📱📱📱📱54
📱📱📱📱📱📱📱📱📱54
🗄
📈
Devices Dashboard
HTTP POST
Server-Sent Events
∞🔄
📈📈📈
♨ Shared

55
Servlet Container
Servlet API
Spring MVC
Reactive Stack
Undertow
Reactive Streams
Spring WebFlux
Servlet Stack

55
Servlet Container
Servlet API
Spring MVC
Reactive Stack
Undertow
Reactive Streams
Spring WebFlux
Servlet Stack
•Annotated Controller
•Function Endpoints (WebFlux.fn)

@Configuration
public class RouterConfig {
@Bean
public RouterFunctions<ServerResponse> routes() {
return route(GET("hello"), req -> {
return ServerReponse.ok()
.body(Mono.just("hello"), String.class);
});
}
}
Spring WebFlux.fn
56

@Configuration
@Bean
public RouterFunctions<ServerResponse> routes() {
return route(GET("hello"), req -> {
return ServerReponse.ok()
.body(Mono.just("hello"), String.class);
});
}
}
lambda
Spring WebFlux.fn
56

Spring WebFlux.fn
57
@Configuration
@Bean
public RouterFunctions<ServerResponse>
routes(HelloHandler helloHandler) {
return route(GET("hello"), helloHandler::hello);
}
}

Spring WebFlux.fn
58
routes(PersonHandeler ph) {
return route(GET("person"), ph::findAll)
.andRoute(POST("person"), ph::create)
.andRoute(GET("person/{id}"), ph::findOne)
.andRoute(PUT("person/{id}"), ph::update)
.andRoute(DELETE("person/{id}"), ph::delete));
}

Spring WebFlux.fn
59
routes(PersonHandeler ph) {
return nest(path("person"),
route(GET("/"), ph::findAll)
.andRoute(POST("/"), ph::create)
.andRoute(GET("/{id}"), ph::findOne)
.andRoute(PUT("/{id}"), ph::update)
.andRoute(DELETE("/{id}"), ph::delete)));
}

60
Servlet Container
Servlet API
Spring MVC
Reactive Stack
Undertow
Reactive Streams
Spring WebFlux
Servlet Stack

60
Servlet Container
Servlet API
Spring MVC
Reactive Stack
Undertow
Reactive Streams
Spring WebFlux
Servlet Stack
Reactive Web Client

Reactive Web Client
61
@RestController
private final WebClient client;
public HelloController(WebClinet.Builer b) {
this.client = b.build();
}
return this.client.get().uri("http://blahblah")
.retrieve().bodyToFlux(String.class);
}}

Reactive Web Client
62
Flux<User> users = webClient.get()
.uri("http://user-service")
.exchange() // => Mono<ClientResponse>
.flatMap(r -> r.bodyToFlux(User.class));
// short-cut
Flux<User> users = webClient.get()
.retrieve()
.bodyToFlux(User.class);

Reactive Web Client
63
Mono<User> user = webClient.get()
.uri("http://user-service/{id}", id)
.header("X-Foo", "foo")
.retrieve().bodyToMono(User.class);
Mono<User> user = ...
Mono<Void> created = webClient.post()
.body(user, User.class)
.retrieve().bodyToMono(Void.class);

From RestTemplate to WebClient
64
@Controller
public class UserController {
@GetMapping("users")
public String hello(Model model) {
List<User> users = restTemplate
.getForObject("/users", List.class);
model.addAttribute("users", users);
return "users";
}
}

From RestTemplate to WebClient
65
@Controller
Flux<User> users = client.get().uri("/users")
model.addAttribute("users", users);
return "users";
}
}

66
<html>
<body>
<ul>
<li data-th-each="user : ${user}">[[${user}]]</li>
</ul>
</body>
</html>

66
<html>
<body>
<ul>
</ul>
</body>
</html>
😀 Spring WebFlux

66
<html>
<body>
<ul>
</ul>
</body>
</html>
😀 Spring WebFlux
😨 Spring MVC

From RestTemplate to WebClient (Spring MVC)
67
@Controller
public Mono<String> hello(Model model) {
users.collectList().map(x -> {
model.addAttribute("users", x);
return "users";
});
}

67
@Controller
users.collectList().map(x -> {
model.addAttribute("users", x);
return "users";
});
}
😀 Spring MVC

68
@Controller
Flux<User> users = ...;
Mono<Sting> foo = ...;
return Mono.zip(user.collectList(), foo)
.map(tpl -> {
model.addAttribute("users", tpl.getT1());
model.addAttribute("foo", tpl.getT2());
return "users";
});}}

69
String url = "http://httpbin.org/delay/1";
Mono<String> mono = Mono.just(restTemplate
.getForObject(url));
return mono;
}

⚠ Don't block the thread in WebFlux!
69
return mono;
}

69
return mono;
} 😠 Blocking!

70
Mono<String> mono = Mono
.fromCallable(() ->restTemplate.getForObject(url))
.subscribeOn(Schedulers.elastic());
return mono;
}

70
Mono<String> mono = Mono
.fromCallable(() ->restTemplate.getForObject(url))
.subscribeOn(Schedulers.elastic());
return mono;
} Switch the execution context

71
Concurrency
Throughput [trans / sec]
Core i7 2.7 GHz
4 Core x HT

Reactive Support in Spring Projects
72
Spring Data
Reactive Stack
Undertow
Reactive Streams
Spring WebFlux
Spring Security
Thymeleaf

Spring Data Kay
73
Reactive support for
• Redis
• MongoDB
• Couchbase
• Cassandra
Infinite streams from the database with @Tailable

Reactive Non-Blocking Data Access
74
public interface ReactiveCrudRepository<ID,T> {
Mono<T> findById(ID id);
Mono<T> findById(Mono<ID> id);
Flux<T> findAll();
Mono<Long> count();
Mono<T> save(T entity);
Mono<T> saveAll(Publisher<T> entityStream);
Mono<Void> delete(T entity)
// ...
}

Tailable Cursor Support for MongoDB
75
public interface MessageRepository
extends ReactiveMongoRepository<Message,String>
{
@Tailable
Flux<Message>
findByUpdatedAtGreaterThan(Instant target);
}

Broadcast updated messages in MongoDB
76
@RestController
private final Flux<Message> messages;
public HelloController(MessageRepository repo) {
this.messages = repo
.findByUpdatedAtGreaterThan(Instant.now())
.share();
this.messages.subscribe();
}
@GetMapping("messages")
public Flux<Message> messages() {
return this.messages;
}}

But, but, JDBC is blocking .... 😭
77

77
Let's see what will happen in next Java

77
Let's see what will happen in next Java
https://static.rainfocus.com/oracle/oow17/sess/1491948952321001dm4m/PF/JavaOne%2017%20-
%20CON1491_1506954898905001IipH.pdf

java.sql2
78
http://cr.openjdk.java.net/~lancea/apidoc/java/sql2/package-summary.html

java.sql2
78
http://cr.openjdk.java.net/~lancea/apidoc/java/sql2/package-summary.html
😢 Does not seem to support
Reactive Streams (j.u.c.Flow)

Spring Security Reactive
79
@Bean
public SecurityWebFilterChain
springWebFilterChain(HttpSecurity http) {
return http.authorizeExchange()
.pathMatchers("/v2/**").hasRole("ADMIN")
.and().httpBasic().and().build();
}
@Bean
public MapUserDetailsRepository userDetailsRepository() {
return new MapUserDetailsRepository(...);
}

Thymeleaf 3.0 reactive support
80
• "full mode"
• "chunked mode" 
=> Progressive rendering. Good for large pages
• "data-driven mode"  
=> Rendering template fragments as Server-Sent Events 
• https://github.com/thymeleaf/thymeleaf-spring/issues/132
• https://github.com/spring-projects/spring-boot/issues/8124
• https://speakerdeck.com/dfernandez/o-2017-getting-thymeleaf-ready-
for-spring-5-and-reactive?slide=18

Data-driven mode
81
Flux<User> users = userService.findAll();
ReactiveDataDriverContextVariable v
= new ReactiveDataDriverContextVariable(users, 1);
model.addAttribute("users", v);
return "users";
}

Reactive Application Patterns (as of 2017)
83

83
Spring WebFluxSpring WebFlux
Frontend Backend
HTTP NoSQL
WebClient Spring Data

84
Spring MVCSpring WebFlux
Frontend Backend
HTTP RDB
JDBC
WebClient

85
Spring MVCSpring MVC
Frontend Backend
HTTP RDB
JDBC
WebClient

Spring Cloud Gateway
86
A Gateway built on Spring Framework 5.0 and Spring
Boot 2.0 providing routing and more
http://cloud.spring.io/spring-cloud-gateway/
http://cloud.spring.io/spring-cloud-gateway/2.0.x/single/
spring-cloud-gateway.html

Start Spring 5 & Spring Boot 2
87

Servlet Stack ⇄ Reactive Stack
88
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<artifactId>spring-boot-starter-webflux</artifactId>
</dependency>
Reactive Stack
Servlet Stack

Servlet Stack ⇄ Reactive Stack
89
<dependency>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webflux</artifactId>
</dependency>
<dependency>
<groupId>io.projectreactor.ipc</groupId>
<artifactId>reactor-netty</artifactId>
</dependency>
<dependency>
<artifactId>spring-boot-starter-webflux</artifactId>
</dependency>
Reactive Stack
Servlet Stack
+
WebClient

Thanks!
90
Resources
• Servlet vs Reactive Stacks in Five Use Cases
• Spring Boot 2 0 Web Applications
• Spring Framework 5: Themes & Trends
• Why Spring ❤ Kotlin

Introduction to Spring WebFlux #jsug #sf_a1

More Related Content

What's hot

Similar to Introduction to Spring WebFlux #jsug #sf_a1

More from Toshiaki Maki

Recently uploaded

Introduction to Spring WebFlux #jsug #sf_a1