Spring WebFlux with Kotlin – Reactive Web

Spring – even more fancy

As you might most certainly know, I’m one of theseKotlin“hipsters”, who’s really loving the language and wouldn’t write any more Java, if it was that easy. If you’re not familiar with my articles, have a look at the other Kotlin related postshere.

Besides Kotlin, I’ve always been intoSpringever since I started with Java back in 2011. I still like the framework although it’s getting bigger and bigger and you often don’t quite know which feature to choose amongst all the alternatives. As the framework itself is growing, thedocumentation, which is one of best you’ll ever get to see, also is.

The thing I like most about Spring is, that you can focus on your business logic from day one and don’t have much technical, infrastructural stuff to set up before kicking of. Spring does that by encapsulating a lot of boilerplate that’s necessary for certain tasks and provides simple annotations we can apply in order to make use of these features. One of the most famous modules certainly isSpring Web MVC, which is widely used when ever it comes to web services on the JVM.

Reactive Programming – The non-blocking way

You might have noticed, thatReactive Programmingis getting more attention recently. There are many frameworks emerging that want to encourage this style of programming, namelyRxJava,Vert.XorAkkafor example. If you’ve never come across these, you can read my post onKotlin with Vert.X as a first step.

Spring reactive

What does this have to do with Spring though? Well, of course, there’s yet another library for building reactive systems, which in fact is powered by Spring:Project Reactor. Reactor will be used in the upcoming Spring Release 5.0, coming as stable in September hopefully, which is going to introduce areactive web frameworkcalledWebFlux.

This fact on it’s own is a good reason for me to dive into it as it sounds fairly fantastic knowing Web MVC as Spring’s outstanding module already. But, there’s yet another great reason to take this expansion into account: Spring is greatly supportingKotlinand will even introduce_Kotlin dedicated_features with the upcoming major release ��

This is going to be achieved by making use of extension functions in order to extend existing APIs and also by introducing Kotlin DSLs, also a topic I’m really interested in, as you can read in my post oncreating a DSL with Kotlin. One of these new DSLs goes hand in hand with SpringWebFlux: a functional DSL for describing the WebFlux-backed web service. With that we want to create a Spring WebFlux with Kotlin app.

This in fact is what I am going to present to you in a very short example up next…​

Spring WebFlux with Kotlin in Action

Let’s have a look at a very basic application using_Spring WebFlux_in a_Kotlin_application. The initial setup can easily be downloaded as aSpringBootapplication fromSpring Initializr, if you choose Kotlin as the programming language and also enable the “Reactive Web” dependency, which is available since SpringBoot 2.0.0.

As soon as we’ve imported this project into our IDE, we can start with creating a reactive web service.

For the sake of brevity, I chose a very simple, not very useful, example: An internally managed repository of simpleStrings, that is populated through the web interface and also is searchable from it.

Thanks to Kotlin, and also Spring, this is not much code to write:

Repo and Handler

@Component
class
ReactiveHandler
(
val
repo: StringRepo) {
fun
getText
(search:
String
)
: Mono
<
String
>
=
repo.
get
(search).toMono().map {
"Result:
$it
!"
}
fun
addText
(text:
String
)
: Mono
<
String
>
=
repo.add(text).toMono().map {
"Result:
$it
!"
}
fun
getAllTexts
()
: Flux
<
String
>
=
repo.getAll().toFlux().map {
"Result:
$it
"
}
}
@Component
class
StringRepo
{
private
val
entities = mutableListOf
<
String
>
()
fun
add
(s:
String
)
= entities.add(s)
fun
get
(s:
String
)
= entities.find { it == s } ?:
"not found!"
fun
getAll
()
= listOf(entities)
}

We just create a repository that maintains a list ofStrings and another classReactiveHandler, which is responsible for delegating to the repository and providing “reactive types” defined in Reactor and mandatory for WebFlux:FluxandMono(Read about ’emhere). Regardless of their intention, have a look at how they are created:toMono()andtoFlux()are an example of extension functions added in Spring 5.0, a feature dedicated to Kotlin.

Using the function DSL

The much more interesting part though, is where the web routing is defined. This part in particular is where the already mentioned functional DSL comes into play. Let’s observe how it works.

Functional WebFlux DSL

@Configuration
class
RoutingConfiguration
{
@Bean
fun
routerFunction
(handler:
ReactiveHandler
)
:
RouterFunction
<
ServerResponse
>
= router {
(
"/reactive"
).nest {
val
searchPathName =
"search"
val
savePathName =
"save"
GET(
"/{
$searchPathName
}"
) { req -
>
val
pathVar = req.pathVariable(searchPathName)
ServerResponse.ok().body(
handler.getText(pathVar)
)
}
GET(
"/"
) {
ServerResponse.ok().body(handler.getAllTexts())
}
PUT(
"/{
$savePathName
}"
) { req -
>
val
pathVar = req.pathVariable(savePathName)
ServerResponse.ok().body(
handler.addText(pathVar)
)
}
}
}
}

Therouterfunction is the entry point of the new DSL, whose definition you can observe onGitHub. The shown solution is just one out of many possible solutions since the DSL provides more ways you can choose from. With my definition, the server starts a web service under “/reactive” and accepts two GET requests and a PUT request, each of which is delegated to the previously shownReactiveHandler(see method parameter) before the results are put into aServerResponse. Of course, you’d have to handle errors in a real-world scenario and “ok” wouldn’t be the only response.

Benefit

If you ask me, this approach is very clean structured and even provides the opportunity of using any Kotlin code for defining variables, loops, conditions, whatsoever inside the actual DSL code. Given that, you have a very powerful tool which can be utilized in a very natural programmatic way.

If your like to check this out, the code is available in myrepository.

Wrap-up and Perspective

I’ve presented a small project that’s making use of Spring 5.0 and its new module WebFlux in combination with Kotlin. I think, the fact, that Spring officially uses and supports Kotlin is averyimportant one, I’d like to emphasize once again.

Kotlin – It’s not only Android!

We all know, that Kotlin made its way into Android, which was possible because Google announced the official support a few weeks ago. On the server-side though, people and especially companies hesitate when it comes to Kotlin. They tend to have doubts as to whether Kotlin’s really mature enough already.

When youask me, there’s no good reason for hesitation. Many projects use Kotlin already, frameworks support Kotlin and even extend their libraries with dedicated Kotlin features. Spring, as one of the most common Java frameworks seems to think the same as they quickly adopted Kotlin as analternativeto Java and Groovy for SpringBoot applications. The most recent developments, which are part of Spring 5.0, are the next step, some of which we’ve observed in this little article.

If you’re, same as me, interested in spreading Kotlin as an alternative to Java, talk about it and tell your colleagues about Spring’s support and what’s actually happening :wink:

Special Thanks

As you can read in thisarticle, Spring’s introducing quite a few Kotlin features. There’s one guy,Sébastien Deleuze, who’s highly responsible for this development in the Spring Framework. He has also been part oftalkingkotlinalready, as one of the first discussion partners of Hadi Hariri. It’s really great to have such influencers in the Kotlin community, many thanks to you!Keep up the great work��

If you like to have a look at my examples, the code is available here:Git. Feel free, to give any feedback, I’m always happy to help. Also, If you like, have a look at myTwitteraccount and follow if you’re interested in more Kotlin stuff �� Thanks a lot.

Simon

Source: https://blog.simon-wirtz.de/spring-webflux-with-kotlin-reactive-web/