Aan de slag met Boot Spring 3.2.0: Het bouwen van een Hello World REST API met NoSQL-integratie

Ga op reis naar de nieuwste ontwikkelingen in Spring Boot met versie 3.2.0 terwijl we je begeleiden bij het maken van een fundamenteel “Hello World” toepassingsvoorbeeld. In deze tutorial gaan we verder dan de gebruikelijke introductie tot Spring; we duiken in de complexiteiten van het bouwen van een REST API terwijl we deze soepel integreren met een NoSQL-database. Spring Boot 3.2.0, met zijn reeks nieuwe functies en optimalisaties, stelt het toneel voor een boeiende verkenning van hedendaagse ontwikkelingsmethoden. Deze gids is afgestemd op zowel beginners als ervaren ontwikkelaars, met de belofte van een hand-on ervaring in het benutten van het potentieel van Spring voor robuuste, moderne toepassingen. Laten we beginnen aan deze reis in Spring 3.2.0, waar eenvoud samenkomt met innovatie.

Wat is er Nieuw in Spring Boot 3.2.0

Spring Boot 3.2.0 markeert een belangrijke sprong voorwaarts in Java ontwikkeling, met een minimale Java 17-omgeving vereist en uitbreiding van ondersteuning naar de meest recente Java 21. Deze versie introduceert veel functies die het landschap van Spring frameworkgebruik herdefiniëren.

Een van de indrukwekkende functies van Java is de ondersteuning voor virtuele threads, die schaalbaarheid en reactiviteit verhogen door het gebruik van lichtgewicht threads. Bovendien introduceert Spring Boot 3.2.0 aanvankelijke ondersteuning voor Project CRaC (JVM Checkpoint Restore), waardoor toepassingen hun staat kunnen herstellen na een JVM-relaunch, waardoor betrouwbaarheid en veerkracht worden verbeterd.

Beveiliging staat centraal met SSL Bundle Reloading, waardoor dynamische herladen van SSL-bundels mogelijk is. Deze functie stelt ontwikkelaars in staat om SSL-certificaten meer dynamisch te beheren, waardoor zowel wendbaarheid als beveiliging in hun toepassingen worden gewaarborgd.

Doorzichtigheidsverbeteringen zijn doorheen de release verweven, waardoor ontwikkelaars verbeterde controle- en traceerbaarheidsmogelijkheden krijgen voor een transparantere en beheerbare ontwikkelingservaring.

In lijn met moderne ontwikkelpraktijken introduceert Spring Boot 3.2.0 toegewijde clients voor RESTful (RestClient) en JDBC (JdbcClient) operaties. Deze aanvullingen vereenvoudigen de communicatie met externe diensten, waardoor integratiemogelijkheden worden verbeterd.

Compatibiliteit met Jetty 12 is nog een opmerkelijke toevoeging, waardoor ontwikkelaars de nieuwste functies van de Jetty webserver kunnen benutten. Spring Boot 3.2.0 breidt zijn ecosysteemcompatibiliteit uit met ondersteuning voor Apache Pulsar, waardoor de berichtendiensten van Spring worden uitgebreid voor het bouwen van robuuste, event-driven toepassingen.

Aanvaardend de wijdverbreide aanwezigheid van Kafka en RabbitMQ, introduceert Spring Boot 3.2.0 ondersteuning voor SSL-bundels voor deze populaire berichtensystemen, waardoor de beveiligingsstatus van toepassingen die op deze berichtenbrokers vertrouwen, wordt versterkt.

De release behandelt ook complexiteiten in afhankelijkheidsbeheer met een herwerkte aanpak voor het hanteren van geneste JAR-bestanden, waardoor betrouwbaarder en voorspelbaarder toepassingsimplementaties worden gegarandeerd. Tot slot zien Docker Image Building verbeteringen, wat het containerisatieproces stroomlijnt en de draagbaarheid en implementatie-efficiëntie van Spring-toepassingen versterkt.

Concluderend, stemt Spring Boot 3.2.0 af met de nieuwste Java-versies, introduceert baanbrekende functies en verfijnt bestaande mogelijkheden. Deze release stelt ontwikkelaars in staat om zelfverzekerd moderne, robuuste en zeer prestatiegerichte toepassingen te bouwen in het voortdurend veranderende landschap van Java-ontwikkeling.

Show Me the Code

In deze sessie gaan we op een spannende reis om een Pokemon API te ontwikkelen, waarbij we de kracht van Spring gebruiken en dit naadloos integreren met HarperDB. Ons focus zal liggen op het implementeren van fundamentele CRUD (Create, Read, Update, Delete) operaties, met een speciale nadruk op het gebruik van unieke identificaties (IDs) voor elke Pokemon. Aan het einde van deze sessie zult u niet alleen over een volledig functionele Spring-toepassing beschikken, maar ook over een Pokemon API die klaar is om uit te breiden en te integreren in grotere projecten. Laten we de wereld van Pokemon en Spring-ontwikkeling in duiken, waar eenvoud samenkomt met innovatie.

Zorg ervoor dat uw NoSQL-database, HarperDB, draait met behulp van Docker. Open uw terminal en voer de volgende opdracht uit:

docker run -d -e HDB_ADMIN_USERNAME=root -e HDB_ADMIN_PASSWORD=password -e HTTP_THREADS=4 -p 9925:9925 -p 9926:9926 harperdb/harperdb

Deze opdracht haalt de HarperDB Docker-afbeelding op en start een container met de opgegeven configuratie. De -p optie wijst de poorten van de container toe aan uw lokale machine, waardoor de HarperDB-interface toegankelijk is op http://localhost:9925.

Ga naar de Spring Initializer om onze Spring-toepassing op te zetten. Volg deze stappen:

1. Kies de gewenste projectinstellingen (bijv. Maven of Gradle, Java-versie).
2. Voeg afhankelijkheden toe: kies ” Spring Web ” uit de lijst met afhankelijkheden.
3. Klik op ” Genereren ” om het project als een ZIP-bestand te downloaden.

Pak het gedownloade ZIP-bestand uit en importeer het project in uw gewenste Integrated Development Environment (IDE), zoals IntelliJ IDEA of Eclipse.

Nu onze Spring-toepassing is ingesteld, is de volgende cruciale stap om deze te integreren met HarperDB. Om dit te bereiken, moeten we de HarperDB-afhankelijkheid in ons project opnemen. Voeg de volgende Maven-afhankelijkheid toe aan uw pom.xml bestand:

<dependency>
    <groupId>io.harperdb</groupId>
    <artifactId>harpderdb-core</artifactId>
    <version>0.0.1</version>
</dependency>

Met de afhankelijkheid op zijn plaats, laten we verder gaan met de code. We maken een configuratieklasse in Spring, HarperDB, om de verbinding te beheren en het een integraal onderdeel te maken van de Spring Inversion of Control (IoC) container:

@Configuration
public class HarperDB {

    @Bean
    public Template template() {
        Server server = ServerBuilder.of("http://localhost:9925")
                .withCredentials("root", "password");
        server.createDatabase("pokemons");
        server.createTable("pokemon").id("id").database("pokemons");
        return server.template("pokemons");
    }
}

Deze configuratieklasse, gemarkeerd met @Configuration, creëert een Spring-bean met de naam template. Het Template object is een belangrijk onderdeel voor interactie met HarperDB. We initialiseren het met de serververbindinggegevens, inclusief de server-URL en inloggegevens. Bovendien creëren we een database met de naam “pokemons” en een tabel met de naam “pokemon” met een “id” kolom. Het stelt de toon voor het opslaan van onze Pokemon-entiteiten in HarperDB.

Om de demo te verbeteren, zullen we eerst een onveranderlijke entiteit maken met behulp van Java’s record functie:

public record Pokemon(String id, String name, String location) {
}

Deze eenvoudige Pokemon recordklasse omsluit de basisattributen van een Pokemon—zijn ID, naam en locatie—op een onveranderlijke manier.

Vervolgens zullen we communicatie met de database opzetten door de PokemonService te creëren om als een brug te dienen naar HarperDB:

@Service
public class PokemonService {

    private final Template template;

    public PokemonService(Template template) {
        this.template = template;
    }

    public Optional<Pokemon> findById(String id) {
        return template.findById(Pokemon.class, id);
    }

    public void save(Pokemon pokemon) {
        template.upsert(pokemon);
    }

    public void delete(String id) {
        template.delete(Pokemon.class, id);
    }
}

De PokemonService klasse is een Spring-service die de basisoperaties behandelt die verband houden met Pokemon-entiteiten. Het gebruikt het Template-object dat we eerder hebben geconfigureerd om te communiceren met HarperDB. De findById methode haalt een Pokemon op op basis van zijn ID, slaat een nieuw Pokemon op of werkt een bestaand bij en verwijdert het uit de database.

Tot slot, laten we de PokemonController creëren om deze operaties beschikbaar te stellen als REST-eindpunten:

@RestController
public class PokemonController {

    private final PokemonService service;

    public PokemonController(PokemonService service) {
        this.service = service;
    }

    @GetMapping("/pokemons/{id}")
    Pokemon findById(@PathVariable String id) {
        return service.findById(id).orElseThrow(() -> new PokemonNotFoundException(id));
    }

    @PutMapping("/pokemons")
    Pokemon newPokemon(@RequestBody Pokemon pokemon) {
        service.save(pokemon);
        return pokemon;
    }

    @DeleteMapping("/pokemons/{id}")
    void deleteEmployee(@PathVariable String id) {
        service.delete(id);
    }
}

Deze PokemonController klasse is gemarkeerd met @RestController en definieert drie eindpunten:

• GET /pokemons/{id} haalt een Pokemon op op basis van zijn ID.
• PUT /pokemons creëert een nieuw Pokemon of werkt een bestaand bij.
• DELETE /pokemons/{id} verwijdert een Pokemon op basis van zijn ID.

De controller vertrouwt op de PokemonService om deze operaties te verwerken, waardoor er een nette scheiding van zorgen is in onze Spring-toepassing.

Met deze componenten op hun plaats, kan onze Pokemon-API basis CRUD-operaties uitvoeren met HarperDB. Voel je vrij om de eindpunten uit te proberen en te zien hoe Spring soepel geïntegreerd is met de NoSQL-database in actie!

Uw Spring-toepassing, geïntegreerd met HarperDB en uitgerust met een Pokemon-API, is nu klaar voor testen en uitvoering. Laten we enkele veelvoorkomende scenario’s bekijken met curl-opdrachten. Voordat u verdergaat, zorg ervoor dat uw Spring-toepassing draait.

Een Pokemon aanmaken

   curl -X PUT -H "Content-Type: application/json" -d '{"id": "1", "name": "Pikachu", "location": "Forest"}' http://localhost:8080/pokemons

Deze opdracht maakt een nieuwe Pokemon met ID 1, de naam Pikachu en de locatie Forest.

Een Pokemon opzoeken op ID

curl http://localhost:8080/pokemons/{id}

Vervang {id} door de werkelijke ID van de zojuist gemaakte Pokemon.

Een Pokemon bijwerken

   curl -X PUT -H "Content-Type: application/json" -d '{"id": "1", "name": "Raichu", "location": "Thunderstorm"}' http://localhost:8080/pokemons

Deze opdracht werkt de bestaande Pokemon met ID 1 bij en geeft de naam Raichu en locatie Thunderstorm.

Een Pokemon verwijderen op ID

curl -X DELETE http://localhost:8080/pokemons/{id}

Vervang {id} door de werkelijke ID van de Pokemon die u wilt verwijderen.

Deze scenario’s bieden een uitgebreide test van de basis CRUD-operaties in uw Pokemon-API, beginnend met het aanmaken van een Pokemon. Pas de opdrachten aan zoals nodig op basis van uw specifieke gebruiksvoorbeeld en gegevens. Veel plezier met testen!

Conclusie

In deze tutorial hebben we de mogelijkheden van Spring Boot 3.2.0 gebruikt om een gestroomlijnde Pokémon API te maken die naadloos is geïntegreerd met HarperDB. De nieuwste Spring-versie heeft belangrijke functies geïntroduceerd, waardoor we in staat zijn om veerkrachtige en schaalbare toepassingen te creëren.

Met behulp van onveranderlijke entiteiten, Spring IoC en HarperDB hebben we laten zien hoe eenvoudig moderne Java-ontwikkeling is. De demo-code, beschikbaar hier, is een basis voor uw projecten, klaar voor aanpassing.

Voor updates en gedetailleerde inzichten verwijzen we naar de officiële Spring-blog. Moge uw Spring Boot en HarperDB-reis gevuld zijn met innovatie en coderingstevredenheid! Geluk met coderen!