Erstelle eine Spring Boot REST-Anwendung mit Gradle

Tutorials

Gradle

In diesem Tutorial erstellen wir eine einfache RESTful Web-Dienst mit Spring Boot und Gradle. Spring Boot erleichtert die Erstellung von eigenständigen, produktionsreifen Spring-basierten Anwendungen, und Gradle ist ein leistungsstarkes Build-Tool, das den Build-Prozess vereinfacht.

Was ist REST?

REST, Representational State Transfer, ist eine Reihe von Architekturprinzipien, die sicherstellen, dass Ihre APIs interoperabel, skalierbar und wartbar sind. Stellen Sie sich vor, Lego-Blöcke zu bauen — verschiedene Anwendungen können nahtlos mit Ihrer API interagieren, solange sie die RESTful-Richtlinien befolgen, genau wie Legos zusammenklicken, unabhängig von ihrem Satz.

Was ist Spring Boot?

Spring Boot ist ein leistungsfähiges Framework, das den Entwicklungsprozess vereinfacht. Stellen Sie es sich als vorgefertigtes Toolkit vor, das mit Komponenten und Funktionen bestückt ist und Ihnen Zeit und Mühe beim Aufbau der Infrastruktur Ihrer Anwendung erspart. Sie können sich auf die Gestaltung der Kernlogik Ihrer API konzentrieren, ohne in Boilerplate-Code versinken.

Bereit, Ihren inneren API-Entwickler zu entfesseln? Dieser Leitfaden wird Ihnen dabei helfen, Ihre erste Spring Boot REST-Anwendung mit Gradle, einem beliebten Build-Tool, zu erstellen. Ob Sie ein erfahrener Java-Programmierer oder gerade erst Ihre Entdeckungsreise beginnen, wird diese schrittweise Reise Sie mit dem notwendigen Wissen ausstatten, um dynamische und interaktive Web-Dienste zu erstellen.

Schlüsselerkenntnisse

Erstellen von RESTful APIs mit Spring Boot: Spring Boot ist ein beliebter Java-Framework, das das Entwicklungsprozess von RESTful APIs vereinfacht. Es bietet eine Vielzahl von Funktionen „out of the box“, wie z.B. automatische Konfiguration und Dependency Injection, die Ihnen Zeit und Mühe sparen können.
Die Kernkonzepte von RESTful APIs verstehen: REST steht für Representational State Transfer. Es handelt sich um eine Reihe von Architekturprinzipien, die dafür sorgen, dass Ihre APIs interoperabel, skalierbar und wartbar sind. Einige der wichtigsten Konzepte von RESTful APIs umfassen Ressourcenrepräsentation, HTTP-Methoden und Statuscodes.
Grundlegende CRUD-Operationen implementieren: CRUD steht für Create, Read, Update und Delete. Dies sind die grundlegenden Operationen, die Sie in Ihren API-Endpunkten implementieren müssen, um Benutzern die Interaktion mit Ihren Daten zu ermöglichen.
Ihre API gründlich testen: Es ist wichtig, Ihre API gründlich zu testen, bevor Sie sie in Produktion bereitstellen. Dies hilft Ihnen dabei, sicherzustellen, dass sie wie erwartet funktioniert und keine Fehler aufweist.
Erweiterte Funktionalitäten erkunden: Wenn Sie mit Spring Boot und RESTful APIs vertrauter werden, können Sie sich weiteren erweiterten Funktionalitäten widmen, wie z.B. Datenmanagement, Sicherheit und Authentifizierung.

Durch die Kombination der Leistungsfähigkeit von REST mit dem effizienten Ansatz von Spring Boot können Sie effiziente und benutzerfreundliche APIs erstellen, die nahtlos mit anderen Anwendungen integriert werden können. Also, sind Sie bereit, das Potenzial von RESTful APIs mit Spring Boot und Gradle zu entsperren? Lass uns anfangen!

Voraussetzungen

Java Development Kit (JDK) 11 installiert
Aktuellste Gradle-Version installiert
Grundlegende Kenntnisse von Java und Spring-Konzepten

Schritt 1: Projekt einrichten

Um mit dem Projekt zu beginnen, müssen wir die folgenden drei Schritte ausführen.

Öffnen Sie ein Terminal oder eine Eingabeaufforderung
Erstellen Sie ein neues Verzeichnis für Ihr Projekt
Navigieren Sie zum Projektverzeichnis
Starten Sie eine grundlegende Spring Boot-Projektstruktur

Shell

mkdir spring-boot-rest-gradle
cd spring-boot-rest-gradle
gradle init --type spring-boot

Schritt 2: Erstellen eines Spring Boot-Projekts

Bitte bearbeiten Sie die vorhandene build.gradle-Datei im Verzeichnis mit dem folgenden Inhalt.

Groovy

plugins {
    id 'org.springframework.boot' version '2.6.3'
    id 'io.spring.dependency-management' version '1.0.11.RELEASE'
    id 'java'
}

group = 'com.example'
version = '1.0-SNAPSHOT'
sourceCompatibility = '11'

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

test {
    useJUnitPlatform()
}

Dies richtet ein grundlegendes Spring Boot-Projekt mit den notwendigen Abhängigkeiten ein.

Schritt 3: Erstellen eines REST-Controllers

Erstellen Sie eine neue Datei namens HelloController.java im Verzeichnis src/main/java/com/example mit folgendem Inhalt:

Java

import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;

@RestController
@RequestMapping("/api")
public class HelloController {

    private final List<String> messages = new ArrayList<>();

    @GetMapping("/hello")
    public String sayHello() {
        return "Hello, Spring Boot!";
    }

    @GetMapping("/messages")
    public List<String> getMessages() {
        return messages;
    }

    @PostMapping("/messages")
    public String addMessage(@RequestBody String message) {
        messages.add(message);
        return "Message added: " + message;
    }

    @PutMapping("/messages/{index}")
    public String updateMessage(@PathVariable int index, @RequestBody String updatedMessage) {
        if (index < messages.size()) {
            messages.set(index, updatedMessage);
            return "Message updated at index " + index + ": " + updatedMessage;
        } else {
            return "Invalid index";
        }
    }

    @DeleteMapping("/messages/{index}")
    public String deleteMessage(@PathVariable int index) {
        if (index < messages.size()) {
            String removedMessage = messages.remove(index);
            return "Message removed at index " + index + ": " + removedMessage;
        } else {
            return "Invalid index";
        }
    }
}

Dies definiert einen REST-Controller mit Endpunkten für GET, POST, PUT und DELETE-Operationen auf einer einfachen Nachrichtenliste.

Schritt 4: Starten der Anwendung

Öffnen Sie ein Terminal oder eine Eingabeaufforderung und führen Sie den folgenden Befehl aus:

Java

./gradlew bootRun

Besuchen Sie http://localhost:8080/api/hello in Ihrem Browser, um den Anfangsendpunkt zu überprüfen. Sie können Tools wie curl, Postman oder einen beliebigen REST-Client verwenden, um die anderen Endpunkte zu testen.

Schritt 5: Testfälle schreiben

Erstelle eine neue Datei mit dem Namen HelloControllerTest.java im Verzeichnis src/test/java/com/example mit folgendem Inhalt:

Java

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;

import static org.hamcrest.Matchers.hasSize;
import static org.hamcrest.Matchers.is;

@SpringBootTest
@AutoConfigureMockMvc
public class HelloControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @BeforeEach
    public void setUp() {
        // Nachrichten vor jedem Test löschen
        // Dies stellt sicher, dass jeder Test in einem sauberen Zustand beginnt
        // Alternativ könnten Sie eine Testdatenbank oder Mock-Daten verwenden
        // abhängig von Ihren Anforderungen
        HelloController messagesController = new HelloController();
        messagesController.getMessages().clear();
    }

    @Test
    public void testSayHello() throws Exception {
        mockMvc.perform(MockMvcRequestBuilders.get("/api/hello"))
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andExpect(MockMvcResultMatchers.content().string("Hello, Spring Boot!"));
    }

    @Test
    public void testGetMessages() throws Exception {
        mockMvc.perform(MockMvcRequestBuilders.get("/api/messages"))
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andExpect(MockMvcResultMatchers.jsonPath("$", hasSize(0)));
    }

    @Test
    public void testAddMessage() throws Exception {
        mockMvc.perform(MockMvcRequestBuilders.post("/api/messages")
                .contentType(MediaType.APPLICATION_JSON)
                .content("\"Test Message\""))
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andExpect(MockMvcResultMatchers.content().string("Message added: Test Message"));
    }

    @Test
    public void testUpdateMessage() throws Exception {
        mockMvc.perform(MockMvcRequestBuilders.post("/api/messages")
                .contentType(MediaType.APPLICATION_JSON)
                .content("\"Initial Message\""));

        mockMvc.perform(MockMvcRequestBuilders.put("/api/messages/0")
                .contentType(MediaType.APPLICATION_JSON)
                .content("\"Updated Message\""))
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andExpect(MockMvcResultMatchers.content().string("Message updated at index 0: Updated Message"));
    }

    @Test
    public void testDeleteMessage() throws Exception {
        mockMvc.perform(MockMvcRequestBuilders.post("/api/messages")
                .contentType(MediaType.APPLICATION_JSON)
                .content("\"Message to Delete\""));

        mockMvc.perform(MockMvcRequestBuilders.delete("/api/messages/0"))
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andExpect(MockMvcResultMatchers.content().string("Message removed at index 0: Message to Delete"));
    }
}

Diese Testfälle verwenden die Testfeatures von Spring Boot, um HTTP-Anfragen zu simulieren und das Verhalten des REST-Controllers zu überprüfen.

Schritt 6: Tests ausführen

Öffnen Sie ein Terminal oder eine Eingabeaufforderung und führen Sie den folgenden Befehl aus, um die Tests auszuführen:

Java

./gradlew test

Überprüfen Sie die Testresultate, um sicherzustellen, dass alle Tests erfolgreich bestanden wurden.

Schlussfolgerung

Herzlichen Glückwunsch! Sie haben erfolgreich einen einfachen RESTful Webdienst mit CRUD-Operationen unter Verwendung von Spring Boot und Gradle erstellt. Dieses Tutorial behandelte die Implementierung von Endpunkten für GET, POST, PUT und DELETE-Operationen zusammen mit den entsprechenden Testfällen.

Zusätzliche Hinweise:

Dies ist ein sehr einfaches Beispiel. Sie können darauf aufbauen, indem Sie weitere Endpunkte erstellen, verschiedene HTTP-Methoden (POST, PUT, DELETE) behandeln und Funktionen wie Datenmanagement hinzufügen.
Erwägen Sie, Unit-Tests für Ihren Controller mit Frameworks wie JUnit hinzuzufügen.
Sie können den Spring Initializr (https://start.spring.io/) verwenden, um schnell ein Projekt mit zusätzlichen Abhängigkeiten und Konfigurationen zu erstellen.

Für weitere Lernen finden Sie diese Ressourcen:

Spring Boot Getting Started Guide: https://spring.io/guides/gs/spring-boot/
Spring REST Services Tutorial: https://spring.io/guides/gs/rest-service/
Building a RESTful Web Service with Spring Boot Actuator: https://spring.io/guides/gs/actuator-service/

Denken Sie daran, dies ist nur der Anfang Ihrer Spring Boot-Reise! Erkunden Sie weiter und bauen Sie erstaunliche Anwendungen.

Source:
https://dzone.com/articles/build-your-first-spring-boot-rest-application-with