Le monde du Big Data et la programmation informatique sont quasi indissociables. En effet, le traitement des données volumineux requiert un minimum de compétences en programmation. De ce fait, il est important de connaître et de maîtriser quelques langages de programmation. Hormis Scala, qui domine en partie le développement Big Data, Java est le langage le plus employé dans ce domaine. Et si l’on souhaite utiliser ce langage, que ce soit pour la Data ou autres, connaître Spring Java est devenu utile.
Dans cet article, nous allons vous présenter Spring Java, son fonctionnement et ses composants. Nous allons également évoquer sa place et son utilité dans le Big Data, mais aussi la manière de l’utiliser.
Spring Java : qu’est-ce que c’est ?
Nous avons déjà abordé le langage Java dans un autre article que vous pouvez retrouver sur notre blog. Mais en résumé, c’est l’un des langages les plus utilisés dans le développement informatique. Il s’agit d’un langage open source et multi-plateforme. Les codes Java sont compilés par son propre système nommé javac et interprété par sa propre machine virtuelle nommée JVM.
Spring Java est, quant à lui, le framework le plus utilisé pour faciliter le développement et les tests d’applications Java. C’est un framework open source et léger permettant aux développeurs Java et Java EE de concevoir des applications d’entreprise. Il permet de résoudre de nombreux problèmes rencontrés par ces développeurs tels que les problèmes de connectivité ou de sécurités. Il utilise notamment des concepts comme le POJO (Plain Old Java Project) et la POA (programmation orientée aspect).
On considère également Spring Java comme un framework de framework. En effet, il regroupe plusieurs projets basés sur le framework de base et plusieurs modules utilisés ensemble ou séparément. Grâce à tous ces outils, il permet de développer des solutions simples, performantes, facilement testables et évolutives avec Java.
Historique
Le framework Spring Java a été créé en 2003 par Rod Johnson et Juergen Holler. Il est à la base conçue afin de proposer une solution complémentaire au développement d’application sur Java EE. Ceci avait pour objectif de simplifier les aspects complexes de ce dernier.
Ses premières versions implémentent les fonctionnalités de base telles que POJO, les supports de JDBC, de l’ORM, les framework web, la POA et la configuration XML basée sur la définition DTD. Elles implémentent surtout le conteneur IoC qui est entre autres au cœur de Spring framework.
Les supports JMX, JDO 2, JCA CCI, JDBC Rowset, Hibernate 3 et TopLink ont été introduits à partir des versions 1.2.
Plusieurs nouveautés sont encore proposées dans les versions 2.x. Nous avons par exemple l’utilisation d’AspectJ, l’introduction de nouveaux namespaces, l’enrichissement et la facilitation de l’utilisation des namespaces existants. Il y a aussi la modification des configurations XML, la réalisation des tests d’intégration basée sur JUnit, etc. Le framework continue son évolution à travers les versions 3.x et 4.x et ne cesse d’introduire de nouvelles fonctionnalités.
Actuellement, il en est à sa cinquième généralement et plus précisément aux versions 5.3.x. Ces dernières versions sont compatibles avec les versions 8 à 18 de JDK. Elles apportent une fois de plus de nombreuses nouveautés et mises à niveau. Ces derniers sont axés essentiellement sur les parties framework web, accès aux bases de données, tests et Spring MVC.
Spring Java vs Java EE
Avant d’effectuer une brève comparaison de Spring Java et de Java EE, il est tout de même important de décrire un peu ce qu’est Java EE.
Alors, Java EE ou Jakarta Enterprise Edition (anciennement nommé Java Enterprise Edition ou J2EE) est une plateforme Java basée sur Java SE. On l’utilise pour le développement et l’exécution d’applications pour les entreprises. Elle se compose d’un serveur d’applications et d’un ensemble d’API. L’objectif de son utilisation est de faciliter la conception de solutions destinée aux architectures distribuées. Java EE a été produit pour la première fois en 1999 par Sun qui a été racheté par Oracle. Actuellement, Java EE en est à sa huitième version.
L’utilisation de Java EE offre plusieurs avantages aux développeurs. En effet, les applications développées avec Java EE sont fiables, flexibles, évolutives et sécurisées. Elle est multi-plateforme, portable et convient parfaitement aux applications complexes et à transactions élevées. Cependant, il présente certaines lacunes, notamment au niveau des prises en charge des développements web. Le coût de développement et de production d’une application est également assez onéreux avec J2EE. En plus, son environnement de développement s’avère assez complexe et difficile à appréhender.
Spring est un framework permettant de développer n’importe quelle application avec justement Java ou Java EE. On peut donc en déduire que comparer ces deux outils n’est pas pertinent puisque ce sont deux technologies complémentaires.
En effet, Spring a été conçu afin de simplifier l’utilisation de JavaEE sans pour autant le remplacer. Certes, il apporte quelques solutions face aux problèmes rencontrés par les développeurs Java EE par exemple en termes de flexibilité, de complexité de l’environnement et d’efficacité. Mais il possède également quelques points faibles notamment en termes de vitesse et de configuration.
Donc, pour effectuer un choix, il faut prendre en compte plusieurs aspects. Il faut considérer l’objectif à atteindre, le coût accepté, la complexité du projet ainsi que les fonctionnalités à mettre en place.
Les avantages de Spring Java
Votre choix se porte vers l’apprentissage et l’utilisation de Spring Java lors de vos prochains développements de projet ? Mais vous vous demandez toujours si ce choix est bon ou non ? Voici les avantages apportés par Spring Java autant pour le développeur que pour l’application elle-même :
- Tout d’abord, le fait qu’il soit open source laisse les développeurs libres sur ce qu’ils peuvent faire ou non ;
- La communauté autour de Spring framework est très active et sa documentation officielle est complète et facile à comprendre ;
- Les applications développées avec Spring sont à couplage lâche, léger, facile à tester et à maintenir. Cela est possible grâce à l’inversion de contrôle et l’injection de dépendance ;
- Il est facile à implémenter notamment grâce à l’utilisation de POJO ;
- Spring offre une meilleure gestion des transactions ;
- L’utilisation du patron de conception MCV permet d’obtenir des applications web bien organisée et facile à implémenter ;
- Plusieurs modules, projets et API y sont intégrés. Cela permet ainsi de faciliter le développement, mais également de faciliter la connexion à d’autres technologies ;
- Étant considéré comme un conteneur léger, il n’a pas forcément besoin de serveur d’application afin de fonctionner correctement.
Spring Java et Big Data
Comme nous l’avons brièvement mentionné dans l’introduction et dans la définition, le développement occupe une partie importante dans le traitement Big Data. Nous avons également mentionné que Java est l’un des langages les plus utilisés pour cela. Pour preuve, les plateformes et écosystèmes tels que Hadoop, Spark, Kafka ou Storm se basent sur Java ou sont développés avec ce langage. Cela veut dire que le framework Spring a lui aussi une place essentielle dans le traitement des données volumineuses.
En effet, Spring possède des modules permettant d’interagir avec les systèmes distribués utilisés dans ce type de solution. On peut intéragir avec plusieurs types de stockage, que ce soit une Data Warehouse, une Data Lake ou le cloud. Il y a par exemple le module Spring Data qui permet d’interagir avec tout type de base de données, relationnelle ou non-relationnelle. Il permet également d’accéder à des framework implémentant MapReduce ou encore des services basés sur le cloud. Nous avons également Spring Batch qui permet de traiter des données volumineuses par lot. Puis, il y a Spring Boot qui permet de créer une application afin de consolider le tout. Et malgré le fait que l’on ne maintient plus le module Spring HDFS, il permet toujours d’interagir avec certaines anciennes versions d’Hadoop.
En plus, il n’est pas rare que l’on doive intégrer un projet Big Data avec des applications d’entreprise ou encore de développer des outils plus spécifiques à l’entreprise afin d’optimiser la prise de décision. Spring Java permet d’effectuer cela de manière simple.
Fonctionnement
Pour comprendre le fonctionnement de Spring Java, il faut connaître les principaux patrons de conception utilisés dans ce framework à savoir l’inversion de contrôle et le MCV, mais également le paradigme AOP.
AOP
AOP ou Programmation Orientée Aspect est un paradigme visant à séparer la partie métier à la partie transversale (cross-cutting concerns) telle que la journalisation, la mise en cache, la sécurité ou la transaction. Un aspect désigne un ensemble d’action à exécuter à un instant précis de l’exécution de l’application et selon certaines conditions.
Pour cela, on doit définir des points précis auxquels ces aspects doivent s’exécuter afin que ces derniers puissent effectuer les actions définies dans celles-ci en modifiant le flot d’exécution général de l’application. Cela permet de ne pas répéter le code exécutant ces actions dans chaque classe qui en a besoin.
On peut appliquer la programmation de deux manières différentes : statique, c’est-à-dire que ces opérations s’effectueront au moment de la compilation ; et dynamique où les opérations se déroulent à l’exécution de l’application. C’est cette dernière approche qui est la plus simple à mettre en place et par conséquent la plus utilisée. Cependant, cette dernière rajoute un coût supplémentaire à l’application, car on doit faire appel à un autre module afin d’exécuter ces aspects.
Inversion de contrôle et Injection de dépendance
L’inversion de contrôle est un patron de conception utilisé essentiellement dans la programmation orientée aspect. Elle se base sur le fait que l’application ne contrôle pas elle-même de son exécution, mais que cette tâche revient au framework utilisé lors de son développement.
En Spring Java, ce design pattern se présente sous forme d’injection de dépendance qui permet de découpler au maximum chaque classe afin qu’elles au maximum indépendant et que l’on puisse au maximum les réutiliser.
Considérons par exemple cette classe :
public class Calcul{
private Addition addition;
public Calcul() {
addition = new Addition();
}
}Nous avons ici une manière classique d’instancier une classe dans une autre avec Java. Maintenant, si l’on applique l’injection de dépendance à cette classe, nous obtenons par exemple les codes suivants :
public class Calcul{
private Addition addition;
public Calcul(Addition addition) {
this.addition = addition;
}
}Ici, on implémente la classe Addition indépendamment de la classe Calcul et on l’injecte seulement à cette dernière au sein de son constructeur. On instancie donc Addition en même temps que Calcul et le tout est géré par Spring.
Hormis cette méthode utilisant un constructeur de classe, on peut également effectuer cette inversion de contrôle à l’aide d’un setter.
MVC
MVC ou Model View Controler est un patron de conception qui vise à séparer le traitement et l’affichage au sein d’une application. Comme son nom l’indique, on divise généralement les applications en trois parties à savoir :
- Le modèle qui gère la partie donnée et les logiques concernant cela ;
- La vue qui implémente l’interface graphique, c’est-à-dire la partie visible par l’utilisateur ;
- Le contrôleur qui sert de tunnel entre les deux précédentes parties et se charge également des traitements nécessaires avant l’acheminement des informations, que ce soit d’un côté ou d’une autre.
On utilise ce pattern dans Spring Java, notamment dans la partie du développement web.
Il faut savoir que MVC peut s’incliner sous d’autres formes telles que le MVVM (Model-View-View-Model), le MVP (Model-View-Presenter) ou le MVW (Model-View-Whatever).
En sachant ces bases, nous pouvons maintenant définir les fonctionnalités de Spring Java.
Grâce à l’inversion de contrôle, Spring agit comme un conteneur léger qui s’occupe de la gestion des objets et leurs dépendances. Ainsi, les objets sont faiblement couplés tout en bénéficiant des fonctionnalités avancées concernant la configuration et l’injection automatique.
Toujours dans cette optique de couplage lâche, Spring sépare les applications généralement en trois couches :
- La présentation qui s’occupe de l’interfaçage homme-machine ;
- Le service qui s’occupe des aspects ;
- L’accès aux données, c’est-à-dire la connexion à la source de données ainsi que le traitement et la persistance des données.
Les composants du framework Spring Java
Maintenant que l’on sait comment il fonctionne, on va voir les composants qui entrent en jeu pour que ce fonctionnement puisse être effectif. Avant de détailler chaque composant, voici l’architecture de ce framework :
Comme on peut le constater, Spring est divisé en différentes parties dont chacun est composé de plusieurs modules. Voyons un à un les composants selon chaque partie.
Spring Core Container
Les modules de Spring Core Container sont ceux qui œuvrent à la mise en place du conteneur léger.
Spring Core et Beans
Ces deux modules constituent le cœur de Spring, car ce sont eux qui contiennent les parties fondamentales du framework. C’est également grâce à ces deux modules que l’on peut appliquer l’inversion de contrôle et l’injection de dépendance au sein de Spring Java afin d’obtenir le conteneur. Ils se basent essentiellement sur le concept de Beanfactory, une implémentation améliorée du pattern Factory, qui permet de découpler la configuration et la spécification des dépendances selon la logique que l’on suit lors du développement.
Spring Context
Ce module s’appuie sur les deux précédents modules afin de fournir un accès à un objet défini du framework. Il contient plusieurs fonctionnalités telles que l’internationalisation, la création transparente des contextes, le chargement de ressources, la propagation d’évènement, le mail, etc. Spring Context prend également en charge certaines fonctionnalités Java EE comme le JMX, mais aussi la communication à distance de base. L’accès à toutes les fonctionnalités de Context se fait à travers une interface appelée ApplicationContext.
SpEL
SpEL ou Spring Expression Language est le module qui fournit le langage à utiliser afin d’interroger et de manipuler les objets gérés par le conteneur lors de son exécution. Il permet notamment d’effectuer plusieurs opérations avec ce langage telles que la définition et la récupération des valeurs de propriété, l’affectation de propriété, l’appel de méthode, la manipulation des tableaux, des listes, des collections et des indexeurs ainsi que les opérateurs logiques et arithmétiques.
AOP et Instrumentation
Les modules regroupés dans cette partie sont ceux qui permet d’implémenter la programmation orientée aspect. Ils permettent donc d’effectuer des tâches relatives à cela. Par exemple, on peut définir les points sur lesquels s’exécutent les aspects ou encore mettre en place un intercepteur de méthodes. Ce groupe contient trois modules à savoir Spring AOP, Spring AspectJ et Spring Instrumentation.
Spring AOP est le module principal implémentant le paradigme de programmation AOP, Spring AspectJ est le module intégrant AspectJ à Spring framework. AspectJ est une extension permettant d’implémenter la programmation orientée aspect en Java.
Le module Spring Instrumentation, quant à lui, est celui qui fournit un support d’implémentation ainsi que des chargeurs de classe.
Data access et intégration
Il s’agit des modules qui prennent en charge l’accès aux données et le traitement des transactions de l’application.
Spring JDBC
Ce module fournit une couche d’abstraction JDBC facilitant l’utilisation de JDBC lors de l’interaction avec une base de données. Il facilite également la compréhension des erreurs spécifiques à chaque système grâce à une hiérarchie d’exceptions dédiées.
Spring ORM
Le module Spring ORM fournit une couche d’intégration des APIs de mappage objet-relationnel telles que JDO, JPA ou encore Hibernate et ainsi pouvoir les intégrer aux autres fonctionnalités et aux modules proposés par Spring Java.
Spring OXM
Celui-ci, quant à lui, permet d’intégrer des APIs de mappage objet-XML telles que XMLBeans, JAXB, XStream, JiBX ou encore Castor.
Spring JMS
Il s’agit du module servant de support au service de messagerie de Java. Il permet donc de produire, de traiter et de recevoir des messages. Ce module s’intègre directement au module messagerie de Spring.
Spring Transaction
Spring Transaction est le module permettant d’effectuer la gestion des transactions pour les classes implémentant des interfaces spéciales et les objets POJO.
Web
Les modules Web de Spring regroupent tous les modules permettant de concevoir une application web de manière efficace.
Spring Web
C’est le module fournissant les fonctionnalités d’intégration de base pour la création d’une application web. Il contient par exemple les fonctionnalités de téléchargement de fichier en plusieurs parties ou l’initialisation des conteneurs IoC ainsi que le support à distance de Spring relatif au web.
Spring Web-Servlet
Web-Serverlet est le module permettant d’implémenter MVC et REST lors du développement web dans le framework Spring. Avec Web-Serverlet, le code du modèle et des formulaires web sont bien séparés. On peut tout à fait utiliser toutes les autres fonctionnalités de Spring avec ce module.
Spring Web-Portlet
Tout comme Web-Serverlet, Web-Portlet permet d’implémenter le pattern MVC dans une application développée avec le framework Spring. Par contre, on utilise celui-ci sur un environnement de portlets.
Spring Web-Struts
Struts est un framework MVC basé sur les requêtes prenantes en charge AJAX, REST et SOAP et permettant de développer des applications web Java. Le module Spring Web-Struts permet donc évidemment d’apporter un support à ce framework afin de pouvoir l’utiliser tout en bénéficiant des fonctionnalités de Spring.
Spring Test
Cette partie se compose d’un seul module qui permet d’effectuer des tests unitaires et des tests d’intégration avec JUnit ou TestNG. Ce module permet également d’effectuer des tests isolés au sein de l’application à l’aide des nombreux objets Mock qu’il fournit. On peut aussi effectuer la mise en cache des contextes d’ApplicationContexts avec lui.
Les projets Spring
Outre les nombreux modules que propose Spring Java, il offre également plusieurs projets connexes regroupés dans Spring IO (Spring Integration Objects). Ces derniers servent à faciliter encore plus le développement d’application avec ce framework. Nous allons voir quelques-uns d’entre eux dans cette section.
Spring Boot
Spring Boot fait sans doute partie des projets Spring les plus populaires en ce moment. Il s’agit d’un framework développé par Pivotal permettant de faciliter le développement de nouvelles applications Spring prêtes pour la production. Son objectif est entre autres de réduire la complexité des configurations d’une application Spring Java. Cela permet aux développeurs de ne pas définir la même configuration partout dans le code, ce qui les fait gagner beaucoup de temps tout en obtenant une application facile à comprendre et à développer.
Spring Boot sert à développer un microservice qui est une architecture permettant de développer et de déployer des services de manière indépendante. Cela implique que chaque service s’exécute de manière autonome, ce qui permet d’obtenir une application finale légère.
L’ascension de ce framework est fulgurante ces dernières années au point où de nombreux projets Spring actuels l’utilise.
Spring Web Flow
Spring WebFlow est un projet Spring permettant de mieux gérer l’enchaînement d’une application web. Pour cela, on implémente un flux web qui est une structure contenant une séquence d’étapes que l’utilisateur doit suivre au cours de l’exécution d’une tâche au sein de l’application. Il s’agit d’un module réutilisable qui couvre plusieurs requêtes HTTP, qui traite les données transactionnelles et qui possède un état. De ce fait, il résout de nombreux problèmes relatifs à ses fonctionnalités et ainsi permet d’obtenir une application web modulaire et plus fluide.
Spring Tools
Il s’agit d’une suite d’outils que l’on peut intégrer à notre IDE favori. Spring Tools fournit notamment une intégration de Spring Initializr et Spring Guides afin que l’on puisse développer facilement une application avec Spring Boot. Il offre de nombreuses autres fonctionnalités comme l’aide à l’édition des codes, la recherche de code, etc. La version 4 de Spring Tools est disponible pour Eclipse, Visual Studio Code et Theia.
Spring Cloud
Spring est le projet Spring Java permettant d’implémenter facilement et rapidement des services et des applications dans un système distribué. Il comprend plusieurs sous-projets tels que Spring Cloud Config, Spring Cloud Netflix, Spring Cloud Bus, Spring Cloud Stream, Spring Cloud Starters, etc. ainsi que de patterns tels que Monitoring, Routing and Load Balancing, Fault Tolerance, Distributed Messaging, etc. Spring Cloud fonctionne sur n’importe quel type de système distribué, que ce soit une simple machine, une Data Center ou encore les plateformes basées sur le cloud. La manière la plus simple de l’utiliser est d’intégrer la version adéquate de Spring Cloud à un projet Spring Boot. Cela facilitera la compilation du projet avec Maven ou Graddle, car ce module intègre directement Spring Cloud BOM (Bill Of Material, un système de gestion de version).
Spring Data
Spring Data est un projet Spring facilitant l’interaction avec n’importe quel type de système de gestion de base de données, qu’il s’agisse d’une base de données relationnelles, d’une base de données NoSQL, d’un système basé sur le cloud ou d’une architecture Big Data. En utilisant ce projet, les développeurs n’auront plus à coder l’accès à ces derniers. Il contient différents sous-projets spécifiques à chaque type de système facilitant ainsi l’accès et la manipulation de celui-ci.
Spring Security
Spring Security est un module permettant non seulement de sécuriser vos applications Spring, mais également toutes vos applications Java en général. Il fournit un puissant système d’authentification ainsi qu’un système de gestion des autorisations prévenant ainsi toutes tentatives de cyberattaques de vos projets.
Spring HATEOAS
Spring HATEOAS (Hypertext As The Engine Of Application State) est une bibliothèque d’APIs permettant d’implémenter des services REST. Ces services REST doit justement respecter le principe HATEOAS dans une application MVC. Pour rappel, le principe HATEOAS stipule que le client doit passer par un lien Hypermedia généré dynamiquement par le serveur pour interagir avec le service. C’est d’ailleurs celui qui caractérise le plus les APIs REST. Le client n’a donc pas besoin de connaître le fonctionnement du service ni la manière d’interagir avec le serveur. Il lui siffit de connaître le lien à contacter. Cette bibliothèque fournit trois manières de créer des URI sans avoir à solliciter Serverlet Context et concaténer le lien à la base de l’URI.
Maintenant que nous avons vu tous les côtés théoriques de cet article, passons maintenant aux cas pratiques. Puisque nous ne pourrions pas traiter chaque projet et chaque module, nous allons vous fournir quelques exemples d’utilisation de ce framework. Cela vous aidera à faire vos premiers pas en Spring Java.
Les prérequis
Afin de pouvoir développer des applications en utilisant ce framework, il faut disposer de certains prérequis à savoir :
- Une bonne connaissance en Java. Vous pouvez parcourir notre guide complet sur Java pour cela ainsi que d’autres articles connexes ;
- Java Development Kit (Version 8, 11, 17 ou 18) installé sur votre machine ;
- Disposer d’une Interface de développement (IDE) tel que Eclipse, Visual Studio Code, etc. ;
- Spring Framework Libraries ;
- Disposer des outils de gestion d’automatisation de projet tel que Maven, Graddle, etc.
Ces prérequis peuvent augmenter en fonction du projet que l’on entreprend et des modules entrant en scène dans ce projet.
Maintenant, passons à la pratique !
Exemples d’utilisation de Spring Java
Ce sera à travers ces quelques exemples que nous allons illustrer l’utilisation de Spring pour le développement d’une application Java.
Exemple #1 : premier pas avec Spring Java : le fameux Hello World
La meilleure façon de commencer ces mini-tutoriels serait bien évidemment de développer le fameux Hello World.
Afin d’effectuer cela en Spring Java, nous allons utiliser https://start.spring.io/ . C’est le moyen le plus facile d’implémenter une solution avec Spring. Cet outil va nous permettre d’utiliser Spring Boot afin de développer une application web facilement.
Après avoir cliqué sur ce lien, vous serez redirigé vers une page comme ceci :
Sur la partie ADD DEPENDENCIES, rechercher “Web” puis cliquer dessus afin de le choisir. Vérifiez que la version cochée sur la partie gauche de la page ne soit pas SNAPSHOT. Vous pouvez également modifier les autres paramètres tels que le nom du projet, l’artefact, etc. Cependant, nous n’allons pas le faire cette fois-ci, puisque nous allons juste implémenter notre première démo.
Une fois que tout est OK, cliquez sur GENERATE afin de télécharger le dossier. Vous allez obtenir un fichier .zip que vous devez extraire et placer dans le répertoire que vous souhaitez sur votre machine.
Maintenant, vous devez ouvrir le dossier à l’aide de l’IDE que vous avez choisi. Ensuite, allez dans src/main/java puis sélectionnez le fichier DemoApplication.java.
Modifions les codes contenus dans ce fichier par les codes ci-dessous :
package com.example.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
@SpringBootApplication
@RestController
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
@GetMapping("/hello")
public String hello(@RequestParam(value = "name", defaultValue = "World") String name) {
return String.format("Hello %s!", name);
}
}Dans ce code, nous avons une méthode main qui exécutera l’application une fois générée. Nous avons également une méthode hello qui retourne une chaine de caractère. Cette variable possède une valeur par défaut qui est World.
Comme vous pouvez également le constater, nous avons rajouté quelques bibliothèques. Ces derniers servent justement à ce qu’on puisse initialiser une valeur par défaut de notre paramètre, à router notre méthode ou à spécifier notre contrôleur.
Exécutons notre application en commençant par le builder. Nous allons pour cela exécuter la commande suivante sur une invite de commande en pointant sur le dossier contenant notre projet :
- Pour Linux et MacOS :
./mvnw spring-boot:run- Sur Windows :
.\mvnw spring-boot:run
La compilation ainsi que le téléchargement du plug-in Maven pour Spring Boot vont se lancer. Une fois le build terminé, vous devriez voir l’affichage suivant stipulant que tout s’est bien passé :
On peut maintenant visiter l’URL localhost:8080/hello pour lancer notre première application Spring Java.
Et si l’on rajoute le paramètre name à la fin de ce lien, la phrase que l’on aperçoit changera en fonction de cela.
Exemple #2 : créer un service web RESTful
Dans ce deuxième exemple, nous allons créer un service web RESTful simple. Celui-ci aura pour objectif d’effectuer une requête GET afin de récupérer un fichier JSON. Ce dernier contient un id et un content avec comme contenu la phrase “Hello, World!” que nous avons utilisé dans l’exemple précédent.
Nous allons donc modifier ce même projet afin de le transformer en service web. Tout d’abord, nous allons ajouter une classe que l’on va nommer Hello (vous pouvez l’appeler comme vous le souhaitez). On va la mettre dans le même dossier que DemoApplication et dans laquelle nous allons mettre les instructions suivantes :
package com.example.demo;
public class Hello {
private final long id;
private final String content;
public Hello(long id, String content) {
this.id = id;
this.content = content;
}
public long getId() {
return id;
}
public String getContent() {
return content;
}
}Comme on peut le constater, cette classe est celle qui va définir notre objet Hello avec l’initialisation des variables, le constructeur de l’objet ainsi que les accesseurs des paramètres. C’est cette classe que l’on va instancier afin d’obtenir le résultat que l’on souhaite afficher dans le JSON.
Après cela, nous allons nous attaquer au fichier principal que nous avons utilisé dans l’exemple précédent. Nous allons modifier le contenu de ce fichier, plus précisément la méthode hello qui est celle qui mappe sur l’URL de l’API.
Tout d’abord, il faut que l’on ajoute la bibliothèque suivante :
import java.util.concurrent.atomic.AtomicLong;Ensuite, on procède à la modification de la méthode de la manière suivante :
private static final String template = "Hello, %s!";
private final AtomicLong counter = new AtomicLong();
@GetMapping("/hello")
public Hello hello(@RequestParam(value = "name", defaultValue = "World") String name) {
return new Hello(counter.incrementAndGet(), String.format(template, name));
}Cette méthode fourni un id incrémenté par le conteur counter ainsi qu’un content avec le contenu composé d’un template suivi de la valeur spécifiée dans le paramètre name. Ce résultat ressemble à ceci si l’on ne spécifie pas de valeur dans name :
Et si, comme dans l’exemple précédent, on ajoute le paramètre name à notre URL, nous obtenons le résultat suivant :
Comme vous pouvez le constater, l’id a bien été incrémenté. Le contenu de content a aussi changé en fonction de la valeur que l’on a spécifiée.
Exemple #3 : consommer un service web RESTful
Dans ce troisième exemple, nous allons, au lieu de créer notre API REST, consommer une API publique en codant nous-mêmes l’accès à cette dernière.
Nous allons toujours utiliser notre précédent projet afin d’illustrer cela. Choisissons également une API au hasard, par exemple l’API Cat Fact que l’on peut contacter via cette URL : https://catfact.ninja/fact
Créons une classe qui va nous servir de modèle afin de recevoir le résultat de la requête. Le contenu de cette classe doit ressembler à ceci :
package com.example.demo;
public class Fact {
private String fact;
private long length;
public String getFact(){
return fact;
}
public void setFact(String fact){
this.fact = fact;
}
public long getLength(){
return length;
}
public void setLength(long length){
this.length = length;
}
@Override
public String toString() {
return "Content{" +
", fact='" + fact + '\'' +
", length='" + length + '\'' +
'}';
}
}Il faut noter que les variables de cette classe doivent ressembler à celles fournies par l’API. Vous pouvez consulter la documentation de l’API en question afin de les connaître.
Une fois cette classe créée, nous allons modifier notre classe principale. Cette dernière ressemblera à ceci :
package com.example.demo;
//import java.util.concurrent.atomic.AtomicLong;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
//import org.springframework.web.bind.annotation.GetMapping;
//import org.springframework.web.bind.annotation.RequestParam;
//import org.springframework.web.bind.annotation.RestController;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;
@SpringBootApplication
//@RestController
public class DemoApplication {
private static final Logger log = LoggerFactory.getLogger(DemoApplication.class);
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
/*private static final String template = "Hello, %s!";
private final AtomicLong counter = new AtomicLong();
@GetMapping("/hello")
public Hello hello(@RequestParam(value = "name", defaultValue = "World") String name) {
return new Hello(counter.incrementAndGet(), String.format(template, name));
}*/
@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
return builder.build();
}
@Bean
public CommandLineRunner run(RestTemplate restTemplate) throws Exception {
return args -> {
Fact fact = restTemplate.getForObject(
"https://catfact.ninja/fact", Fact.class);
log.info(fact.toString());
};
}
}Comme vous pouvez le constater, nous avons commenté certaines librairies qui ne nous sont pas nécessaires dans cet exemple. Nous avons également commenté la mention @RestController, car nous n’allons pas émettre de résultat sous format web.
En effet, dans cet exemple, nous allons juste afficher le résultat à travers les logs de l’application.
Ici, nous avons deux méthodes ou plutôt deux objets Bean. Le premier, nommé restTemplate, va nous servir de support afin d’intercepter le résultat de la requête. Puis, nous avons la méthode run qui est une implémentation de CommandLineRunner servant à exécuter le RestTemplate.
Maintenant, si l’on effectue un build et qu’on lance notre projet, nous devrions obtenir le résultat suivant :
Voilà, nous terminons cet article sur ce dernier exemple. Vous pouvez maintenant utiliser Spring Java afin d’optimiser le développement d’applications d’entreprise en Java. Cet article vous aidera à mieux démarrer avec ce framework en apprenant les bases nécessaires à son utilisation.
Si vous souhaitez en apprendre davantage sur Java ou la programmation informatique en général ou en Big Data, nous vous invitons à parcourir notre blog afin de découvrir d’autres articles intéressants. Nous vous invitons également à télécharger cette formation qui vous aidera à devenir Data Engineer Spark Scala.
