1. Introduction
In this tutorial, we’ll create a simple REST controller using Spring Boot with Kotlin and Gradle. We’ll also discover how easily we can deploy it as a Docker image.
2. Imports
In order to implement our REST controller with Spring Boot and Kotlin, we’ll have to add the following dependencies to our project:
implementation("org.springframework.boot:spring-boot-starter-web")
implementation("com.fasterxml.jackson.module:jackson-module-kotlin")
(For new projects, we’d recommend creating them using https://start.spring.io)
3. Create a Data Class
As the next step, let’s implement a Person data class consisting of two immutable properties: id and a name:
data class PersonResponse(val id: Int, val name: String)
4. Controller
We can now create a PersonController with getPerson function:
@RestController
class PersonController {
val personId = AtomicInteger()
@GetMapping("/person")
fun getPerson(@RequestParam(value = "name", defaultValue = "Foo") name: String) =
PersonResponse(personId.incrementAndGet(), name)
}
This is a very simple function responding to GET requests to /person?name={userValue} and returning a JSON object which represents an instance of PersonResponse.
5. Run the Application
Finally, we can run our application using one of the Gradle Wrapper tasks:
./gradlew bootRun
Let’s verify the output:
curl localhost:8080/person?name=John curl localhost:8080/person
{"id":1,"name":"John"}
{"id":2,"name":"Foo"}
As can be seen, the default value “Foo” is used, when we don’t specify any value for the name parameter in our request.
6. Dockerize the Application
So at this point, we have a working REST API created with Spring Boot and Kotlin and the last thing we need is Docker integration.
6.1. Create a Dockerfile
In order to dockerize our application, we will need to create a Dockerfile and put it in the root directory of our project:
FROM openjdk VOLUME /tmp RUN mkdir /work COPY . /work WORKDIR /work RUN /work/gradlew build RUN mv /work/build/libs/*.jar /work/app.jar ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/work/app.jar"]
6.2. Create a .dockerignore
Let’s exclude unnecessary directories and files from the building process:
.gradle build out
6.3. Check the Dockerfile
Finally, let’s build the image and create a new container:
docker build --no-cache -t person-app . docker run -it --rm -p 8080:8080 person-app
Once the process is finished, we can repeat steps from step 5 and ensure that everything is working properly.
7. REST API With Spring Boot, Kotlin and Docker Summary
In this article, we’ve discovered how easy it is to expose a REST endpoint in a containerized Spring Boot application with Kotlin, Gradle, and Docker. If you’d like to see the whole project implementation, please head to our GitHub project.
Finally, if you really enjoyed this post, I’d be very grateful if you’d help it spread by sharing it with your friends. Let’s build a better community together! 🙂
If you have any ideas or comments that you would like to share with us, please let us know in the comments below, by our Facebook page or group, or by using our contact form.
