Create a Spring Boot project with Kotlin

Download and install the latest version of IntelliJ IDEA Ultimate Edition.

note

If you use IntelliJ IDEA Community Edition or another IDE, you can generate a Spring Boot project using a web-based project generator.

Create a new Spring Boot project with Kotlin by using the Project Wizard in IntelliJ IDEA Ultimate Edition:

note

You can also create a new project using IntelliJ IDEA with the Spring Boot plugin.

1. In IntelliJ IDEA, select File | New | Project.

2. In the panel on the left, select New Project | Spring Boot.

3. Specify the following fields and options in the Project Wizard window:

   • Name: demo

   • Language: Kotlin

   • Type: Gradle - Kotlin

     tip

     This option specifies the build system and the DSL.

   • Package name: demo

   • JDK: Java JDK

     note

     This tutorial uses Amazon Corretto version 21. If you don't have a JDK installed, you can download it from the dropdown list.

   • Java: 17

   

4. Ensure that you have specified all the fields and click Next.

5. Select the following dependencies that will be required for the tutorial:

   • Web | Spring Web

   • SQL | Spring Data JDBC

   • SQL | H2 Database

   

6. Click Create to generate and set up the project.

   tip

   The IDE will generate and open a new project. It may take some time to download and import the project dependencies.

7. After this, you can observe the following structure in the Project view:

   

   The generated Gradle project corresponds to the Maven's standard directory layout:

   • There are packages and classes under the main/kotlin folder that belong to the application.

   • The entry point to the application is the main() method of the DemoApplication.kt file.

Open the DemoApplication.kt file:

// DemoApplication.kt
package demo

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

@SpringBootApplication
class DemoApplication

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

Declaring classes – class DemoApplication

Right after package declaration and import statements you can see the first class declaration, class DemoApplication.

In Kotlin, if a class doesn't include any members (properties or functions), you can omit the class body ({}) for good.

@SpringBootApplication annotation

@SpringBootApplication annotation is a convenience annotation in a Spring Boot application. It enables Spring Boot's auto-configuration, component scan, and be able to define an extra configuration on their "application class".

Program entry point – main()

The main() function is the entry point to the application.

It is declared as a top-level function outside the DemoApplication class. The main() function invokes the Spring's runApplication(*args) function to start the application with the Spring Framework.

Variable arguments – args: Array<String>

If you check the declaration of the runApplication() function, you will see that the parameter of the function is marked with vararg modifier: vararg args: String. This means that you can pass a variable number of String arguments to the function.

The spread operator – (*args)

The args is a parameter to the main() function declared as an array of Strings. Since there is an array of strings, and you want to pass its content to the function, use the spread operator (prefix the array with a star sign *).

The application is ready to run, but let's update its logic first.

In the Spring application, a controller is used to handle the web requests. In the same package with DemoApplication.kt file, create the MessageController.kt file with the MessageController class as follows:

// MessageController.kt
package demo

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

@RestController
class MessageController {
    @GetMapping("/")
    fun index(@RequestParam("name") name: String) = "Hello, $name!"
}

@RestController annotation

You need to tell Spring that MessageController is a REST Controller, so you should mark it with the @RestController annotation.

This annotation means this class will be picked up by the component scan because it's in the same package as our DemoApplication class.

@GetMapping annotation

@GetMapping marks the functions of the REST controller that implement the endpoints corresponding to HTTP GET calls:

@GetMapping("/")
fun index(@RequestParam("name") name: String) = "Hello, $name!"

@RequestParam annotation

The function parameter name is marked with @RequestParam annotation. This annotation indicates that a method parameter should be bound to a web request parameter.

Hence, if you access the application at the root and supply a request parameter called "name", like /?name=<your-value>, the parameter value will be used as an argument for invoking the index() function.

Single-expression functions – index()

Since the index() function contains only one statement you can declare it as a single-expression function.

This means the curly braces can be omitted and the body is specified after the equals sign =.

Type inference for function return types

The index() function does not declare the return type explicitly. Instead, the compiler infers the return type by looking at the result of the statement on the right-hand side from the equals sign =.

The type of Hello, $name! expression is String, hence the return type of the function is also String.

String templates – $name

Hello, $name! expression is called a String template in Kotlin.

String templates are String literals that contain embedded expressions.

This is a convenient replacement for String concatenation operations.

The Spring application is now ready to run:

1. Click the green Run icon in the gutter beside the main() method:

   

   tip

   You can also run the ./gradlew bootRun command in the terminal.

   This starts the local server on your computer.

2. Once the application starts, open the following URL:

   http://localhost:8080?name=John

   You should see "Hello, John!" printed as a response:

   

In the next part of the tutorial, you'll learn about Kotlin data classes and how you can use them in your application.

Proceed to the next chapter