Spring Boot Application in Kotlin: A Step-by-Step Guide

May 19, 2024

—

Introduction

Spring Boot is a powerful framework for building production-ready applications in Java. Kotlin, with its concise syntax and modern features, is a perfect companion for Spring Boot. In this blog post, we’ll walk through creating a Spring Boot application in Kotlin.

Prerequisites

Before we begin, ensure you have the following installed:

JDK 11 or higher
IntelliJ IDEA (or your preferred IDE)
Gradle or Maven

Setting Up the Project

Step 1: Create a New Project

Open IntelliJ IDEA.
Click on Create New Project.
Select Spring Initializr and fill in the details:
- Group: company.venturem
- Artifact: spring-kotlin-demo
- Dependencies: Spring Web, Spring Data JPA, H2 Database, Spring Boot DevTools.

Step 2: Project Structure

After setting up the project, your structure should look like this:

Plain Text

spring-kotlin-demo
├── src
│   ├── main
│   │   ├── kotlin
│   │   │   └── company
│   │   │       └── venturem
│   │   │           ├── SpringKotlinDemoApplication.kt
│   │   │           ├── controller
│   │   │           │   └── HelloController.kt
│   │   │           ├── entity
│   │   │           │   └── User.kt
│   │   │           ├── repository
│   │   │           │   └── UserRepository.kt
│   │   │           └── service
│   │   │               └── UserService.kt
│   ├── resources
│   │   ├── application.properties
│   └── test
│       └── kotlin
│           └── company
│               └── venturem
│                   └── SpringKotlinDemoApplicationTests.kt

Writing Code

Step 3: Main Application Class

Create the main application class in company.venturem package.

package company.venturem

import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication

@SpringBootApplication
class SpringKotlinDemoApplication

fun main(args: Array<String>) {
    runApplication<SpringKotlinDemoApplication>(*args)
}

Step 4: Controller

Create a simple REST controller in the controller package.

package company.venturem.controller

import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.RestController

@RestController
class HelloController {

    @GetMapping("/hello")
    fun sayHello(): String {
        return "Hello, World!"
    }
}

Step 5: Entity

Define an entity class for a User in the entity package.

package company.venturem.entity

import javax.persistence.Entity
import javax.persistence.GeneratedValue
import javax.persistence.GenerationType
import javax.persistence.Id

@Entity
data class User(
    @Id @GeneratedValue(strategy = GenerationType.AUTO)
    val id: Long = 0,
    val name: String,
    val email: String
)

Step 6: Repository

Create a repository interface for the User entity in the repository package.

package company.venturem.repository

import company.venturem.entity.User
import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.stereotype.Repository

@Repository
interface UserRepository : JpaRepository<User, Long>

Step 7: Service

Implement a service class to handle business logic in the service package.

package company.venturem.service

import company.venturem.entity.User
import company.venturem.repository.UserRepository
import org.springframework.stereotype.Service

@Service
class UserService(private val userRepository: UserRepository) {

    fun getAllUsers(): List<User> = userRepository.findAll()

    fun getUserById(id: Long): User? = userRepository.findById(id).orElse(null)

    fun createUser(user: User): User = userRepository.save(user)

    fun deleteUser(id: Long) = userRepository.deleteById(id)
}

Step 8: Application Properties

Configure the H2 database in application.properties.

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.h2.console.enabled=true
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

Running the Application

Run the SpringKotlinDemoApplication class. Once the application starts, you can test the endpoints.

Open your browser and go to http://localhost:8080/hello. You should see “Hello, World!”.

Conclusion

Congratulations! You’ve successfully created a simple Spring Boot application using Kotlin. This setup can be extended to build more complex applications by adding more entities, services, and controllers. Kotlin’s concise syntax and Spring Boot’s powerful features make a great combination for developing modern, robust applications.