Kotlin + Spring Boot = Dobrana Para!

Trochę czasu minęło, ale pora żebyśmy wrócili do naszej aplikacji pisanej w Kotlinie do wykrywania plagiatów w kodach źródłowych programów. Dzisiaj zajmiemy się postawieniem prostego endpoint-a RESTowego używającej do tego Spring Boot.

Nowy moduł Mavenowy

Na początku musimy zacząć od stworzenia nowego moduły Mavenowego. Warto to zrobić, żeby odseperować sam algorytm i jego działanie od serwera.

Chcemy stworzyć moduł plag-api, aby nasza mavenowa struktura wyglądała następująco:

plag-detector
|-plag-algorithm
|-plag-api

Aby to zrobić musimy dodać 3 linię z fragment poniższego listingu do pliku pom.xml w projekcie plag-detector.

<modules>
	<module>plag-algorithm</module>
	<module>plag-api</module>
</modules>das

Gdy to zrobiliśmy to tworzymy folder plag-api dla tego modułu i plik pom.xml dla niego, który wygląda następująco:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>pl.lantkowiak</groupId>
    <artifactId>plag-api</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>plag-api</name>

    <!-- Jako parent ustawiamy spring-boot-starter-parent -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.9.RELEASE</version>
        <!-- Dzieki ponizszemu ustawieniu parent bedzie popierany z repozytorium -->
        <relativePath/>
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <kotlin.version>1.2.10</kotlin.version>
    </properties>

    <dependencies>
        <!-- zaleznosci potrzebne do web developmentu (np. wystawienia RESTa) -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- zaleznosci do biblioteki potrzebnej do Kotlina -->
        <dependency>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-stdlib-jre8</artifactId>
            <version>${kotlin.version}</version>
        </dependency>
        <dependency>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-reflect</artifactId>
            <version>${kotlin.version}</version>
        </dependency>

        <!-- zaleznosci do bibliotek zwiazanych z testami -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <sourceDirectory>${project.basedir}/src/main/kotlin</sourceDirectory>
        <testSourceDirectory>${project.basedir}/src/test/kotlin</testSourceDirectory>
        <plugins>
            <!-- plugin do obslugi spring boot -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maaen-plugin</artifactId>
            </plugin>
            <!-- plugin do Kotlins -->
            <plugin>
                <artifactId>kotlin-maven-plugin</artifactId>
                <groupId>org.jetbrains.kotlin</groupId>
                <version>${kotlin.version}</version>
                <configuration>
                    <compilerPlugins>
                        <plugin>spring</plugin>
                    </compilerPlugins>
                    <jvmTarget>${java.version}</jvmTarget>
                </configuration>
                <executions>
                    <execution>
                        <id>compile</id>
                        <phase>compile</phase>
                        <goals>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>test-compile</id>
                        <phase>test-compile</phase>
                        <goals>
                            <goal>test-compile</goal>
                        </goals>
                    </execution>
                </executions>
                <dependencies>
                    <dependency>
                        <groupId>org.jetbrains.kotlin</groupId>
                        <artifactId>kotlin-maven-allopen</artifactId>
                        <version>${kotlin.version}</version>
                    </dependency>
                </dependencies>
            </plugin>
        </plugins>
    </build>
</project>

Pora na REST service

Pora żebyśmy napisali nasz pierwszy REST Service. Jest to banalnie proste 😉

package pl.lantkowiak.plagdetector.api.rest

import org.springframework.web.bind.annotation.RequestMapping
import org.springframework.web.bind.annotation.RequestMethod
import org.springframework.web.bind.annotation.RestController

@RestController
class HelloService {
    @RequestMapping("/greeting", method = [RequestMethod.GET])
    fun hello(): String {
        return "Hello World!"
    }
}

Oznaczamy naszą klasę adnotacją @RestController, która powoduje, że nasza klasa jest traktowana jako REST controller, który jest zarządzany przez Springa.

Następnie tworzymy metodę, która zwraca Stringa. Będzie to metoda, która będzie wywoływana przez nasz endpoint RESTowy.

Kolejnym krokiem jest użycie adnotacji  @RequestMapping, wraz z dwoma parametrami:

  • “/greeting” – określa pod jakim adresem będzie dostępny nasz endpoint
  • method = [RequestMethod.GET] – określa jakiego typu metody RESTa będą obsłużone przez tę metodę; w naszym przypadku jest to GET

Pora to uruchomić!

Przyszła pora na uruchomienie naszego REST service’u. Aby to zrobić musimy stworzyć jeszcze jedną klasę wraz z metodą main.

@SpringBootApplication
class Application

fun main(args: Array<String>) {
    SpringApplication.run(Application::class.java, *args)
}

Naszą klasę oznaczamy adnotacją @SpringBootApplication, a w metodzie main uruchamiamy naszą aplikację.

Teraz wystarczy uruchomić naszą aplikację!

Sprawdźmy czy działa

Spring Boot domyślnie używa portu 8080. Żeby sprawdzić czy wszystko działa jak należy wystarczy, że wejdziemy pod poniższy adres:

http://localhost:8080/greeting

W przeglądarce powinniśmy zobaczyć napis Hello World!, który świadczy o tym, że wszystko działa jak należy 🙂

Podsumowanie

Dzisiaj stworzyliśmy nasz pierwszy REST service w Kotlinie przy użyciu Spring Boota. Osoby, które mają doświadczenie ze Spring Bootem na pewno zauważyły, że jego użycie w Kotlinie nie odbiega specjalnie od użycia w Javie.

Następnym razem spróbujemy użyć Dockera do uruchomienia aplikacji 🙂

← Previous post

Next post →

1 Comment

  1. Pawel Jaworski

    Można liczyć na dalsze wpisy z tej tematyki?

Dodaj komentarz

Twój adres email nie zostanie opublikowany. Pola, których wypełnienie jest wymagane, są oznaczone symbolem *