Dans ce document, tu trouveras une définitions des termes suivants :
Spring est un framework permettant de créer des applications web, généralement destinées aux entreprises.
Il est possible de créer une application frontend (avec le moteur de template Thymeleaf par exemple), mais l'utilisation la plus commune de Spring est la réalisation d'un backend sécurisé et d'une API permettant de s'interfacer avec un frontend.
Spring est basé sur une approche modulaire, où il faut sélectionner et configurer un ensemble de dépendances à ajouter à son projet (par exemple Spring Security pour l'authentification).
Le module principal gère l'injection de dépendance, la traduction, les ressources (par exemple les images, polices de caractères)...
Un des principes fondamentaux de Spring est l'utilisation de l'injection de dépendance : plutôt que d'ajouter du code pour créer toi même les appels des fonctionnalités dont tu aurais besoin, tu vas demander à Spring de t'en fournir des instances grâce à l'injection de dépendance.
Imaginons que tu aies besoin de récupérer la liste de tes utilisateurs, qui proviennent de la base de données. Même si tu ne sais pas ce qu'est un repository, dis-toi que c'est la fonctionnalité qui te permet d'y accéder.
Tu vas demander à Spring de te fournir ce repository à l'aide d'une injection de dépendance (pas d'inquiétude si ça te paraît étrange, nous verrons celà plus tard).
@RestController
public class UserController {
// the repository you need
private final UserRepository repository;
// the bean injected by Spring
public UserController(UserRepository repositoryInjected) {
this.repository = repositoryInjected;
}
}Si tu te passionnes pour l'injection de dépendance, sache que c'est l'application du principe d'inversion de contrôle. Tu pourras trouver plus d'infos en ressource.
En travaillant avec Spring, tu vas souvent voir le terme de bean. La définition que tu trouveras sur internet te sembleras un peu mystique, je vais essayer de t'expliquer ça simplement :
Un bean est une instance d'une classe qui peut être injectée par dépendance.
Pour qu'une classe puisse être un bean, il faut :
- qu'elle possède un constructeur vide
- qu'elle possède des propriétés privées et des getters et setters
- qu'elle soit
Serializable: qu'elle puisse être transformée en "flux de données" que Spring pourra faire persister (par exemple le sauver dans un fichier JSON ou une base de données)
Spring permet l'utilisation d'annotation pour faciliter la configuration de ton projet, ainsi que l'injection de dépendance des beans de ton projet.
Une annotation va commencer par un @ :
// here Spring boot knows that UserRepository is a bean
@Repository
public class UserRepository {
// ...
}Certaines annotations vont permettre de créer des configurations, d'autre annotations vont préciser qu'un bean peut être instancié à partir de la classe, par exemple :
@Component: c'est une annotation de base qui indique que la classe sera automatiquement détectée par Spring@Service: c'est une extension de@Componentqui indique que la classe sera utilisée comme un service (qui contiendrait des méthodes pour traiter ou valider des données, par exemple)@Repository: c'est une extension de@Componentqui indique que la classe sera utilisé comme un repository (qui permettrait de récupérer, modifier ou supprimer des données d'une base de données, par exemple)
Nous avons précédemment abordé Spring, mais c'est en fait avec Spring Boot que nous allons travailler.
Spring Boot est un module de Spring, qui facilite la création d'un projet, en contenant du code et des configurations par défaut.
Il contient aussi un serveur web préconfiguré (Tomcat), qui va te permettre d'exécuter l'application web.
Afin d'initialiser un projet Spring Boot rapidement, il existe le site Spring Initializr.
Il te permet d'effectuer les choix suivants :
- le gestionnaire de dépendance du projet (nous allons utiliser Maven)
- le langage du projet (nous allons utiliser Java)
- la version de Spring Boot (la version sélectionnée par défaut sera à préférer)
- le packaging (tu peux laisser jar sélectionné)
- la version de Java (privilégier la version LTS courante)
- les dépendances (tu les découvriras plus tard)
- et les métadonnées du projet :
- Group : généralement lié au site de ton entreprise, de la forme extension.nom (ex: com.company-name)
- Artifact : l'identifiant du projet (ex: my-project)
- Name : le nom du projet (ex: My Awesome Project)
- Description : la... description du projet ! Oui je sais, c'est surprenant
- Package name : il est composé du
groupet de l'artifact, tu n'as pas à le personnaliser
Si tu préfères les lignes de commandes, tu peux aussi faire la même chose à partir de ton terminal, avec Spring Boot CLI.
Maven est un gestionnaire de dépendance qui va te permettre plusieurs choses, entre-autres :
- de gérer (ajouter, modifier, supprimer) des dépendances à ton projet
- d'exécuter le projet en local sur ta machine
- de créer un
builddu projet, que tu pourras déployer - de lancer des tests
Afin d'utiliser Maven dans ton projet, tu auras deux possibilité :
- l'installer sur ta machine, puis le lancer avec
mvn - ou plus simplement, utiliser la version contenue dans ton projet créé par Spring Intializr, puis le lancer avec
./mvnw
Une fois ton projet créé sur Spring Intializr puis décompressé, tu peux te diriger dans le dossier de se dernier via ton terminal, puis entrer la commande :
./mvnw spring-boot:run- Initialise un projet sur Spring Intializr, sans ajouter de dépendances, en sélectionnant Maven et Java dans sa version LTS actuelle
- Tu peux mettre les métadonnées de ton choix
- Démarre le projet avec Maven, s'il y a écrit BUILD SUCCESS, c'est gagné !