Refactor to Reactive With Spring 5 and Project Reactor

Refactor To Reactive
by Oleh Dokuka
1

2
https://goo.gl/yzG2HC
Say Hello Here

3
• JSE at Levi9
• JEEConf/JavaDay/JUG Speaker
• Reactor 3 committer
• Reactivity preacher
/oleh.dokuka /OlegDokuka/OlehDokuka
3
About me

Agenda
• App Overview
• Refactoring
5

Primary Goal
• Expand Reactive Approaches with Spring 5
• Demonstrate Refactoring Steps by Examples
6

Functionality
• Gitter Chat Communication
• Messaging Statistics
11

12
Gitter Room:
Reactive EatDog

Toolkit
• Spring Framework 4.x
• Spring MVC
• Spring Data Mongo
• Spring Boot 1.5.x
14

Whole ApplicationControllers LayerServices LayerPersistence Layer
18

Problems
• Pulling model
• Blocking I/O
28

29
Step 0.
Or how to motivate the business

java -Xmx2g
-Xms1g
-Dserver.tomcat.accept-count=20000
-jar blocking.jar
Blocking Tomcat
33

Throughput Average Latency (millisec.)
100 1271
1000 4600
10000 44565
Blocking Tomcat
34

java -Xmx2g
-Xms1g
-Dserver.tomcat.max-threads=10000
-Dserver.tomcat.max-connections=10000
-jar blocking.jar
Blocking Tomcat
35

100 1211
1000 1429
10000 OutOfMemoryError
Blocking Tomcat
36

java -Xmx2g
-Xms1g
-jar non-blocking.jar
Non-blocking Tomcat
37

100 1203
1000 1407
10000 9661
Non-blocking Tomcat
38

1000 1370
10000 2699
20000 6310
Non-blocking Netty
39

Non-Blocking Connection Pipe
Gitter Connection Pipe
56
Client Connection Pipe

57
Step 2.
Choose Reactive Toolset

Reactive Types
•Mono<T>
•Flux<T>
60

Reactive Types
•Mono<T>
•Flux<T>
61

Reactive Stack (WebFlux)
@Controller, @RequestMapping,…
Spring MVC
Servlet API
Servlet Container
64
Spring WebFlux
HTTP/Reactive-Streams
Servlet 3.1, Netty, Undertow
Default Stack (MVC)

@RestController
@RequestMapping("/api/v1/statistics")
public class StatisticResource {
private final StatisticService statisticService;
@Autowired
public StatisticResource(
StatisticService statisticService) {
this.statisticService = statisticService;
}
@GetMapping("/users")
public List<UsersStatisticVM> getUsersStatistic() {
return statisticService.getUsersStatistic();
}
} 65

@RestController
@Autowired
}
public Flux<UsersStatisticVM> getUsersStatistic() {
}
} 66

@RestController
@Autowired
}
public List<UsersStatisticVM> getUsersStatistic() {
}
} 67

@RestController
@Autowired
}
public Flux<UsersStatisticVM> getUsersStatistic() {
}
} 68

Asynchronous
event-driven framework
72

https://goo.gl/yxAJGI
74
Join GitHub

75
Step 3.1.
Update Dependencies

Tip
77
• Use start.spring.io to generate build
file

SpringBoot 2.X
78
Toolset Tips
SpringBoot 1.X

80
Step 3.2.
Refactor Contracts (interfaces)

Tips
81
Object Mono<Object>
Iterable<T> Flux<T>

However
82
Object Flux<Object>

ReactiveCrudRepository<T, ID>
83
Toolset Tips
CrudRepository<T, ID>

interface ReactiveCrudRepository<T, ID> extends Repository<T, ID> {
<S extends T> Mono<S> save(S entity);
<S extends T> Flux<S> saveAll(Iterable<S> entities);
<S extends T> Flux<S> saveAll(Publisher<S> entityStream);
Mono<T> findById(ID id);
Mono<T> findById(Mono<ID> id);
Mono<Boolean> existsById(ID id);
Mono<Boolean> existsById(Mono<ID> id);
Flux<T> findAll();
Flux<T> findAllById(Iterable<ID> ids);
Flux<T> findAllById(Publisher<ID> idStream);
Mono<Long> count();
Mono<Void> deleteById(ID id);
Mono<Void> delete(T entity);
Mono<Void> deleteAll(Iterable<? extends T> entities);
Mono<Void> deleteAll(Publisher<? extends T> entityStream);
Mono<Void> deleteAll();
}
84

interface ReactiveCrudRepository<T, ID> extends Repository<T, ID> {
<S extends T> Mono<S> save(S entity);
<S extends T> Flux<S> saveAll(Iterable<S> entities);
<S extends T> Flux<S> saveAll(Publisher<S> entityStream);
Mono<T> findById(ID id);
Mono<T> findById(Mono<ID> id);
Mono<Boolean> existsById(ID id);
Mono<Boolean> existsById(Mono<ID> id);
Flux<T> findAll();
Flux<T> findAllById(Iterable<ID> ids);
Flux<T> findAllById(Publisher<ID> idStream);
Mono<Long> count();
Mono<Void> deleteById(ID id);
Mono<Void> delete(T entity);
Mono<Void> deleteAll(Iterable<? extends T> entities);
Mono<Void> deleteAll(Publisher<? extends T> entityStream);
Mono<Void> deleteAll();
}
85

87
Step 3.3.
Refactor Implementation (services)

Notice
88
• Everything is a Stream
• Only Non-blocking ops.
• Less side effects
• No custom operators

Toolset Tips
90
RestTemplate WebClient

public interface WebClient {
UriSpec<RequestHeadersSpec<?>> get();
//omitted...
static WebClient create() {
return new DefaultWebClientBuilder().build();
}
interface RequestHeadersSpec<S extends RequestHeadersSpec<S>> {
//omitted...
Mono<ClientResponse> exchange();
//omitted...
}
interface ResponseSpec {
<T> Mono<T> bodyToMono(Class<T> bodyType);
<T> Flux<T> bodyToFlux(Class<T> elementType);
<T> Mono<ResponseEntity<T>> toEntity(Class<T> bodyType);
<T> Mono<ResponseEntity<List<T>>> toEntityList(Class<T> elementType);
}
}
91

public interface WebClient {
UriSpec<RequestHeadersSpec<?>> get();
//omitted...
static WebClient create() {
return new DefaultWebClientBuilder().build();
}
interface RequestHeadersSpec<S extends RequestHeadersSpec<S>> {
//omitted...
Mono<ClientResponse> exchange();
//omitted...
}
interface ResponseSpec {
<T> Mono<T> bodyToMono(Class<T> bodyType);
<T> Flux<T> bodyToFlux(Class<T> elementType);
<T> Mono<ResponseEntity<T>> toEntity(Class<T> bodyType);
<T> Mono<ResponseEntity<List<T>>> toEntityList(Class<T> elementType);
}
}
92

94
WebClient
.create()
.get()
.uri(...)
.header(...)
.exchange()
.retryWhen(...)
.flatMapMany(...);
WebClient
.create()
.get()
.uri(...)
.header(...)
.exchange()
.retryWhen(...)
.flatMapMany(...);

@Autowired
public GitterService(
GitterClient gitterClient
) {
gas = Flux.merge(
getLatestMessages(),
getMessagesStream(null)
)
.replay(30)
.autoConnect(0);
}
95
@Autowired
) {
gas = Flux.merge(
)
.replay(30)
.autoConnect(0);
}

@Autowired
) {
gas = Flux.merge(
)
.replay(30)
.autoConnect(0);
}
96
.getMS().getLM()
.retry()
cache

97
@Autowired
) {
gas = Flux.merge(
)
.replay(30)
.autoConnect(0);
}
.getMS().getLM()
.retry()
cache

.getMS().getLM()
.retry()
cache
98
@Autowired
) {
gas = Flux.merge(
)
.replay(30)
.autoConnect(0);
}

.getLM() .getMS()
.retry()
cache
99
@Autowired
) {
gas = Flux.merge(
)
.replay(30)
.autoConnect(0);
}

.getMS().getLM()
.retry()
cache
100
@Autowired
) {
gas = Flux.merge(
)
.replay(30)
.autoConnect(0);
}
@Autowired
) {
gas = Flux.merge(
)
.replay(30)
.autoConnect(0);
}
.getLM()

.getMS().getLM()
.retry()
cache
101
@Autowired
) {
gas = Flux.merge(
)
.replay(30)
.autoConnect(0);
}

.getMS().getLM()
.retry()
cache
102
@Autowired
) {
gas = Flux.merge(
)
.replay(30)
.autoConnect(0);
}

.getMS().getLM()
.retry()
cache
103
@Autowired
) {
gas = Flux.merge(
)
.replay(30)
.autoConnect(0);
}

.getMS().getLM()
.retry()
cache
104
@Autowired
) {
gas = Flux.merge(
)
.replay(30)
.autoConnect(0);
}

…subscribe();
105
@Autowired
) {
gas = Flux.merge(
)
.replay(30)
.autoConnect(0);
}
.getMS().getLM()
.retry()
cache
@Autowired
) {
gas = Flux.merge(
)
.replay(30)
.autoConnect(0);
}

…subscribe();
106
@Autowired
) {
gas = Flux.merge(
)
.replay(30)
.autoConnect(0);
}
.getMS().getLM()
.retry()
cache

@Autowired
) {
gas = Flux.merge(
)
.replay(30)
.autoConnect(0);
}
@Autowired
) {
gas = Flux.merge(
)
.replay(30)
.autoConnect(0);
}
…subscribe();
107
.getMS().getLM()
.retry()
cache .getMS()
.retry()

@Autowired
) {
gas = Flux.merge(
)
.replay(30)
.autoConnect(0);
}
@Autowired
) {
gas = Flux.merge(
)
.replay(30)
.autoConnect(0);
}
…subscribe();
108
.getMS().getLM()
.retry()
cache
…subscribe();

…subscribe();
109
@Autowired
) {
gas = Flux.merge(
)
.replay(30)
.autoConnect(0);
}
.getMS().getLM()
.retry()
cache
@Autowired
) {
gas = Flux.merge(
)
.replay(30)
.autoConnect(0);
}
…subscribe();

…subscribe();
110
@Autowired
) {
gas = Flux.merge(
)
.replay(30)
.autoConnect(0);
}
.getMS().getLM()
.retry()
cache
@Autowired
) {
gas = Flux.merge(
)
.replay(30)
.autoConnect(0);
}
…subscribe();
.getMS()
.retry()

@Autowired
public DefaultMessageService(
MessageRepository messageRepository,
ChatService<MessageResponse> chatClient,
ApplicationContext context
) {
this.chatClient = chatClient;
chatClient.stream()
.transform(MessageMapper::toDomainUnits)
.transform(messageRepository::saveAll)
.retryWhen(…)
.subscribe()
}
113
@Autowired
) {
chatClient.stream()
.retryWhen(…)
.subscribe()
}

@Autowired
) {
chatClient.stream()
.retryWhen(…)
.subscribe()
}
114

@Autowired
MessageBroker messageBroker
) {
chatClient.stream()
.retryWhen(…)
.subscribe()
}
.transform()
115

@Autowired
) {
chatClient.stream()
.retryWhen(…)
.subscribe()
}
.transform()
116

@Autowired
) {
chatClient.stream()
.retryWhen(…)
.subscribe()
}
.transform()
117

@Autowired
) {
chatClient.stream()
.retryWhen(…)
.subscribe()
}
.transform()
118

@Autowired
) {
chatClient.stream()
.retryWhen(…)
.subscribe()
}
.transform()
119

@Autowired
) {
chatClient.stream()
.retryWhen(…)
.subscribe()
}
.transform()
120

@Autowired
) {
chatClient.stream()
.retryWhen(…)
.subscribe()
}
.transform()
121

.transform()
@Autowired
) {
chatClient.stream()
.retryWhen(…)
.subscribe()
}
122

.transform()
@Autowired
) {
chatClient.stream()
.retryWhen(…)
.subscribe()
}
123

@Override
public Flux<MessageVM> latest() {
return chatClient.stream()
.transform(MessageMapper
::toViewModelUnits
);
}
@Override
::toViewModelUnits
);
}
@Override
::toViewModelUnits
);
}
.transform()
124

public DefaultStatisticService(
ConfigurableApplicationContext context,
UserRepository userRepository
) {
this.userRepository = userRepository;
this.statisticPublisher =
Flux
.create(
s -> context.addApplicationListener(
(MessageSavedEvent e) ->
s.next(e.getSource())
),
FluxSink.OverflowStrategy.LATEST
)
.flatMap(s -> doGetUserStatistic())
.mergeWith(Mono.defer(this::doGetUserStatistic))
.cache(1);
}
127
) {
Flux
.create(
),
)
.cache(1);
}

) {
Flux
.create(
),
)
.cache(1);
}
128
) {
Flux
.create(
),
)
.cache(1);
}

) {
Flux
.create(
),
)
.cache(1);
}
129
) {
Flux
.create(
),
)
.cache(1);
}

) {
Flux
.create(
),
)
.cache(1);
}
130
) {
Flux
.create(
),
)
.cache(1);
}

) {
Flux
.create(
),
)
.cache(1);
}
131
) {
Flux
.create(
),
)
.cache(1);
}
.mergeWith(.defer(…))
.flatMap{ userStatistic()}
.userStatistic()

) {
Flux
.create(
),
)
.cache(1);
}
) {
Flux
.create(
),
)
.cache(1);
}
132
.userStatistic()

) {
Flux
.create(
),
)
.cache(1);
}
) {
Flux
.create(
),
)
.cache(1);
}
133
.userStatistic()
.cache( )
.userStatistic()

) {
Flux
.create(
),
)
.cache(1);
}
) {
Flux
.create(
),
)
.cache(1);
}
) {
Flux
.create(
),
)
.cache(1);
}
134
.userStatistic()
.cache( )
.userStatistic()

) {
Flux
.create(
),
)
.cache(1);
}
) {
Flux
.create(
),
)
.cache(1);
}
135
.cache( )
.userStatistic()

) {
Flux
.create(
),
)
.cache(1);
}
) {
Flux
.create(
),
)
.cache(1);
}
) {
Flux
.create(
),
)
.cache(1);
}
136
.cache( )

) {
Flux
.create(
),
)
.cache(1);
}
137
.cache( )

private Mono<US> doGetUserStatistic() {
Mono<UserVM> topActiveUser =
userRepository
.findMostActive()
.map(UserMapper::toViewModelUnits);
Mono<UserVM> topMentionedUser =
userRepository
.findMostPopular()
return Mono.zip(
topActiveUser.transform(::addResilience),
topMentionedUser.transform(::addResilience),
UsersStatisticVM::new
);
}
userRepository
.findMostActive()
userRepository
.findMostPopular()
return Mono.zip(
);
}
138
Mono<UserVM> addResilience(Mono<UserVM> input) {
return input
.timeout(Duration.ofSeconds(2))
.defaultIfEmpty(EMPTY_USER)
.onErrorReturn(EMPTY_USER);
}
Mono<UserVM> addResilience(Mono<UserVM> input) {
return input
.timeout(Duration.ofSeconds(2))
.defaultIfEmpty(EMPTY_USER)
.onErrorReturn(EMPTY_USER);
}

userRepository
.findMostActive()
userRepository
.findMostPopular()
return Mono.zip(
);
}
.map(…)
.addResilience(…)
.zip(…) 139

userRepository
.findMostActive()
userRepository
.findMostPopular()
return Mono.zip(
);
}
.map(…)
.addResilience(…)
.zip(…) 140

userRepository
.findMostActive()
userRepository
.findMostPopular()
return Mono.zip(
);
}
.map(…)
.addResilience(…)
.zip(…) 141

userRepository
.findMostActive()
userRepository
.findMostPopular()
return Mono.zip(
);
}
.map(…)
.addResilience(…)
.zip(…) 142

userRepository
.findMostActive()
userRepository
.findMostPopular()
return Mono.zip(
);
}
.map(…)
.addResilience(…)
.zip(…) 143

userRepository
.findMostActive()
userRepository
.findMostPopular()
return Mono.zip(
);
}
.map(…)
.addResilience(…)
.zip(…) 144

userRepository
.findMostActive()
userRepository
.findMostPopular()
return Mono.zip(
);
}
.addResilience(…)
.zip(…)
.subscribe()
145

userRepository
.findMostActive()
userRepository
.findMostPopular()
return Mono.zip(
);
}
.addResilience(…)
.zip(…)
.subscribe()
146

userRepository
.findMostActive()
userRepository
.findMostPopular()
return Mono.zip(
);
}
.map(…)
.addResilience(…)
.zip(…)
null
147

userRepository
.findMostActive()
userRepository
.findMostPopular()
return Mono.zip(
);
}
.map(…)
.addResilience(…)
.zip(…)
null
148

userRepository
.findMostActive()
userRepository
.findMostPopular()
return Mono.zip(
);
}
.map(…)
.addResilience(…)
.zip(…)
null
149

userRepository
.findMostActive()
userRepository
.findMostPopular()
return Mono.zip(
);
}
.map(…)
.addResilience(…)
.zip(…)
nullnull
150

userRepository
.findMostActive()
userRepository
.findMostPopular()
return Mono.zip(
);
}
.map(…)
.addResilience(…)
.zip(…)
null
151

userRepository
.findMostActive()
userRepository
.findMostPopular()
return Mono.zip(
);
}
.map(…)
.addResilience(…)
.zip(…)
null
152

userRepository
.findMostActive()
userRepository
.findMostPopular()
return Mono.zip(
);
}
.map(…)
.addResilience(…)
.zip(…)
null
153

userRepository
.findMostActive()
userRepository
.findMostPopular()
return Mono.zip(
);
}
.map(…)
.addResilience(…)
.zip(…)
154

userRepository
.findMostActive()
userRepository
.findMostPopular()
return Mono.zip(
);
}
.addResilience(…)
.zip(…)
.subscribe()
155

userRepository
.findMostActive()
userRepository
.findMostPopular()
return Mono.zip(
);
}
.addResilience(…)
.zip(…)
.subscribe()
156

userRepository
.findMostActive()
userRepository
.findMostPopular()
return Mono.zip(
topActiveUser.defaultIfEmpty(EMPTY_USER),
topMentionedUser.defaultIfEmpty(EMPTY_USER),
);
}
userRepository
.findMostActive()
userRepository
.findMostPopular()
return Mono.zip(
);
}
.addResilience(…)
.zip(…)
.subscribe()
157

userRepository
.findMostActive()
userRepository
.findMostPopular()
return Mono.zip(
);
}
.addResilience(…)
.zip(…)
.subscribe()
158

Toolset Tips
160
Spring MVC
Spring WebFlux
Reactive WebSocket

public interface WebSocketSession {
String getId();
HandshakeInfo getHandshakeInfo();
DataBufferFactory bufferFactory();
Flux<WebSocketMessage> receive();
Mono<Void> send(Publisher<WebSocketMessage> messages);
default Mono<Void> close() {
return close(CloseStatus.NORMAL);
}
Mono<Void> close(CloseStatus status);
WebSocketMessage textMessage(String payload);
WebSocketMessage binaryMessage(
Function<DataBufferFactory, DataBuffer> payloadFactory);
WebSocketMessage pingMessage(
WebSocketMessage pongMessage(
} 161

public interface WebSocketSession {
String getId();
HandshakeInfo getHandshakeInfo();
DataBufferFactory bufferFactory();
Flux<WebSocketMessage> receive();
Mono<Void> send(Publisher<WebSocketMessage> messages);
default Mono<Void> close() {
return close(CloseStatus.NORMAL);
}
Mono<Void> close(CloseStatus status);
WebSocketMessage textMessage(String payload);
WebSocketMessage binaryMessage(
WebSocketMessage pingMessage(
WebSocketMessage pongMessage(
} 162

@Override
public Publisher<?> handle()
{
return Flux.merge(
messageService.latest(),
statisticService
.usersStatisticStream()
);
}
network
.merge()
164

@Override
{
return Flux.merge(
statisticService
);
}
network
.merge()
165

@Override
{
return Flux.merge(
statisticService
);
}
network
.merge()
166

@Override
{
return Flux.merge(
statisticService
);
}
network
.merge()
167

.merge()
@Override
{
return Flux.merge(
statisticService
);
}
network
168

@Override
{
return Flux.merge(
statisticService
);
}
network
.merge()
169

@Override
{
return Flux.merge(
statisticService
);
}
network
.merge()
170

@Override
{
return Flux.merge(
statisticService
);
}
network
.merge()
171

174
Gitter Room:
Reactive EatDog

Checklist
• Message-Driven
• Resilient
• Responsive
• Elastic
176

Interfaces
178
TElement Mono<TElement>
Iterable<T> Flux<T>

ReactiveCrudRepository<T, ID>
179
CrudRepository<T, ID>
Database

Web Communication
180
RestTemplate WebClient

Web Endpoints
181
Spring MVC
Spring WebFlux

Advantages
• Reactive System
• Higher throughput
• Spring Framework support
183

Disadvantages
• Understanding
• JDBC driver
• Debug
184

1. Learn Project Reactor [http://projectreactor.io/learn]
2. Reactive WebFlux [https://docs.spring.io/spring-framework/
docs/5.0.0.RELEASE/spring-framework-reference/web-
reactive.html#spring-webflux]
3. File Reading in Reactor [https://simonbasle.github.io/2017/10/
file-reading-in-reactor/]
4. Zuul 2 - Netflix Tech Blog [https://medium.com/netflix-techblog/
zuul-2-the-netflix-journey-to-asynchronous-non-blocking-
systems-45947377fb5c]
5. Benchmark [https://github.com/CollaborationInEncapsulation/
blocking-vs-nonblocking-benchmark]
186

https://goo.gl/Rsp8ji
187
Presentation

Refactor to Reactive With Spring 5 and Project Reactor

More Related Content

What's hot

Similar to Refactor to Reactive With Spring 5 and Project Reactor

More from EatDog

Recently uploaded

Refactor to Reactive With Spring 5 and Project Reactor