• 8 heures
  • Moyenne

Ce cours est visible gratuitement en ligne.

course.header.alt.is_video

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 27/09/2021

Observez la structure minimale

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

L’étape 2 correspond au fait de structurer et configurer notre projet.

Mais ça ne suffit pas, d'avoir une structure minimale ? 🤔

La structure minimale nous offre déjà une structure ! C’est vrai, mais ce n’est pas suffisant.

Dans ce chapitre, je vous propose de découvrir plus en détail cette structure minimale, et ainsi on comprendra ce qu’il nous reste à faire !

“Here we go”

Explorez la structure minimale

Voici le projet à travers la vue Package Explorer de STS. Qu'observez-vous? Comment les sources sont-elles organisées ?

L’arborescence du projet est affichée, à savoir les répertoires, les fichiers, les packages.
Arborescence du projet via la vue Package Explorer

Voici quelques points à noter :

  • Nous retrouvons les fichiers liés à Maven (pom.xml, mvnw et mvnw.cmd).

  • Nos sources sont organisées suivant le schéma standard :

    • src/main/java : contient les packages et les classes Java ;

    • src/main/resources : contient les fichiers ressources, tels que les fichiers de propriétés ou des templates (HTML, par exemple) ;

    • src/test/java : contient les classes Java de test.

  • Comme tout projet Java/Maven, on retrouve également la JRE et les Maven Dependencies.

J’attire également votre attention sur le fait que cette structure minimale ne contient pas que des répertoires et des packages : il y a aussi deux classes Java et un fichier Propriétés.

Le fichier de propriétés “application.properties” est créé par défaut, mais il est vide ; j’y reviendrai plus tard, promis !

Pour ce qui de la classe HelloWorldApplicationTests.java, je ne souhaite pas m’y arrêter non plus à cette étape ; sachez juste pour le moment qu’elle vérifie que le contexte Spring se lance bien comme attendu.

Maintenant, parlons de HelloWorldApplication.java, qui est la classe principale de votre projet. On y retrouve 2 choses importantes :

  1. La méthode main dont je ne vous ferai pas l’offense de vous expliquer son rôle en Java !

  2. L’annotation @SpringBootApplication qui est critique !

S T O P ! Annotation, tu dis ?

Vous avez raison, je vais vous expliquer ce qu’est une annotation, et son utilité au sein de Spring.

Découvrez le rôle des annotations et leurs avantages

Nous avons vu ensemble que Spring Framework fournit l’IoC container, dans la partie 1 du cours. L’IoC container va instancier pour vous des classes, puis si nécessaire les injecter dans d’autres instances de classe. Pour qu’une classe soit manipulée par l’IoC container, il est nécessaire de l’indiquer explicitement à Spring. Comment ?

La première solution est l’utilisation de fichiers XML au sein desquels on décrit les classes que Spring doit gérer ; voici un exemple des plus simples :

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN"
"http://www.springframework.org/dtd/spring-beans-2.0.dtd">
<beans>
<bean id="myBean" class="com.openclassrooms.BeanImpl"/>
</beans>

La classe com.openclassrooms.BeanImpl (qui a été créée préalablement, évidemment) sera ainsi prise en compte par l’IoC container.

La seconde solution est l’utilisation des annotations.

Une annotation, c’est-à-dire @[nom de l’annotation], peut être ajoutée à une classe, une méthode, un attribut. L’annotation influe sur le comportement du programme car elle fournit des métadonnées lors de la compilation ; ces mêmes métadonnées seront utilisées lors de l’exécution.

Depuis la version 2.5 de Spring, de nombreuses annotations sont fournies, dont le but est de :

  1. Permettre à l’IoC container d’utiliser nos classes.

  2. Influer sur le comportement de Spring.

Voici quelques exemples d’annotations Spring :

  • @Component

  • @Autowired

  • @Qualifier

Si on reprend l’exemple précédent, voici la correspondance en annotation :

package com.openclassrooms;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
@Component
@Qualifier(“myBean”)
public class BeanImpl {
// TO DO
}

L’annotation @Component permet de déclarer la classe BeanImpl auprès de Spring, comme étant un bean à avoir dans l’IoC container.

L’annotation @Qualifier permet de donner un nom à ce bean, en l'occurrence “myBean” (si cette annotation n’est pas définie, le nom par défaut est le nom de la classe).

Qu’en dites-vous ? C’est plus sympa, non ? Nul besoin de manipuler du XML, tout se passe dans le Java !

Utilisez l’annotation @SpringBootApplication

Revenons maintenant à nos moutons ! Ou plutôt à l’annotation @SpringBootApplication. À quoi sert-elle ?

Comme je vous l’ai expliqué, elle va permettre à l’IoC container de manipuler la classe HelloWorldApplication.java.

Bien ! Mais encore ?

Elle permettra également d’influer sur le comportement de Spring.

Ah ! C’est intéressant, c’est-à-dire ?

@SpringBootApplication est un composé de 3 autres annotations :

  1. @SpringBootConfiguration : la classe sera utilisée comme une classe de configuration (on reviendra sur cette notion plus tard).

  2. @EnableAutoConfiguration : active la fameuse fonctionnalité d’autoconfiguration de Spring Boot, que je vous ai tant vantée.

  3. @ComponentScan : active le “scanning” de classes dans le package de la classe et dans ses sous-packages. Sans cette annotation, l’IoC container ne tiendra pas compte de vos classes, même si vous avez ajouté une annotation sur celles-ci. 

OK, on y voit plus clair maintenant ! En résumé, cette classe, c’est ce qui déclenche toute la mécanique interne de Spring Boot et des composants Spring associés. Et tout ça en moins de 15 lignes de code. 

Nous voilà au bout de l’analyse de la structure minimale d’un projet Spring Boot, et quelle conclusion tirons-nous ?

Oui, nous avons une base, c’est vrai, mais il y a des trous !

  1. Au sein de src/main/java, nous avons un seul package. Et vu qu’un développeur apprend à regrouper les classes par sous-ensemble, nous allons devoir créer des sous-packages pour nos différentes classes à venir.

  2. Le fichier applications.properties est vide ! Le pauvre, il doit se sentir bien inutile... Rassurez-vous, on va vite lui donner un rôle à jouer !

Remplissons ces trous pour pouvoir aller de l’avant !

En résumé

  • La structure minimale n’est pas suffisante, il faut l’enrichir.

  • Les annotations sont un pilier au sein de Spring Boot pour tirer profit de l’IoC container.

  • L’annotation @SpringBootApplication est la concaténation de plusieurs annotations, et son objectif est de déclencher toute la mécanique interne de Spring.

Vous savez désormais pourquoi il est important de structurer votre projet. Mais concrètement, comment s'y prendre ? C'est que nous allons voir dans le prochain chapitre.

Exemple de certificat de réussite
Exemple de certificat de réussite