This document summarizes steps for converting a typical Spring Boot application in Java to an idiomatic Kotlin application using Spring Boot with Kotlin, Kofu, and Coroutines. It introduces Kofu, a new Kotlin DSL for configuration of Spring Boot applications, and outlines the general direction and upcoming features of Spring frameworks' support for Kotlin. The document contains code examples demonstrating how to use Coroutines and reactive programming with Spring WebFlux and Spring Data. It also contains a safe harbor statement noting that the information is intended for informational purposes only and is subject to change.

1. © Copyright 2019 Pivotal Software, Inc. All rights Reserved.
Sébastien Deleuze
@sdeleuze
4 Juillet 2019
Spring Boot with Kotlin,
Kofu and Coroutines

2. Safe Harbor Statement
The following is intended to outline the general direction of Pivotal's offerings. It is intended for
information purposes only and may not be incorporated into any contract. Any information
regarding pre-release of Pivotal offerings, future updates or other planned modifications is subject
to ongoing evaluation by Pivotal and is subject to change. This information is provided without
warranty or any kind, express or implied, and is not a commitment to deliver any material, code, or
functionality, and should not be relied upon in making purchasing decisions regarding Pivotal's
offerings. These purchasing decisions should only be based on features currently available. The
development, release, and timing of any features or functionality described for Pivotal's offerings in
this presentation remain at the sole discretion of Pivotal. Pivotal has no obligation to update forward
looking information in this presentation.
2

3. 2018
Coroutines
2019
Android is Kotlin first
2016
Kotlin 1.0
Kotlin on start.spring.io
Gradle Kotlin DSL
2017
Spring official Kotlin support
Android official Kotlin support
A little bit of history

4. The Kotlin rise continues

5. Why Kotlin?

6. Pragmatic
and elegant

7. (null) safety

8. Better signal-to-noise ratio

9. Make reactive easier
via Coroutines

10. steps to go from a typical Spring Boot
application in Java to an idiomatic Kotlin one3

11. Step 1 Java to Kotlin

14. Code

15. Step 2 Spring MVC
to WebFlux with Coroutines

16. WebFlux provides Spring MVC
programming model built on top a
reactive engine instead of Servlet

17. CompletableFuture
Flow.Publisher
Mono
Flux
Single / Maybe
Flowable
Spring WebFlux/Data with
Reactive Streams APIs
Application
...

18. Scalability
No more 1 request per thread

19. Neutral to latency

20. Streaming

21. Backpressure
Also outside the JVM via
R2DBC and RSocket

22. R2DBC

23. R2DBC is a reactive SPI*
for SQL drivers
* Service Provider Interface

24. Only depends on Reactive Streams

25. R2DBC SPI
Spring Data
R2DBC
PostgreSQL SQL Server H2 MySQL
...

26. Coroutines

27. Coroutines are Kotlin lightweight threads
allowing to write non-blocking code in an
imperative way
2
7

28. CompletableFuture
Flow.Publisher
Mono
Flux
Single / Maybe
Flowable
suspend fun
Flow
Spring WebFlux/Data with
Reactive Streams APIs
Application

29. How ReactiveX APIs translate to Coroutines
fun handler(): Mono<Void> suspend fun handler()
fun handler(): Mono<T> suspend fun handler(): T?
fun handler(): Flux<T> fun handler(): Flow<T>

30. interface WeatherService {
fun fetchWeather(location: String): Mono<Weather>
}
val location = "Lyon, France"
mainService.fetchWeather(location)
.timeout(Duration.ofSeconds(2))
.doOnError { logger.error(it.message) }
.onErrorResume { backupService.fetchWeather(location) }
.map { String.format("Weather in %s is %s", it.location, it.description) }
.subscribe { logger.info(it) }
interface WeatherService {
suspend fun fetchWeather(location: String): Weather
}
val location = "Lyon, France"
val weather = try {
withTimeout(2000L) {
mainService.fetchWeather(location)
}
} catch (ex: CancellationException) {
logger.error(ex.message)
backupService.fetchWeather(location)
}
String.format("Weather in %s is %s", weather.location, weather.description)
Reactor
declarative API
Coroutines
imperative API

31. Flow type introduced in Coroutines 1.2

32. Finite or infinite number of elements

33. Backpressure via suspending
functions

34. Operators are extension functions and
easy to implement

35. Code

36. Step 3 Annotations and
Spring Boot auto configuration to
explicit configuration via Kofu DSL

37. Spring Framework 5
introduced 2 Kotlin DSLs

38. Router DSL
router {
(accept(APPLICATION_JSON) and "/api").nest {
"/admin".nest {
GET("/ticket", ticketingHandler::findAll)
GET("/ticket/random", ticketingHandler::randomDraw)
GET("/favorite", favoriteHandler::findAll)
GET("/{year}/talk", talkHandler::findAdminByEventId)
}
GET("/talk/{login}", talkHandler::findOne)
GET("/{year}/talk", talkHandler::findByEventId)
"/user".nest {
GET("/", userHandler::findAll)
POST("/", userHandler::create)
GET("/{login}", userHandler::findOne)
}
}
}

39. Beans DSL
val myBeans = beans {
bean<Foo>()
bean<Bar>()
bean("bazBean") {
Baz().apply {
message = "Hello world"
}
}
profile("foobar") {
bean { FooBar(ref("bazBean")) }
}
bean(::myRouter)
}
class Foo
class Bar(private val foo: Foo)
class Baz(var message: String = "")
class FooBar(private val baz: Baz)
fun myRouter(foo: Foo, bar: Bar, baz: Baz) = router { ... }

40. Spring Fu is an incubator intended to mature
experimental features before inclusion in top-level
Spring projects (Framework, Boot, Data, etc.)
4
0

41. Spring Fu introduce a third DSL

42. Kofu

43. Kofu is a minimalist, efficient and explicit configuration
model for Spring Boot using a Kotlin DSL
4
3

44. Kofu configuration for Spring Boot
application(WebApplicationType.SERVLET) {
logging {
level = LogLevel.DEBUG
}
beans {
bean<SampleService>()
bean<SampleHandler>()
}
webMvc {
port = if (profiles.contains("test")) 8181 else 8080
router {
val handler = ref<SampleHandler>()
GET("/", handler::hello)
POST("/api", handler::json)
}
converters {
string()
jackson {
indentOutput = true
}
}
}
}
Experim
ental

45. Code

46. Kofu 0.2 is work in progress
● Spring Security DSL
● Spring Data JDBC, Redis, Cassandra, JOOQ
● Type safe configuration
Spring Framework 5.2 / Spring Boot 2.2 (September 2019)
● Official Coroutines support
● Significant throughput improvements
● Significantly faster startup
● Less memory consumption
● Data classes for configuration properties
Spring Framework 5.3 (2020)
● Out of the box GraalVM native image setup 4
6

47. Thanks
@sdeleuze
https://github.com/spring-projects/spring-fu