Before you start

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

Create a Spring Boot project

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

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

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

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

   • Name: demo

   • Language: Kotlin

   • Build system: Gradle

   • JDK: Java 17 JDK

   • 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.

   The IDE will generate and open the 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.

Explore the generated Spring Boot application

Open the DemoApplication.kt file:

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 *).

Create a controller

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 DemoApplication.kt file, create the MessageController class as follows:

@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.

Here is a complete code of the DemoApplication.kt:

Run the application

The Spring application is now ready to run:

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

   

   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:

   

Next step

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

Get the Kotlin language map

Get your personal language map to help you navigate Kotlin features and track your progress in studying the language. We will also send you language tips and useful materials on using Kotlin with Spring.