创建使用 Kotlin 的 Spring Boot 项目

The first part of the tutorial shows you how to create a Spring Boot project in IntelliJ IDEA using Project Wizard.

Before you start

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

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 Spring Boot project

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

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

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

   • Name: demo
   • Language: Kotlin
   • Build system: Gradle

   • JDK: Java 17 JDK

     This tutorial uses Amazon Corretto version 18.

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

Explore the project Gradle build file

Open the build.gradle.kts file: it is the Gradle Kotlin build script, which contains a list of the dependencies required for the application.

The Gradle file is standard for Spring Boot, but it also contains necessary Kotlin dependencies, including the kotlin-spring Gradle plugin – kotlin("plugin.spring").

Here is the full script with the explanation of all parts and dependencies:

import org.jetbrains.kotlin.gradle.tasks.KotlinCompile // For `KotlinCompile` task below

plugins { 
    id("org.springframework.boot") version "3.1.2"
    id("io.spring.dependency-management") version "1.1.2"
    kotlin("jvm") version "1.9.24" // The version of Kotlin to use
    kotlin("plugin.spring") version "1.9.24" // The Kotlin Spring plugin
}

group = "com.example"
version = "0.0.1-SNAPSHOT"

java {
    sourceCompatibility = JavaVersion.VERSION_17
}

repositories {
    mavenCentral()
}

dependencies { 
    implementation("org.springframework.boot:spring-boot-starter-data-jdbc") 
    implementation("org.springframework.boot:spring-boot-starter-web") 
    implementation("com.fasterxml.jackson.module:jackson-module-kotlin") // Jackson extensions for Kotlin for working with JSON
    implementation("org.jetbrains.kotlin:kotlin-reflect") // Kotlin reflection library, required for working with Spring
    runtimeOnly("com.h2database:h2") 
    testImplementation("org.springframework.boot:spring-boot-starter-test")
}

tasks.withType<KotlinCompile> { // Settings for `KotlinCompile` tasks
    kotlinOptions { // Kotlin compiler options
        freeCompilerArgs = listOf("-Xjsr305=strict") // `-Xjsr305=strict` enables the strict mode for JSR-305 annotations
        jvmTarget = "17" // This option specifies the target version of the generated JVM bytecode
    }
}

tasks.withType<Test> { 
    useJUnitPlatform()
}

As you can see, there are a few Kotlin-related artifacts added to the Gradle build file:

1. In the plugins block, there are two Kotlin artifacts:

   • kotlin("jvm") – the plugin defines the version of Kotlin to be used in the project
   • kotlin("plugin.spring") – Kotlin Spring compiler plugin for adding the open modifier to Kotlin classes in order to make them compatible with Spring Framework features

2. In the dependencies block, a few Kotlin-related modules listed:

   • com.fasterxml.jackson.module:jackson-module-kotlin – the module adds support for serialization and deserialization of Kotlin classes and data classes
   • org.jetbrains.kotlin:kotlin-reflect – Kotlin reflection library

3. After the dependencies section, you can see the KotlinCompile task configuration block. This is where you can add extra arguments to the compiler to enable or disable various language features.

Explore the generated Spring Boot application

Open the DemoApplication.kt file:

package com.example.demo

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

@SpringBootApplication
class DemoApplication

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

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!"
}

These Spring annotations also require additional imports:

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

Here is a complete code of the DemoApplication.kt:

package com.example.demo

import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.RequestParam
import org.springframework.web.bind.annotation.RestController

@SpringBootApplication
class DemoApplication

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

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

Run the application

The Spring application is now ready to run:

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

   

   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:

   

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