Que l'on soit en train d'apprendre le framework, ou que l'on ait besoin de commencer un nouveau projet, la démarche est la même, et elle est très simple !
Spring Initializr
On va éviter de commencer un projet en copiant un ancien sur lequel on aurait déjà travaillé. Repartir de zéro nous permettra de commencer sur des bases propres, avec les dernières versions des librairies et composants. Spring nous propose un outil pour packager l'initialisation du projet, avec tous les modules dont on pourrait avoir besoin : Spring Initializr. Cela se passe sur start.spring.io
On peut laisser les options de gauche par défaut. J'ai personnellement une préférence pour Maven, et le choix de Java 21.
A droite, on va choisir les composants qui correspondent à nos besoin. Tous les composants Spring s'y trouvent, faites votre marché ! On va rester simple et choisir
- Spring Web, pour un test simple
- Spring Data JPA, pour utiliser une BDD
- H2 Database, une BDD in memory
On clique en bas sur Generate, ça télécharge un zip, à dé-zipper et ouvrir en tant que projet dans votre IDE préféré. Pour moi, c'est IntelliJ
Deux éléments importants ont été générés
- Le fichiers des dépendances, ici le pom.xml pour maven
- La méthode main contenue dans la classe DemoApplication
Cela suffit pour démarrer l'application !
Ajoutons une resource REST
Créons un package controller et une classe HelloResource à l'intérieur.
package com.example.demo.controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class HelloResource {
@GetMapping("/hello")
public String hello(String param){
return "Hello " + param;
}
}
On peut démarrer l'application et appeler l'URL http://localhost:8080/hello?param=World
Hello WorldAjoutons une base de données
Créons un package domain et une Entité Hello
package com.example.demo.domain;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
@Entity
public class Hello {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
private String param;
public Hello(){}
public Hello(String param){
this.param = param;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getParam() {
return param;
}
public void setParam(String param){
this.param = param;
}
}
Et son Repository
package com.example.demo.domain;
import org.springframework.data.jpa.repository.JpaRepository;
public interface HelloRepository extends JpaRepository<Hello, Long> {
}
Dans le package controller, on crée le record DTO associé
package com.example.demo.controller;
public record HelloDto(Long id, String param) {
}
On peut maintenant injecter le Repository dans la Ressource et ajouter une méthode de création et de lecture par id
package com.example.demo.controller;
import com.example.demo.domain.Hello;
import com.example.demo.domain.HelloRepository;
import org.springframework.web.bind.annotation.*;
@RestController
public class HelloResource {
private final HelloRepository helloRepository;
public HelloResource(HelloRepository helloRepository) {
this.helloRepository = helloRepository;
}
@GetMapping("/hello")
public String hello(String param){
return "Hello " + param;
}
@PostMapping("/hello")
public HelloDto create(@RequestBody HelloDto helloDto){
Hello hello = helloRepository.save(new Hello(helloDto.param()));
return new HelloDto(hello.getId(), hello.getParam());
}
@GetMapping("/hello/{id}")
public HelloDto get(@PathVariable Long id){
Hello hello = helloRepository.findById(id).orElseThrow();
return new HelloDto(hello.getId(), hello.getParam());
}
}
Relançons l'application. On peut maintenant créer un objet Hello sur l'URL http://localhost:8080/hello en POST avec le body
{
"param": "World !"
}Réponse :
{
"id": 1,
"param": "World !"
}On peut alors requêter l'URL http://localhost:8080/hello/1
Réponse :
{
"id": 1,
"param": "World !"
}Et ensuite ?
Il est très simple d'ajouter des composants Spring que l'on n'aurait pas ajoutés à l'initialisation en important les dépendances sur les starters. Un starter est un package tout configuré d'un composant Spring. Par exemple, on peut ajouter Spring Security avec Maven
<dependencies>
<!-- ... other dependency elements ... -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
</dependencies>Cela ajoutera Spring Security avec son auto-configuration et toutes ses dépendances dans les bonnes versions.
