Spring Boot 2 Meets Kotlin

Hello Guys.

Today we will talk about the new feature added in Spring 5.0 and Spring Boot 2. We will understand the Kotlin support for Spring Boot Applications.

Kotlin is a new language created by JetBrains Team. The language is JVM language. It means the language creates a bytecode to run on Java Virtual Machine.

As we can see, the primary inspiration is Scala language. There are many constructions similar in both languages, the data classes concepts for instance.

There are some interesting advantages when we adopt Kotlin to code. The most exciting is reduce boilerplate code and make our code more concise, it brings more maintainability and transforms our code more readable.

We will understand these topics on next examples, then is Time to Code!!!

Create the Tasks Project with Spring Initializr

We will create a simple project to manage Tasks. The main idea here is to explain some Kotlin interesting points on this project.

Let’s go to Spring Initiliazr page. The project should be created with these configurations below:

The interesting points here are:

  • Maven Project
  • Kotlin Language
  • Spring Boot 2
  • Dependencies: Reactive Web, Actuator and Reactive MongoDB

Creating our TaskEntity

We need to create our main entity. The entity is pretty simple and so easy to implement the Task class should be like this:

As we can see, there are some Kotlin interesting points here. There is a data class keyword it means the class has the purpose of holding data. Kotlin will add some important behaviors automatically like:

  • equals() and hashCode()
  • toString()
  • copy()

there are some restrictions the data classes cannot be abstract, open, sealed or inner.

The full data classes documentation can be found here.

Creating the Reactive Task Repository

Now, we will use the Spring Data MongoDB Reactive implementation. The behaviors are similar in the blocking version, but it will not blocking because is the reactive version. The way to thinking is similar there is DSL to use objects properties to create queries automatically.

The TaskRepository should be like this:

The keyword interface is the same in Java language, but the way to extends is Kotlin is slightly different, in Kotlin we will use “:” instead of extends.

Creating the TaskService

Let’s create our TaskService class it will invoke the repository implementations. The code of TaskService should be like this:

There are a couple of interesting things here. Let’s start by injection, there is no necessity to use @Autowired in class constructor since Spring Framework 4 version, as we can see it will work as expected here as well. We use val in favor immutability.

Let’s understand the tasks() function. The function has no┬ábody because of the implementation has one line only. In this case, the function return can be omitted as well. It makes the code more concise and easy to understand.

We have used the same features in our other functions.

The full documentation about functions can be found here.

The REST Layer

Our REST Layer should be reactive. Then we need to return Flux or Mono in our methods. We will use the one line function and we can omit these declarations, keep in mind to achieve reactive functionalities we need Flux or Mono in our methods.

The TaskResource class should be like this:

As we can see we are using the same as we did before, we have not used return methods declaration, the compiler can infer it for us, also it prevents developers errors as well.

We are using the @GetMapping and @PostMapping instead of @RequestMapping annotations, it makes our code more readable.

Configuring the MongoDB connections

We will use the yaml file, it makes our configuration file more readable and introduces semantics in our file. The configuration file should be like this:

There is nothing special here, a couple of configurations for mongoDB and tomcat server.

The Final Project Structure

Let’s analyze the final project structure, you can put in your preferred structure. I suggest the following one:


Excellent, now we can run it.

Run it and try your pretty new API using Kotlin Language!!!

Awesome Job, well done!!!

The full source code can be found here.


I recommend docker to run a mongoDB instance it makes your life extremely easy.


You can find more detailed implementations and different Use Case in my book ( Spring 5.o By Example), published by Packt.


Thank you, for next Post, I will write about Spring Cloud Gateway and how it can help developers to work with Routes.