Spring Boot mit Kotlin

Spring Boot makes it easy to create stand-alone, production-grade Spring-based Applications that you can ‘just run’.

Kotlin wurde so konzipiert, dass es gut mit dem Java-Ökosystem zusammenspielt, und es scheint mir, dass es die gleiche pragmatische und innovative Denkweise teilt wie Spring Boot, sodass sie gut zusammenspielen. In diesem Beitrag werde ich eine Spring Boot-Anwendung von Anfang an mit Kotlin als Hauptsprache erstellen. Man wird lernen, wie Kotlin mit Spring arbeitet. Am Ende wird man eine einfache Spring-Anwendung haben, die mit Kotlin implementiert ist. Mit jeder neuen Version von Spring Boot haben wir eine bessere Kotlin-Unterstützung und können Spring-Anwendungen mit minimalem Boilerplate programmieren.

Spring Boot bietet eine idiomatische Möglichkeit, eine Anwendung mit runApplication<MyApplication>(*args) auszuführen. Wir haben die Methode mit dem reifizierten Typparameter MyApplication qualifiziert, jetzt ist er innerhalb der Funktion zugänglich. Da die Funktion inline ist, ist der Zugriff auf den Typparameter zur Laufzeit ohne Reflection möglich. Normale Funktionen (nicht als inline markiert) können keine reified Typparameter haben.

Anwendungsbeispiel

Lass uns eintauchen und eine Kotlin-Anwendung mit Spring Boot 2 erstellen! Die Unterstützung von Spring durch Kotlin ist in der Referenzdokumentation zu Spring Framework und Spring Boot dokumentiert.

Gradle ist das am häufigsten verwendete Build-Werkzeug für Kotlin und stellt eine Kotlin-DSL zur Verfügung, die bei der Generierung eines Kotlin-Projekts standardmäßig verwendet wird, sodass dies die empfohlene Wahl ist. Man kann aber auch Maven verwenden, wenn man damit besser zurechtkommt. Zuerst müssen wir eine Spring Boot Anwendung erstellen, was auf verschiedene Arten geschehen kann. Ich werde den Spring Initializer von https://start.spring.io verwenden, um das Grundgerüst für eine Spring-Anwendung mit der Spring Web-Abhängigkeit zu generieren:

Das Projekt sollte die folgende Struktur haben:

Wenn man das Projekt importiert hat, sieht man, dass es eine einzige Anwendungsdatei mit dem Namen SpringKotlinApplication.kt enthält. In der Datei finden man den folgenden Code:

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

@SpringBootApplication
class SpringBootKotlinApplication

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

Diese Datei enthält die main Funktion, mit der die Anwendung gestartet wird. Um eine Funktion in Kotlin zu deklarieren, verwendet man das Schlüsselwort fun, gefolgt von ihrem Namen, den Parametern und dem Rückgabetyp. Wenn es keinen Rückgabetyp gibt, gibt man nichts an, was bei dieser Funktion der Fall ist.

Auch hier hat man eine mit @SpringBootApplication annotierte Klasse, die sich genauso verhält wie in Java. Man wird auch feststellen, dass SpringKotlinApplication nicht als public deklariert ist. Der Grund ist ziemlich einfach: Alle Klassen sind in Kotlin standardmäßig public! Zusätzlich kann eine Klasse, die keine Variablen und keine Funktionen hat, ohne geschweifte Klammern deklariert werden. Im Wesentlichen haben wir also gerade eine Klasse definiert.
Jede außerhalb des Körpers einer Klasse definierte Funktion ist automatisch statisch. Dadurch ist diese Funktion für die Startausführung geeignet.

Gradle

Die Schlussfolgerung, die wir aus der Gradle-Konfiguration ziehen, ist die folgende: Sie enthält die Spring-Framework-Plugins mit Abhängigkeiten für Spring-Boot. Sie enthält Abhängigkeiten wie:

  • kotlin-stdlib-jdk8 – ist die Java-8-Variante der Kotlin-Standardbibliothek
  • kotlin-reflect – ist die Kotlin Reflection-Bibliothek
  • jackson-module-kotlin – fügt Unterstützung für die Serialisierung/Deserialisierung von Kotlin-Klassen und Datenklassen hinzu, ein Thema, das in weiteren Blogbeiträgen diskutiert werden soll.

Die Datei build.gradle.kts enthält folgenden Code

import org.jetbrains.kotlin.gradle.tasks.KotlinCompile

plugins {
   id("org.springframework.boot") version "2.3.2.RELEASE"
   id("io.spring.dependency-management") version "1.0.9.RELEASE"
   kotlin("jvm") version "1.3.72"
   kotlin("plugin.spring") version "1.3.72"
}

group = "com.trivadis"
version = "0.0.1-SNAPSHOT"
java.sourceCompatibility = JavaVersion.VERSION_11

repositories {
   mavenCentral()
}

dependencies {
   implementation("org.springframework.boot:spring-boot-starter-web")
   implementation("com.fasterxml.jackson.module:jackson-module-kotlin")
   implementation("org.jetbrains.kotlin:kotlin-reflect")
   implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
   testImplementation("org.springframework.boot:spring-boot-starter-test") {
      exclude(group = "org.junit.vintage", module = "junit-vintage-engine")
   }
}

tasks.withType<Test> {
   useJUnitPlatform()
}

tasks.withType<KotlinCompile> {
   kotlinOptions {
      freeCompilerArgs = listOf("-Xjsr305=strict")
      jvmTarget = "11"
   }
}

Danach muss nur noch eine RestController-Klasse hinzugefügt und die Anwendung gestartet werden. Die RestController-Annotation @RestController zeigt an, dass die Klasse eingehende Anforderungen behandelt, und die @GetMapping-Annotation zeigt Methoden an, die einzelne Endpunkte behandeln:

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

@RestController
class Controller {

    @GetMapping("/helloWorld")
    fun helloWorld(): String {
        return "Hello, World"
    }

    @GetMapping("/helloName")
    fun helloName(@RequestParam("name") name: String): String {
        return "Hello, $name"
    }
}

Man führt die Anwendung aus, indem man die Klasse SpringKotlinApplication in der IDE ausführt (oder mit ./gradlew bootRun). Man geht danach auf http://localhost:8080/helloWorld. Es sollte die folgende Begrüßungsnachricht im Browser zu sehen sein:

Wir können es dynamischer gestalten, indem wir die Nachricht in dem Endpunkt für die Begrüßung aller Personen verfügbar machen. Bei der zweiten Methode, helloName(), erhält die Funktion einen Parameter namens name.

In Kotlin deklariert man Parameter, indem man zuerst den Namen angibt, gefolgt von einem Doppelpunkt und seinem Typ. Dies ist die gleiche Konvention, die zur Deklaration des Rückgabetypen einer Funktion verwendet wird. Die Annotation @RequestParam wird an die gleiche Stelle gesetzt wie im Java-Code.

Vielleicht ist euch auch aufgefallen, dass man Strings nicht konkatenieren muss, um variable Werte einzufügen. Kotlin hat eine eingebaute Funktion namens String-Templates, die es erlaubt, eine Variable zu referenzieren, indem man das $-Zeichen gefolgt vom Variablennamen selbst setzt.

Startet man die Anwendung erneut und öffnet den folgenden Link http://localhost:8080/helloName?name=Andrada, dann sollte man die nachstehende Meldung sehen:

In diesem Artikel befassten wir uns mit der Kotlin-Unterstützung in Spring Boot 2.x. Anhand eines Beispiels sahen wir, dass Kotlin unsere Anwendungen vereinfachen und verbessern kann, indem es uns dabei unterstützt, kürzeren und sichereren Code zu schreiben. Kotlin unterstützt auch einige erstaunliche Funktionen wie Datenklassen, Extension Functions und ist vollständig kompatibel mit vorhandenem Java-Code. Das bedeutet, dass man Kotlin-Code schreibt und von den Java-Klassen aus aufrufen kann und umgekehrt. Darüber hinaus wurde Kotlin von Grund auf so aufgebaut, dass es fantastische Unterstützung in einer IDE bietet, und das tut es auch.

Es gibt viele Gründe, Kotlin auszuprobieren, und mit der Unterstützung von Google und Spring ist es jetzt an der Zeit, es auszuprobieren. Dieser Blog-Beitrag ist der dritte Blog-Beitrag (Kotlin für Java-Entwickler, Kotlin Multi-Platform Projekte für die Web-Entwicklung) aus einer Serie von Kotlin-Blog-Beiträgen. Es ist geplant, weitere interessante Artikel zu schreiben, also bleibt dran.

Views All Time
439
Views Today
7
Short URL for this post: https://blog.oio.de/SkEWA
This entry was posted in Other languages for the Java VM and tagged , . Bookmark the permalink.

1 Response to Spring Boot mit Kotlin

  1. Pingback: Web UIs mit Kotlin | techscouting through the java news

Leave a Reply

Your email address will not be published. Required fields are marked *