Bien démarrer avec Boot Spring 3.2.0 : Création d’une API REST Hello World avec intégration NoSQL

Partir à la découverte des dernières avancées en matière de développement avec Spring Boot version 3.2.0 en nous guidant pour créer une application de base « Hello World ». Dans ce tutoriel, notre attention dépasse l’introduction habituelle à Spring ; nous plongeons dans les détails de la construction d’une API REST tout en l’intégrant en douceur avec une base de données NoSQL. Spring Boot 3.2.0, avec sa gamme de nouvelles fonctionnalités et optimisations, pose les bases pour une exploration captivante des pratiques de développement contemporaines. Ce guide s’adresse autant aux débutants qu’aux développeurs chevronnés, promettant une expérience pratique dans l’exploitation du potentiel de Spring pour des applications robustes et modernes. Commençons ce voyage dans Spring 3.2.0, où la simplicité rencontre l’innovation.

Quoi de neuf dans Spring Boot 3.2.0

Spring Boot 3.2.0 marque un bond important dans le développement Java, exigeant un environnement Java 17 minimum et étendant le support au Java 21 de pointe. Cette version introduit de nombreuses fonctionnalités qui redéfinissent le paysage de l’utilisation du framework Spring.

L’une des caractéristiques impressionnantes de Java est le soutien aux threads virtuels, qui augmentent la scalabilité et la réactivité en utilisant des threads légers. De plus, Spring Boot 3.2.0 introduit un soutien initial pour le projet CRaC (JVM Checkpoint Restore), qui permet aux applications de récupérer leur état après un redémarrage de la JVM, améliorant ainsi la fiabilité et la résilience.

La sécurité prend le devant avec le rechargement dynamique des bundles SSL, permettant le rechargement dynamique des bundles SSL. Cette fonctionnalité permet aux développeurs de gérer les certificats SSL de manière plus dynamique, garantissant à la fois l’agilité et la sécurité dans leurs applications.

Les améliorations de l’observabilité sont intégrées dans la version, offrant aux développeurs des capacités de surveillance et de traçage améliorées pour une expérience de développement plus transparente et gérable.

Conformément aux pratiques de développement modernes, Spring Boot 3.2.0 introduit des clients dédiés pour les opérations RESTful (RestClient) et JDBC (JdbcClient). Ces ajouts simplifient la communication avec les services externes, améliorant les capacités d’intégration.

La compatibilité avec Jetty 12 est un autre ajout remarquable, permettant aux développeurs d’exploiter les dernières fonctionnalités du serveur web Jetty. Spring Boot 3.2.0 élargit sa compatibilité avec l’écosystème avec le soutien pour Apache Pulsar, élargissant les capacités de messagerie de Spring pour la construction d’applications robustes et basées sur des événements.

Acquis du caractère répandu de Kafka et RabbitMQ, Spring Boot 3.2.0 introduit le support de l’ensemble SSL pour ces systèmes de messagerie populaires, renforçant ainsi la posture de sécurité des applications qui reposent sur ces brokers de messages.

La version aborde également les complexités de gestion des dépendances avec une approche révisée pour gérer les JAR imbriqués, garantissant des déploiements d’applications plus fiables et prévisibles. Enfin, la construction d’images Docker voit des améliorations, simplifiant le processus de containerisation et améliorant la portabilité et l’efficacité des déploiements des applications Spring.

En conclusion, Spring Boot 3.2.0 s’aligne sur les dernières versions de Java, introduit des fonctionnalités révolutionnaires et affine les capacités existantes. Cette version permet aux développeurs de construire en toute confiance des applications modernes, résilientes et hautement performantes dans l’évolution constante du développement Java.

Montrez-moi le code

Dans cette session, nous nous lançons dans un voyage passionnant pour développer une API Pokemon, utilisant la puissance de Spring et l’intégrant de manière transparente avec HarperDB. Notre attention se portera sur la mise en œuvre des opérations de base CRUD (Create, Read, Update, Delete), avec une attention particulière portée aux identifiants uniques (IDs) pour chaque Pokemon. A la fin de cette session, vous aurez non seulement une application Spring entièrement fonctionnelle, mais aussi une API Pokemon à votre disposition, prête à être étendue et intégrée dans des projets plus larges. Plongeons dans le monde des Pokemon et du développement Spring, où la simplicité rencontre l’innovation.

Assurez-vous que votre base de données NoSQL, HarperDB, est en marche en utilisant Docker. Ouvrez votre terminal et exécutez la commande suivante:

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

Cette commande extrait l’image Docker de HarperDB et démarre un conteneur avec la configuration spécifiée. L’option -p mappe les ports du conteneur à votre machine locale, rendant l’interface HarperDB accessible à http://localhost:9925.

Dirigez-vous vers le Spring Initializer pour configurer notre application Spring. Suivez ces étapes :

1. Sélectionnez les paramètres de projet souhaités (par exemple, Maven ou Gradle, version de Java).
2. Ajoutez des dépendances : choisissez « Spring Web » dans la liste des dépendances.
3. Cliquez sur « Générer » pour télécharger le projet au format ZIP.

Extraire le fichier ZIP téléchargé et importer le projet dans votre environnement de développement intégré (IDE) préféré, tel qu’IntelliJ IDEA ou Eclipse.

Maintenant que notre application Spring est configurée, l’étape cruciale suivante est de l’intégrer à HarperDB. Pour ce faire, nous devons inclure la dépendance HarperDB dans notre projet. Ajoutez la dépendance Maven suivante à votre fichier pom.xml:

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

Avec la dépendance en place, passons maintenant au code. Nous allons créer une classe de configuration dans Spring, HarperDB, pour gérer la connexion et en faire une partie intégrante du conteneur Spring Inversion of Control (IoC) :

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

Cette classe de configuration, annotée avec @Configuration, crée un bean Spring nommé template. L’objet Template est un composant clé pour interagir avec HarperDB. Nous l’initialisons avec les détails de connexion au serveur, y compris l’URL du serveur et les informations d’identification. De plus, nous créons une base de données nommée “pokemons” et une table nommée “pokemon” avec une colonne “id”. Cela prépare le terrain pour stocker nos entités Pokemon dans HarperDB.

Pour améliorer la démo, nous allons d’abord créer une entité immuable en utilisant la fonctionnalité record de Java :

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

Cette classe de record Pokemon simple encapsule les attributs de base d’un Pokemon—son ID, son nom et sa localisation—de manière immuable.

Ensuite, établissons la communication avec la base de données en créant le PokemonService pour servir de pont vers 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);
    }
}

La classe PokemonService est un service Spring qui gère les opérations de base liées aux entités Pokemon. Elle utilise l’objet Template que nous avons configuré précédemment pour interagir avec HarperDB. La méthode findById récupère un Pokemon par son ID, enregistre, ajoute ou met à jour un Pokemon, et le supprime ou le retire de la base de données.

Enfin, créons le PokemonController pour exposer ces opérations en tant que points de terminaison REST :

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

Cette classe PokemonController est annotée avec @RestController et définit trois points de terminaison :

• GET /pokemons/{id} récupère un Pokemon par son ID.
• PUT /pokemons crée un nouveau Pokemon ou met à jour un existant.
• DELETE /pokemons/{id} supprime un Pokemon par son ID.

Le contrôleur s’appuie sur le PokemonService pour gérer ces opérations, offrant une séparation claire des responsabilités dans notre application Spring.

Avec ces composants en place, notre API Pokemon peut effectuer des opérations CRUD de base en utilisant HarperDB. N’hésitez pas à tester les points de terminaison et à voir l’intégration transparente de Spring avec la base de données NoSQL en action!

Votre application Spring, intégrée à HarperDB et dotée d’une API Pokemon, est maintenant prête pour les tests et l’exécution. Explorons quelques scénarios courants à l’aide de commandes curl. Avant de procéder, assurez-vous que votre application Spring est en cours d’exécution.

Créer un Pokemon

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

Cette commande crée un nouveau Pokemon avec l’ID 1, le nom Pikachu et l’emplacement Forest.

Récupérer un Pokemon par ID

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

Remplacez {id} par l’ID réel du Pokemon que vous venez de créer.

Mettre à jour un Pokemon

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

Cette commande met à jour le Pokemon existant avec l’ID 1 pour avoir le nom Raichu et l’emplacement Thunderstorm.

Supprimer un Pokemon par ID

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

Remplacez {id} par l’ID réel du Pokemon que vous souhaitez supprimer.

Ces scénarios offrent un test complet des opérations CRUD de base dans votre API Pokemon, en commençant par la création d’un Pokemon. Ajustez les commandes en fonction de votre cas d’utilisation et de vos données spécifiques. Bonne chance pour les tests!

Conclusion

Dans ce tutoriel, nous avons exploité les capacités de Spring Boot 3.2.0 pour créer une API Pokémon simplifiée intégrée de manière transparente à HarperDB. La dernière version de Spring a introduit des fonctionnalités clés, améliorant notre capacité à créer des applications résilientes et évolutives.

En utilisant des entités immuables, Spring IoC et HarperDB, nous avons démontré la simplicité du développement moderne en Java. Le code de démonstration, disponible ici, sert de base pour vos projets, prêt à être personnalisé.

Pour les mises à jour et des informations approfondies, veuillez consulter le blog officiel de Spring. Que votre parcours avec Spring Boot et HarperDB soit rempli d’innovation et de joie de coder! Bon codage!