Aller au contenu

Spring Boot - Premiers pas

A la découverte de SpringBoot

Découvrir le framework Spring

Spring est un framework Java open source qui facilite et structure le développement d’applications java. Créé par Rod Jonhson, il est aujourd’hui porté par la société Pivotal.

Initialement dénommé Spring Framework, il est utilisé dans de nombreux projets depuis de nombreuses années.

Au fils du temps, il a évolué pour fournir toujours plus de services et permettre aux développeurs de travailler plus vite, plus facilement et de manière plus structurée.

Spring Framework est composé de modules

spring-architecture

Bien qu’ils soient prévus pour être indépendants, il est fréquent et souvent intéressant d’utiliser au maximum les services qu’ils proposent. Spring est un framework extrement puissant, proposant des services très intéressants mais il un a un gros défaut : il est assez difficile à configurer.

C’est pour palier ce défaut qu’a été créé SpringBoot.

Bien que l’objectif principal soit toujours le même (permettre de développer plus facilement, plus rapidement et de manière structurée des applications java), SpringBoot facilite la mise en place d’un projet qui utilisera les fonctionnalités proposées par Spring en fournissant :

Par ailleurs, SpringBoot est particulièrement efficace dans la création d’API Rest (ou RestFull).

Concepts fondateurs

Spring s’appuie sur 3 concepts :

L’IOC gère les dépendances entre les classes par une simple déclaration.

La POA sépare la couche métier (coeur du logiciel) de la couche technique.

La couche d’abstraction permet d’intégrer facilement d’autres frameworks ou bibliothèques. On utilise pour cela l’outil Maven ou Gradle.

Avant de commencer à utiliser SpringBoot, il faut installer le plug-in pour Eclipse.

SpringBoot est un framework java très pratique et facile à mettre en place. Il prend en charge les dépendances nécessaires au fonctionnement du projet. Une fois le plug-in installé, vous pourrez générer un projet Gradle depuis le site web : https://start.spring.io/

Installation du plugin STS pour eclipse

A installer depuis le Eclipse Marketplace (nous ne l’utiliserons pas dans l’immédiat pour la création de projet SpringBoot) :

STS dans le marketplace

Création d’un projet SpringBoot-Gradle depuis Spring Initializr

Ce projet est une application Standalone (non web)

rendez-vous à l’adresse : htpps://start.spring.io/ et suivez les instructions.

Initializr01

On choisit le type de build system (c’est-à-dire la façon dont le projet sera compilé et géré)

On choisit le langage de développement du projet :

On choisit la version de Spring Boot

Les options ont des suffixes :

Project Metadata

C’est la carte d’identité du projet :

Remarque : Souvent on utilise un serveur embarqué comme Tomcat dans un projet Web et du coup, on peut choisir JAR sauf si on utilise un serveur externe à l’application ce qui est possible mais rare avec Spring Boot !

Voici les différences sous forme de tableau

Format Signification Type d’application Mode d’exécution
JAR (Java ARchive) Application autonome contenant tout (code, dépendances, serveur embarqué) Application standalone, exécutable directement java -jar monApp.jar
WAR (Web Application ARchive) Application déployable sur un serveur Java externe (Tomcat, Jetty, JBoss, WebLogic…) Application hébergée dans un conteneur servlet Copie du .war dans webapps/ d’un serveur

Intérêt du JAR

L’intérêt avec Spring Boot, réside dans le fait que lorsque l’on choisit un JAR, il embarque un serveur Tomcat (ou Jetty ou autres directement dans le fichier JAR. Du coup, l’application se lance et on y accède via l’url de l’application web.

Les avantages :

Intérêt du WAR et modificiations

Le choix du WAR correspond à des cas spécifiques

Cas Exemple
On doit déployer sur un serveur Tomcat déjà en production Entreprise où un Tomcat commun héberge toutes les apps
On fait de la cohabitation d’applications dans un même conteneur Plusieurs WAR partagent le même Tomcat
On travaille avec anciens outils / procédures DevOps Certains outils legacy imposent le WAR

Il faudra changer des paramètres et modifier le code Spring Boot :

@SpringBootApplication
public class DemoApplication extends SpringBootServletInitializer {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

La zone des Dépendances

C’est là que l’on ajoute modules Spring dont on a besoin dans le projet.

Il faut cliquer sur Add Dependencies et chercher :

Choix de récupération du projet

Résumé visuel

SPRING INITIALIZR
├── Project : Maven / Gradle
├── Language : Java / Kotlin / Groovy
├── Spring Boot Version
├── Project Metadata
│     ├── Group
│     ├── Artifact
│     ├── Name
│     ├── Description
│     ├── Package name
│     ├── Packaging
│     └── Java Version
├── Dependencies
└── Buttons (Generate / Explore)

Voici la dernière version de l’interface Spring Initialzr avec des informations

Version plus anciennces ci-dessous

Initializr02

Importation du projet Gradle dans Eclipse

Initializr03

Etapes d’importation du projet Maven ou Gradle dans IntelliJ

Liste des étapes pour importer un projet Spring Boot Initialzr dans l’IDE IntelliJ

Ajout d’un package et d’une classe (un simple Bean)

Cette classe MessageBean contient 2 méthodes :

@Component("messageBean")
public class MessageBean {
	public void message()
	{
		System.out.println("Bonjour cher(e) apprenant(e) !");
		
	}
	public void message(String phrase)
	{
		System.out.println("Bonjour cher(e) apprenant(e), voici ta phrase : "+phrase);
	}
}

Modification dans la classe principale et la méthode main()

@SpringBootApplication
@ComponentScan(basePackages = {"fr.bouget.spring.message.springdemo01"})
public class Springdemo01Application {

	public static void main(String[] args) {
		ApplicationContext context = SpringApplication.run(Springdemo01Application.class, args);
		MessageBean monObjetMessage = (MessageBean) context.getBean("messageBean");
		monObjetMessage.message();
		monObjetMessage.message("C'est facile SpringBoot !");
	}
}

Exécution

Résultat attendu dans votre console

Initializr04

Création d’un projet web SpringBoot-Gradle depuis Spring Initializr

Projet identique avec une dépendance pour le web. Quelques annotations suffisent pour le webiser !

Il faudra juste ajouter une dépendance. Voici un extrait du build.gradle :

implementation 'org.springframework.boot:spring-boot-starter-web'
providedRuntime 'org.springframework.boot:spring-boot-starter-tomcat'

Structure du projet

En parcourant notre projet SpringBoot, on observe que les répertoires suivants ont été créés :

En plus de ces répertoires, des fichiers de configurations essentiel au bon fonctionnement de notre projet ont été générés dont celui de Gradle.

Dans ce fichier, on y trouve :

C’est grâce à ce fichier que le projet java sera configuré et que l’ensemble des librairies utiles seront téléchargées et intégrées au projet.

Dans le répertoire src/main/resources Il y a un fichier important nommé application.properties. Ce fichier a vocation à contenir TOUTES les informations de configuration des composants utilisés par le projet (composants encapsulés par SpringBoot).

Toutefois, il est possible de stocker les informations de configuration dans d’autres types de fichiers (YAML, XML) en créant une classe spécifique pour que le framework SpringBoot puisse prendre en charge ce changement.

Pour plus de détails sur les mots clefs utilisables, cliquez ici.

Dans le package fr.bouget.spring.message.springdemo02.bean ajouter la classe suivante (ici, pas de changement) :

@Component("messageBean")
public class MessageBean {
	public String message()
	{
		return "Bonjour cher(e) apprenant(e) !";
	}
	public String message(String phrase)
	{
		return "Bonjour cher(e) apprenant(e), voici ta phrase : "+phrase;
	}
}

package fr.bouget.spring.message.springdemo02;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Springdemo02Application {
	public static void main(String[] args) {
		SpringApplication.run(Springdemo02Application.class, args);
	}
}

L’annotation @SpringBootApplication a 3 fonctions :

Voici la classe MessageController, le point d’entrée.

@Controller
@RequestMapping("/demo2")
public class MessageController {
	
	@Autowired
	private MessageBean messageBean;
	
	@RequestMapping("/message")
	@ResponseBody
	public String afficherMessage()
	{
		return messageBean.message();
	}
	
	@RequestMapping("/message/{phrase}")
	@ResponseBody
	public String afficherMessage(@PathVariable("phrase") String phrase)
	{
		return messageBean.message(phrase);
	}

}

Dans le monde Spring, le mot Controller designe la classe qui fournit les services web (équivalent des Servlet en Java Web). C’est le point d’entrée de l’application web. Pour définir un Controller au sens Spring, on va ajouter à la classe précédemment créée l’annotation @Controller.

Grâce à cette annotation, Spring identifiera cette classe comme une classe spéciale sur laquelle le framework travaillera.

Pour relier la méthode afficherMessage() à une URI, on va ajouter à la déclaration de la méthode l’annotation @RequestMapping(chemin). Chemin étant la chaîne de caractère qui sera ajoutée à la fin de l’URL entrée dans le navigateur.

Comme notre méthode retourne une variable (ici une chaîne de caractères), il faut aussi ajouter l’annotation @ResponseBody qui permet de renvoyer une réponse HTTP.

Lancer votre application web

http://localhost:8080/demo2/message

puis celle ci-dessous :

http://localhost:8080/demo2/message/phil Jarive qui arrive !

Annotations Spring 5.0/6.2

Cliquez sur ce lien du blogspot javamidnight

Conclusion

Avec ces projets d’introduction, vous avez pu découvrir que SpringBoot :

Quelques conseils

Spring est un framework difficile à prendre en main car son champ d’application est très vaste.

Il fournit une quantité importante de classes utilisables pour différents contextes / besoins et une quantité phénoménale d’annotations auxquelles viennent s’ajouter les annotations des librairies que Spring gère. De plus il est souvent possible d’écrire ces annotations de plusieurs manières.

Vous l’aurez compris, une grande partie du travail à venir sera donc de se familiariser avec tous ces éléments (les annotations particulièrement).

Annotations

Dans la version actuelle de SpringBoot, les annotations ont une importance particulière. Il en existe un grand nombre cependant si vous maîtriser la listes des annotations ci-dessous, vous aurez une base solide pour être autonome. Nous vous conseillons donc d’étudier cette liste est classée par “thématique”.

Remarque : Il se peut que certains liens ne fonctionnent plus.

Configuration

Annotation Documentation officielle
@SpringBootApplication Regroupe @Configuration, @EnableAutoConfiguration et @ComponentScan
@Configuration Déclare une classe de configuration Spring
@ComponentScan Active la recherche automatique des composants (@Component, @Service, etc.)
@EnableWebMvc Active la configuration Spring MVC manuelle (si vous ne voulez pas de l’auto-config de Boot)
@Value Injecte une valeur issue d’une propriété (application.yml, variable d’env., etc.)

Injection de dépendances

Annotation Documentation officielle
@Bean Déclare un bean géré par Spring
@Component Indique un composant Spring générique
@Service Spécifie un composant métier
@Repository Spécifie un composant d’accès aux données (DAO / JPA)
@Autowired Injecte une dépendance automatiquement
@Qualifier Précise quel bean injecter quand plusieurs existent

Web (MVC et Rest)

Annotation Documentation officielle
@Controller Déclare une classe comme contrôleur MVC
@RestController Spécifie un contrôleur REST qui renvoie des données JSON directement
@RequestMapping Définit l’URL racine d’un contrôleur ou d’une méthode
@GetMapping Spécifie un endpoint HTTP GET
@PostMapping Spécifie un endpoint HTTP POST
@PutMapping Spécifie un endpoint HTTP PUT
@DeleteMapping Spécifie un endpoint HTTP DELETE
@RequestParam Récupère un paramètre d’URL (query string)
@PathVariable Récupère une variable d’URL (ex: /chiens/{id})
@RequestBody Désérialise le corps JSON d’une requête HTTP en objet Java
@ResponseBody Sérialise un objet Java en JSON dans la réponse HTTP

Hibernate & JPA

Annotation Documentation officielle
@Entity (JPA) Marque une classe comme entité persistante
@Id Spécifie la clé primaire d’une entité
@GeneratedValue Indique la stratégie de génération de la clé primaire
@OneToMany Relation 1-N entre deux entités
@ManyToOne Relation N-1 entre deux entités
@JoinColumn Définit la colonne de jointure entre entités
@Column Configure les détails d’une colonne (nom, longueur, nullabilité, etc.)
@Table Spécifie le nom de la table associée à l’entité

Bean Validation (Jakarta)

Annotation Documentation officielle
@Valid Déclenche la validation d’un objet lors de la réception HTTP
@NotNull Champ obligatoire
@NotBlank Chaîne non vide (pour String)
@Email Vérifie le format d’un e-mail
@Min / @Max Contraintes numériques
@Size Définit la taille minimale et maximale d’un champ

Annotations pour Lombok

Annotation Documentation officielle
@Getter / @Setter Génère automatiquement les accesseurs
@RequiredArgsConstructor Crée un constructeur avec les champs final ou @NonNull
@NoArgsConstructor / @AllArgsConstructor Génère les constructeurs sans / avec arguments
@ToString Crée une méthode toString() lisible
@Builder Implémente le pattern Builder pour instancier les objets facilement
@Slf4j Ajoute un logger log.info(), log.error(), etc…

Liens spring.io sélectionnés

webographie