Bouw een Spring Boot REST-toepassing met Gradle

Gradle

In deze tutorial gaan we een eenvoudige RESTful webservice maken met behulp van Spring Boot en Gradle. Spring Boot maakt het gemakkelijk om zelfstandige, productierijpe Spring-gebaseerde applicaties te creëren, en Gradle is een krachtig bouwgereedschap dat het bouwproces vereenvoudigt.

Wat is REST?

REST, Representational State Transfer, is een set architectonische principes die zorgen dat uw API’s interoperabel, schaalbaar en onderhoudbaar zijn. Stel je voor dat je Lego blokken bouwt – verschillende applicaties kunnen soepele interactie aan met uw API zolang ze de RESTful richtlijnen volgen, net als Legos die samenklikken ongeacht hun set.

Wat is Spring Boot?

Spring Boot is een krachtige framework dat het ontwikkelingsproces vereenvoudigt. Denk eraan als een voorgebouwde toolkit gevuld met componenten en functies, wat u tijd en moeite bespaart bij het opzetten van uw applicatie-infrastructuur. U kunt zich concentreren op het creëren van de kernlogica van uw API zonder in herhaling belanden.

Klaar om uw innerlijke API-ontwikkelaar te ontsluiten? Deze gids zal u in staat stellen om uw eerste Spring Boot REST-applicatie te creëren met behulp van Gradle, een populaire bouwtool. Of u nu een ervaren Java-programmeur bent of net aan het verkennen begint, deze stap-voor-stap reis zal u met de essentiële kennis uitrusten om dynamische en interactieve webservices te bouwen.

Belangrijkste afhaak

Maak RESTful APIs aan met Spring Boot: Spring Boot is een populaire Java-framework dat het ontwikkelingsproces van RESTful APIs vereenvoudigt. Het biedt een breed scala aan functies uit de doos, zoals automatische configuratie en afhankelijkheidsinjectie, die u tijd en moeite kunnen besparen.
Begrijp de kernconcepten van RESTful APIs: REST staat voor Representational State Transfer. Het is een reeks architectonische principes die ervoor zorgen dat uw APIs interoperabel, schaalbaar en onderhoudbaar zijn. Enkele van de belangrijkste concepten van RESTful APIs omvatten bronrepresentatie, HTTP-methoden en statuscodes.
Implementeer basis CRUD-bewerkingen: CRUD staat voor Create, Read, Update en Delete. Dit zijn de basisbewerkingen die u in uw API-eindpunten zult moeten implementeren om gebruikers in staat te stellen met uw gegevens te interageren.
Test uw API grondig: Het is belangrijk om uw API grondig te testen voordat u deze implementeert in productie. Dit zal u helpen ervoor te zorgen dat deze zoals verwacht werkt en dat er geen fouten zijn.
Verken geavanceerde functionaliteiten: Naarmate u bekender raakt met Spring Boot en RESTful APIs, kunt u geavanceerdere functionaliteiten verkennen, zoals gegevensbeheer, beveiliging en authenticatie.

Door de kracht van REST te combineren met de gestroomlijnde aanpak van Spring Boot, kunt u efficiënte en gebruiksvriendelijke APIs ontwikkelen die soepel kunnen integreren met andere applicaties. Dus, bent u klaar om het potentieel van RESTful APIs te ontgrendelen met Spring Boot en Gradle? Laten we beginnen!

Vereisten

Java Development Kit (JDK) 11 geïnstalleerd
Laatste versie van Gradle geïnstalleerd
Basisbegrip van Java en Spring concepten

Stap 1: Project instellen

Om met het project te beginnen, moeten we de onderstaande 3 stappen initiëren.

Open een terminal of opdrachtprompt
Maak een nieuw directory aan voor je project
Navigeer naar de projectdirectory
Initieer een basis Spring Boot projectstructuur

Shell

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

Stap 2: Maak een Spring Boot Project

Pas het bestaande build.gradle bestand aan dat aanwezig is in de directory met de onderstaande inhoud.

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()
}

Dit stelt een basis Spring Boot project in met de noodzakelijke afhankelijkheden.

Stap 3: Maak een REST Controller

Maak een nieuw bestand met de naam HelloController.java in de src/main/java/com/example directory met de volgende inhoud:

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

Dit definieert een REST controller met endpoints voor GET, POST, PUT, en DELETE operaties op een eenvoudige lijst met berichten.

Stap 4: Voer de applicatie uit

Open een terminal of opdrachtprompt en voer de volgende opdracht uit:

Java

./gradlew bootRun

Bezoek http://localhost:8080/api/hello in je browser om de initiële endpoint te controleren. Je kunt tools zoals curl, Postman of een REST client gebruiken om de andere endpoints te testen.

Stap 5: Schrijf testgevallen

Maak een nieuw bestand met de naam HelloControllerTest.java in de src/test/java/com/example directory met de volgende inhoud:

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() {
        // Wis berichten voor elke test
        // Dit zorgt voor een schone staat voor elke test
        // Alternatief, je zou een testdatabase of gesimuleerde gegevens kunnen gebruiken
        // afhankelijk van je eisen
        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"));
    }
}

Deze testgevallen maken gebruik van Spring Boot’s testmogelijkheden om HTTP-verzoeken te simuleren en het gedrag van de REST controller te verifiëren.

Stap 6: Tests uitvoeren

Open een terminal of command prompt en voer de volgende opdracht uit om de tests uit te voeren:

Java

./gradlew test

Bekijk de testresultaten om ervoor te zorgen dat alle tests succesvol zijn doorgegaan.

Conclusie

Gefeliciteerd! Je hebt met succes een basis RESTful webservice met CRUD-operaties gemaakt met behulp van Spring Boot en Gradle. Deze tutorial behandelde de implementatie van eindpunten voor GET, POST, PUT en DELETE operaties samen met de corresponderende testgevallen.

Extra opmerkingen:

Dit is een zeer basisvoorbeeld. Je kunt erop voortbouwen door meer eindpunten te creëren, verschillende HTTP-methoden (POST, PUT, DELETE) af te handelen en functionaliteit toe te voegen zoals gegevensbeheer.
Overweeg unit tests voor je controller toe te voegen met behulp van frameworks zoals JUnit.
U kunt de Spring Initializr (https://start.spring.io/) gebruiken om snel een project te genereren met extra afhankelijkheden en configuraties.

Voor verdere studie, bekijk deze bronnen:

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/

Vergeet niet, dit is slechts het begin van je Spring Boot reis! Blijf verkennen en ontwikkel geweldige applicaties.

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