Erste Schritte mit Boot Spring 3.2.0: Erstellen einer Hello World REST-API mit NoSQL-Integration

Starten Sie eine Reise in die neuesten Fortschritte der Spring Boot-Entwicklung mit Version 3.2.0, während wir Ihnen helfen, eine grundlegende „Hello World“-Anwendung zu erstellen. In diesem Tutorial geht es nicht nur um die übliche Einführung in Spring, sondern wir tauchen auch in die Feinheiten der Erstellung einer REST-API ein, während wir sie nahtlos mit einer NoSQL-Datenbank integrieren. Spring Boot 3.2.0, mit seinem Arsenal an neuen Funktionen und Optimierungen, bietet die Bühne für eine fesselnde Erkundung zeitgemäßer Entwicklungspraktiken. Dieser Leitfaden richtet sich an sowohl Anfänger als auch erfahrene Entwickler und verspricht praktische Erfahrungen beim Erschließen des Potenzials von Spring für robuste, moderne Anwendungen. Beginnen wir diese Reise in Spring 3.2.0, wo Einfachheit auf Innovation trifft.

Was ist Neues in Spring Boot 3.2.0

Spring Boot 3.2.0 stellt einen bedeutenden Sprung nach vorne in der Java-Entwicklung dar, erfordert eine minimale Java 17-Umgebung und erweitert die Unterstützung für die bahnbrechende Java 21. Diese Version führt viele Funktionen ein, die die Landschaft der Nutzung des Spring-Frameworks neu definieren.

Eine der beeindruckenden Funktionen von Java ist die Unterstützung für virtuelle Threads, die Skalierbarkeit und Reaktionsfähigkeit durch die Nutzung von leichtgewichtigen Threads erhöhen. Darüber hinaus führt Spring Boot 3.2.0 eine erste Unterstützung für das Projekt CRaC (JVM Checkpoint Restore) ein, das es Anwendungen ermöglicht, ihren Zustand nach einem Neustart der JVM wiederherzustellen, was die Zuverlässigkeit und Resilienz erhöht.

Sicherheit steht im Mittelpunkt mit SSL Bundle Reloading, das dynamisches Neuladen von SSL Bundles ermöglicht. Diese Funktion ermöglicht Entwicklern eine dynamischere Verwaltung von SSL-Zertifikaten, was sowohl Agilität als auch Sicherheit in ihren Anwendungen gewährleistet.

Verbesserungen bei der Beobachtbarkeit sind in der gesamten Veröffentlichung verwoben, was Entwicklern erweiterte Überwachungs- und Ablaufverfolgungsfähigkeiten für eine transparenter und kontrollierbare Entwicklungserfahrung bietet.

Im Einklang mit modernen Entwicklungspraktiken führt Spring Boot 3.2.0 spezialisierte Clients für RESTful (RestClient) und JDBC (JdbcClient) Operationen ein. Diese Zusätze vereinfachen die Kommunikation mit externen Diensten und erhöhen die Integrationsfähigkeiten.

Die Kompatibilität mit Jetty 12 ist eine weitere bemerkenswerte Inklusion, die Entwicklern ermöglicht, die neuesten Funktionen des Jetty-Webservers zu nutzen. Spring Boot 3.2.0 erweitert seine Ecosystem-Kompatibilität mit Unterstützung für Apache Pulsar, was die Messaging-Fähigkeiten von Spring erweitert und die Entwicklung robuster, ereignisgesteuerter Anwendungen ermöglicht.

Die Anerkennung der Verbreitung von Kafka und RabbitMQ führt Spring Boot 3.2.0 ein, indem es SSL-Bundle-Unterstützung für diese beliebten Nachrichtensysteme einführt und die Sicherheitslage von Anwendungen, die auf diesen Message-Brokern beruhen, stärkt.

Die Veröffentlichung behebt auch Abhängigkeitsmanagement-Komplexitäten mit einem überarbeiteten Ansatz zur Behandlung von geschachtelten JARs, was zu einer zuverlässigeren und vorhersehbaren Anwendungsbereitstellung führt. Schließlich werden Docker Image Building-Verbesserungen vorgenommen, um den Containerisierungsprozess zu optimieren und die Portabilität und Bereitstellungseffizienz von Spring-Anwendungen zu verbessern.

Zusammenfassend passt sich Spring Boot 3.2.0 den neuesten Java-Versionen an, führt bahnbrechende Funktionen ein und verfeinert bestehende Fähigkeiten. Diese Veröffentlichung ermöglicht Entwicklern, selbstbewusst moderne, robuste und hochleistungsfähige Anwendungen in der sich ständig weiterentwickelnden Landschaft der Java-Entwicklung zu erstellen.

Zeig mir den Code

In dieser Sitzung starten wir ein spannendes Abenteuer, um eine Pokémon-API mit dem Schwerpunkt auf den grundlegenden CRUD-Operationen (Erstellen, Lesen, Aktualisieren, Löschen) zu entwickeln, wobei besonderer Wert auf die Verwendung eindeutiger Kennungen (IDs) für jedes Pokémon gelegt wird. Am Ende dieser Sitzung haben Sie nicht nur eine voll funktionsfähige Spring-Anwendung, sondern auch eine Pokémon-API zur Verfügung, die bereit ist, in größere Projekte erweitert und integriert zu werden. Tauchen wir in die Welt von Pokémon und Spring-Entwicklung ein, wo Einfachheit auf Innovation trifft.

Stellen Sie sicher, dass Ihre NoSQL-Datenbank, HarperDB, mithilfe von Docker betriebsbereit ist. Öffnen Sie Ihr Terminal und führen Sie den folgenden Befehl aus:

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

Dieser Befehl zieht das HarperDB Docker-Image und startet einen Container mit der angegebenen Konfiguration. Die Option -p leitet die Ports des Containers auf Ihren lokalen Computer weiter, wodurch die HarperDB-Schnittstelle unter http://localhost:9925 zugänglich ist.

Gehen Sie zum Spring Initializer, um unsere Spring-Anwendung einzurichten. Folgen Sie diesen Schritten:

1. Wählen Sie die gewünschten Projekteinstellungen (z.B. Maven oder Gradle, Java-Version).
2. Fügen Sie Abhängigkeiten hinzu: Wählen Sie „Spring Web“ aus der Abhängigkeitenliste.
3. Klicken Sie auf „Generieren“, um das Projekt als ZIP-Datei herunterzuladen.

Extrahieren Sie die heruntergeladene ZIP-Datei und importieren Sie das Projekt in Ihre bevorzugte integrierte Entwicklungsumgebung (IDE), wie z.B. IntelliJ IDEA oder Eclipse.

Nun, da unsere Spring-Anwendung eingerichtet ist, ist der nächste entscheidende Schritt die Integration mit HarperDB. Um dies zu erreichen, müssen wir die HarperDB-Abhängigkeit in unserem Projekt einbinden. Fügen Sie die folgende Maven-Abhängigkeit zu Ihrer pom.xml-Datei hinzu:

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

Mit der Abhängigkeit an Bord, gehen wir nun zum Code. Wir werden eine Konfigurationsklasse in Spring erstellen, HarperDB, um die Verbindung zu verwalten und sie zu einem integralen Bestandteil des Spring Inversion of Control (IoC)-Containers zu machen:

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

Diese Konfigurationsklasse, mit dem Annotation @Configuration versehen, erstellt einen Spring-Bean namens template. Das Template-Objekt ist ein zentrales Element für die Interaktion mit HarperDB. Wir initialisieren es mit den Servernetzverbindungsdetails, einschließlich der Serverseite-URL und der Anmeldeinformationen. Darüber hinaus erstellen wir eine Datenbank namens “pokemons” und eine Tabelle namens “pokemon” mit einer “id”-Spalte. Es bereitet den Boden für die Speicherung unserer Pokemon-Entitäten in HarperDB.

Um die Demo zu verbessern, erstellen wir zunächst eine unveränderliche Entität unter Verwendung von Javas record-Feature:

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

Diese einfache Pokemon-Record-Klasse kapselt die grundlegenden Attribute eines Pokemon – seine ID, Name und Position – auf eine unveränderliche Weise.

Als nächstes etablieren wir die Kommunikation mit der Datenbank, indem wir die PokemonService erstellen, um als Brücke zu HarperDB zu dienen:

@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);
    }
}

Die PokemonService-Klasse ist ein Spring-Service, der grundlegende Operationen im Zusammenhang mit Pokemon-Entitäten behandelt. Sie nutzt das zuvor konfigurierte Template-Objekt, um mit HarperDB zu interagieren. Die findById-Methode ruft ein Pokemon anhand seiner ID ab, speichert es, fügt es hinzu oder aktualisiert es, und löscht es und entfernt es aus der Datenbank.

Zum Schluss erstellen wir den PokemonController, um diese Operationen als REST-Endpunkte zu exponieren:

@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);
    }
}

Diese PokemonController-Klasse ist mit @RestController annotiert und definiert drei Endpunkte:

• GET /pokemons/{id} ruft ein Pokemon anhand seiner ID ab.
• PUT /pokemons erstellt ein neues Pokemon oder aktualisiert ein bestehendes.
• DELETE /pokemons/{id} löscht ein Pokemon anhand seiner ID.

Der Controller setzt auf der PokemonService zur Handhabung dieser Operationen, was eine klare Trennung der Verantwortlichkeiten in unserer Spring-Anwendung ermöglicht.

Mit diesen Komponenten an Bord kann unsere Pokemon-API grundlegende CRUD-Operationen mithilfe von HarperDB ausführen. Zögern Sie nicht, die Endpunkte zu testen und die reibungslose Integration von Spring mit der NoSQL-Datenbank in Aktion zu sehen!

Ihre Spring-Anwendung, integriert mit HarperDB und mit einer Pokemon-API ausgestattet, ist nun bereit für Tests und Ausführung. Lassen Sie uns einige häufige Szenarien mit curl-Befehlen erkunden. Bevor Sie fortfahren, stellen Sie sicher, dass Ihre Spring-Anwendung läuft.

Einen Pokemon erstellen

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

Dieser Befehl erstellt einen neuen Pokemon mit der ID 1, dem Namen Pikachu und der Location Wald.

Einen Pokemon anhand der ID abrufen

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

Ersetzen Sie {id} durch die tatsächliche ID des soeben erstellten Pokemon.

Einen Pokemon aktualisieren

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

Dieser Befehl aktualisiert den vorhandenen Pokemon mit der ID 1, um den Namen Raichu und die Location Gewitter zu haben.

Einen Pokemon anhand der ID löschen

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

Ersetzen Sie {id} durch die tatsächliche ID des zu löschenden Pokemon.

Diese Szenarien bieten eine umfassende Überprüfung der grundlegenden CRUD-Operationen in Ihrer Pokemon-API, beginnend mit der Erstellung eines Pokemon. Passen Sie die Befehle entsprechend Ihrem spezifischen Anwendungsfall und den Daten an. Viel Spaß beim Testen!

Schlussfolgerung

In diesem Tutorial haben wir die Fähigkeiten von Spring Boot 3.2.0 genutzt, um eine optimierte Pokémon API zu entwickeln, die nahtlos mit HarperDB integriert ist. Die neueste Spring-Version hat wichtige Funktionen eingeführt, die unsere Fähigkeit erhöhen, robuste und skalierbare Anwendungen zu erstellen.

Durch die Verwendung von unveränderlichen Entitäten, Spring IoC und HarperDB haben wir die Einfachheit der modernen Java-Entwicklung demonstriert. Der Demo-Code, verfügbar hier, bildet eine Grundlage für deine Projekte und ist bereit für die Anpassung.

Für Updates und tiefgründige Einblicke siehe den offiziellen Spring-Blog. Möge deine Reise mit Spring Boot und HarperDB voller Innovation und Programmierfreude sein! Viel Spaß beim Programmieren!