Partie 2 : Concepts essentiels de Spring Boot

Introduction:

Dans le deuxième volet de notre série de blogs Spring Boot, nous approfondissons les concepts fondamentaux qui constituent l’épine dorsale de toute application Spring Boot. De la gestion des dépendances avec Maven ou Gradle au travail avec les données à l’aide de Spring Data et à la maîtrise des subtilités des services Web RESTful, nous ne négligeons aucun effort. Alors, attachez vos ceintures alors que nous embarquons pour un voyage à travers la gestion des dépendances, Spring Data et les profondeurs des services Web RESTful.

Gestion des dépendances avec Maven ou Gradle

Introduction aux outils de construction

Dans le domaine du développement Spring Boot, les outils de build jouent un rôle crucial dans la gestion des dépendances, la compilation du code source et l’empaquetage des applications. Deux outils de construction populaires dans l’écosystème Java sont Maven et Gradle.

Maven

Maven est un outil d’automatisation de build et de gestion de projet largement utilisé. Il utilise une approche déclarative pour définir les configurations et les dépendances du projet dans un fichier XML nommé pom.xml. Maven simplifie le processus de construction en fournissant une structure standardisée pour les projets et un référentiel central pour le téléchargement des dépendances.

Suivez les étapes ci-dessous pour Maven :

Importer un projet maven dans Eclipse

• Ouvrez Éclipse.
• Sélectionner Fichier > Importer > option.
• Sélectionnez l’option Projets Maven. Cliquez sur le bouton Suivant.

• Sélectionnez l’emplacement du projet, où un projet a été créé à l’aide de Maven. J’ai créé une série de projets Java SpringBoot-Blog dans la partie précédente.

Maintenant, vous pouvez voir le projet Maven dans Eclipse.

Maintenant, jetez un œil aux propriétés du projet Spring Boot Blog Series. Vous pouvez voir qu’Eclipse a ajouté des dépendances Maven au chemin de construction Java.

Il est maintenant temps de créer ce projet en utilisant la fonctionnalité maven d’Eclipse.

• Cliquez avec le bouton droit sur le projet Spring Boot Blog Series pour ouvrir le menu contextuel.
• Sélectionnez Exécuter en option.
• Puis l’option du package maven. Vérifiez la console pour les journaux.
• Maven va commencer à construire le projet

Maintenant, faites un clic droit sur HomeController.java. Sélectionnez le Courir comme option. Sélectionnez ensuite Application Java.

Vous pourrez voir la sortie dans la console.

Graduation

Gradle est un autre outil de construction puissant qui offre flexibilité et extensibilité. Il utilise un DSL (Domain-Specific Language) basé sur Groovy ou Kotlin pour créer des scripts. Contrairement à Maven, Gradle permet aux développeurs d’écrire des scripts de construction concis et expressifs. Il prend également en charge les builds incrémentielles, ce qui le rend efficace pour les grands projets.

Tout d’abord, nous devons ajouter le plugin Java au script de construction, car il fournit les tâches permettant de compiler le code source Java, d’exécuter les tests unitaires, de créer un Javadoc et de créer un fichier JAR.

Utilisez la ligne suivante dans build.gradle déposer.

appliquer le plugin : ‘java’

Disposition du projet Java par défaut

Chaque fois que vous ajoutez un plugin à votre build, cela suppose une certaine configuration de votre projet Java (similaire à Maven). Jetez un œil à la structure de répertoires suivante.

• src/main/java contient le code source Java.
• src/test/java contient les tests Java.

Si vous suivez cette configuration, le fichier de build suivant est suffisant pour compiler, tester et regrouper un projet Java.

Pour démarrer la build, tapez la commande suivante sur la ligne de commande après avoir accédé au chemin de votre projet.

Commande : build.gradle

initialiser l’exécution de la tâche

Gradle ne prend pas encore en charge plusieurs modèles de projet. Mais il offre un initialisation tâche pour créer la structure d’un nouveau projet Gradle. Sans paramètres supplémentaires, cette tâche crée un projet Gradle, qui contient les fichiers wrapper Gradle, un build.gradle et paramètres.gradle déposer.

Lors de l’ajout du -taper paramètre avec bibliothèque java comme valeur, une structure de projet Java est créée et le build.gradle Le fichier contient un certain modèle Java avec Junit. Jetez un œil au code suivant pour build.gradle déposer.

Exécutez à la fois les fichiers main et test.

Chemin : /SprinBoot-BlogSeries-1/src/main/java/com/springboot/SprinBootBlogSeries1Application.java

Chemin : /SprinBoot-BlogSeries-1/src/test/java/com/springboot/SprinBootBlogSeries1ApplicationTests.java

Maintenant, faites un clic droit sur SprinBootBlogSeries1Application.java. Sélectionnez le Courir comme option. Sélectionnez ensuite Application Java.

Vous pourrez voir la sortie dans la console.

Configuration des dépendances

Maven et Gradle rendent la gestion des dépendances transparente. Les développeurs déclarent les dépendances dans les fichiers de configuration de build, et l’outil de build se charge de les télécharger et de les gérer. Pour les projets Spring Boot, des dépendances sont spécifiées pour divers composants, tels que Spring Core, Spring Web, Spring Data, etc.

Par exemple, l’ajout de la dépendance Spring Web et de la dépendance des outils de développement Spring Boot à un projet Maven ressemble à ceci dans le fichier pom.xml :

Gestion des plugins

Les outils de build utilisent souvent des plugins pour étendre leurs fonctionnalités. Dans les projets Spring Boot, les plugins peuvent être utilisés pour des tâches telles que l’empaquetage de l’application dans un fichier JAR ou WAR exécutable. Les plugins sont configurés dans le fichier de configuration de l’outil de build.

Travailler avec des données dans Spring Boot

Introduction aux données Spring

Spring Data simplifie l’accès aux données dans les applications Spring. Il fournit un modèle de programmation cohérent et une abstraction sur divers magasins de données, notamment des bases de données relationnelles, des bases de données NoSQL, etc. Spring Data vise à réduire le code passe-partout et à rationaliser les tâches courantes d’accès aux données.

Configuration du Spring Data JPA

Spring Data JPA (Java Persistence API) fait partie du parapluie Spring Data qui simplifie le développement de couches d’accès aux données à l’aide de JPA. Il permet aux développeurs d’interagir avec les bases de données à l’aide d’annotations et de requêtes JPA standard. La configuration de Spring Data JPA implique de définir une source de données, de configurer des classes d’entités et de configurer des référentiels.

<dependency>            
<groupId>org.springframework.boot</groupId>         
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

Entrez le code ci-dessus dans pom.xml pour ajouter une dépendance Data JPA.

Création de référentiels et d’entités

Les référentiels de Spring Data fournissent une abstraction de haut niveau pour les opérations d’accès aux données. Ils éliminent le besoin d’écrire du code passe-partout pour les opérations CRUD (Créer, Lire, Mettre à jour, Supprimer). Les entités représentent le modèle de données et sont généralement annotées avec des annotations JPA pour les mapper aux tables de base de données.

Comme le nom le suggère,

• Opération CRÉER: Exécute l’instruction INSERT pour créer un nouvel enregistrement.
• Opération LIRE: Lit les enregistrements de la table en fonction du paramètre d’entrée.
• Opération DE MISE À JOUR: Exécute une instruction de mise à jour sur la table. Il est basé sur le paramètre d’entrée.
• Opération SUPPRIMER: Supprime une ligne spécifiée dans le tableau. Il est également basé sur le paramètre d’entrée.

Pour créer des référentiels avec une opération crud, veuillez Cliquez ici .

Services Web RESTful en profondeur

Mappage des demandes et contrôleurs

Les services Web RESTful sont un élément clé des applications Web modernes. Dans Spring Boot, la création d’API RESTful est simplifiée à l’aide de contrôleurs annotés. Les contrôleurs gèrent les requêtes HTTP et définissent la structure de l’API. Des annotations comme @RestController et @RequestMapping sont utilisés pour mapper les URL aux méthodes.

Corps de requête et de réponse

Les services RESTful traitent souvent des données aux formats JSON ou XML. Spring Boot prend en charge la conversion automatique entre les objets Java et ces formats de données. Les corps de requête peuvent être automatiquement mappés à des objets Java à l’aide @RequestBody annotation, tandis que @ResponseBody L’annotation aide à convertir les objets Java au format de réponse approprié.

@RequestBodyannotation

L’annotation @RequestBody relie le corps HTTPRequest à l’objet de domaine, en termes simples. À l’aide des convertisseurs de messages HTTP, le framework Spring désérialise automatiquement les requêtes HTTP entrantes et les convertit en objets Java.

Pour résoudre l’argument de la méthode en fonction du type de contenu de la requête, nous envoyons le corps de la requête via un HttpMessageConverter. Si les définitions précédentes paraissent confuses, l’annotation @RequestBody permet de récupérer le contenu de la requête et de la transformer automatiquement en Objet Java.

Maintenant, créons un contrôleur et expliquons où exactement l’annotation @RequestBody est utilisée.

package com.example;


import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProductAPIController {

        @GetMapping
        public String getAllProducts() {
//          code to get all product goes here
            return "This will return All the products";
        }

        @GetMapping(value = "{id}")
        public String getProduct(@PathVariable Integer id) {
//          code to get the product by ID goes here
            return "This will return the product associated with ID";
        }

        @PostMapping(value = "addProduct")
        public String addProduct(@RequestBody Product product) {
//          code to add the product goes here
            return "This will add the product which is passed by request body";

        }

        @PutMapping(value = "{id}")
        public String updateProduct(@RequestBody Product product, @PathVariable Integer id) {
//          code to update product associated with the given id will go here            
            return "This will update the product associated with the provided product ID";

        }

    }

Comme le montre le code ci-dessus, l’objet Product est annoté avec @RequestBody, ce qui signifie que PostRequest a un corps qui contient le format JSON de l’objet Product qui est capturé en tant que paramètre par la méthode addProduct via notre annotation @RequestBody.

Java désérialisera automatiquement le JSON entrant en un objet Produit si le JSON est valide et conformément aux conventions de dénomination des objets. Tout cela est fait par notre annotation.

Si nous testons notre application via Postman, nous pouvons voir notre sortie comme ci-dessous avec les méthodes Get, Post et Put,

@ResponseBody annotation dans Spring MVC

• En d’autres termes, @ResponseBody demande au framework Spring de sérialiser un objet de retour en JSON ou XML et de le renvoyer dans le cadre de HTTPResponse.
• Lors de l’interaction avec l’API REST dans Spring 4.x, nous devons utiliser @RestController au niveau de la classe plutôt que @ResponseBody au niveau de la méthode.
• @RestController est une annotation construite avec @Controller et @ResponseBody qui est elle-même une méta-annotation.
• Dans l’exemple précédent, notre fonction addProduct renvoie un objet Product, que nous souhaitons fournir dans la réponse HTTP au format JSON. Nous pouvons toujours spécifier le type de contenu que notre fonction renvoie lorsque nous utilisons l’annotation @ResponseBody.
• La propriété générée de @RequestMapping peut être utilisée pour cela.
  Notez que des annotations comme @PostMapping, @GetMapping, etc. définissent des alias pour ce paramètre.
• Comme on le voit dans notre contrôleur ci-dessus, nous avons l’annotation @RestController, nous n’avons donc plus besoin de @ResponseBody. Le @RestController ajoutera automatiquement @ResponseBody en cas de besoin.

Si vous n’avez pas suivi les bases de la configuration de SpringBoot et de l’environnement Cliquez ici pour lire.

Conclusion

En conclusion, la maîtrise de ces concepts essentiels de Spring Boot, notamment les outils de build, l’accès aux données avec Spring Data et les subtilités des services Web RESTful, constitue une base solide pour développer des applications robustes et évolutives. Ces concepts permettent aux développeurs de gérer efficacement les dépendances, d’interagir avec les bases de données et de créer des API bien conçues et résilientes.