Démarrer avec Spring Boot

Notions théoriques

Qu'est-ce que Spring Boot ?

Spring Boot est un framework Java qui simplifie la création d'applications web. Il est basé sur Spring Framework, mais il ajoute une couche d'auto-configuration qui évite d'écrire des dizaines de fichiers XML de configuration.

Comparaison avec Symfony

Comme Symfony en PHP, Spring Boot suit le principe Convention over Configuration : il fait des choix raisonnables par défaut pour que vous n'ayez à configurer que ce qui s'écarte de la norme.

Symfony (PHP)	Spring Boot (Java)
symfony server:start	mvn spring-boot:run
.env	application.properties
Composer	Maven (pom.xml)
Twig	Thymeleaf
Doctrine	Spring Data JPA
composer require	dépendances dans pom.xml

Spring Initializr

Spring Initializr (start.spring.io) est le générateur officiel de projets Spring Boot, l'équivalent de symfony new monprojet.

Pour créer le projet MonBlog, choisir :

• Project : Maven
• Language : Java
• Spring Boot : 3.x (la dernière stable)
• Java : 21
• Dépendances à ajouter :
  • Spring Web — pour les contrôleurs HTTP
  • Thymeleaf — pour les vues HTML
  • Spring Data JPA — pour la persistance
  • MySQL Driver — pour la connexion MySQL
  • Validation — pour les validations de formulaires
  • Flyway Migration — pour les migrations de base de données

Structure du projet généré

MonBlog/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── org/joliciel/monblog/
│   │   │       └── MonBlogApplication.java   ← point d'entrée
│   │   └── resources/
│   │       ├── application.properties        ← configuration (comme .env)
│   │       ├── static/                       ← CSS, JS, images
│   │       └── templates/                    ← vues Thymeleaf (comme templates/ Symfony)
│   └── test/
│       └── java/
│           └── org/joliciel/monblog/
│               └── MonBlogApplicationTests.java
└── pom.xml                                   ← dépendances Maven (comme composer.json)

L'annotation @SpringBootApplication

package org.joliciel.monblog;

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

@SpringBootApplication
public class MonBlogApplication {

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

@SpringBootApplication regroupe trois annotations en une :

• @SpringBootConfiguration — déclare la classe comme source de configuration
• @EnableAutoConfiguration — active la configuration automatique
• @ComponentScan — scanne automatiquement les classes annotées du package

info

Spring Boot démarre un serveur Tomcat embarqué sur le port 8080 par défaut. Vous n'avez pas besoin d'installer Tomcat séparément.

Le fichier application.properties

Ce fichier, situé dans src/main/resources/, configure l'application. C'est l'équivalent du fichier .env de Symfony.

# Nom de l'application
spring.application.name=MonBlog

# Port du serveur (8080 par défaut)
server.port=8080

# Configuration base de données (à compléter séance 505)
spring.datasource.url=jdbc:mysql://localhost:3306/monblog
spring.datasource.username=root
spring.datasource.password=

Lancer l'application

# Depuis la racine du projet Maven
mvn spring-boot:run

Puis ouvrir http://localhost:8080 dans le navigateur.

astuce

Dans IntelliJ IDEA, vous pouvez aussi cliquer sur le bouton vert Run à côté de la méthode main() dans MonBlogApplication.java.

Le fichier pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
             https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <!-- Parent Spring Boot : gère les versions de toutes les dépendances -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.3.0</version>
    </parent>

    <groupId>org.joliciel</groupId>
    <artifactId>monblog</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>MonBlog</name>

    <properties>
        <java.version>21</java.version>
    </properties>

    <dependencies>
        <!-- Spring Web (contrôleurs HTTP) -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- Thymeleaf (vues HTML) -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <!-- Spring Data JPA (persistance) -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <!-- MySQL Driver -->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!-- Bean Validation -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>
        <!-- Flyway migrations -->
        <dependency>
            <groupId>org.flywaydb</groupId>
            <artifactId>flyway-mysql</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

attention

Avec spring-boot-starter-parent, vous n'avez pas besoin de préciser les numéros de version pour les dépendances Spring Boot officielles. Spring Boot gère les compatibilités entre ses composants.

Exemple pratique

Voici le fichier MonBlogApplication.java généré, avec commentaires pédagogiques :

package org.joliciel.monblog;

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

// Cette annotation active toute la magie de Spring Boot :
// auto-configuration, scan des composants, etc.
@SpringBootApplication
public class MonBlogApplication {

    // Point d'entrée Java standard
    public static void main(String[] args) {
        // Démarre le serveur Tomcat embarqué et l'application Spring
        SpringApplication.run(MonBlogApplication.class, args);
    }
}

Après mvn spring-boot:run, vous devriez voir dans la console :

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
...
Started MonBlogApplication in 2.345 seconds (process running for 2.678)

Une erreur de connexion MySQL est normale à ce stade si la base de données n'est pas encore configurée.

Test de mémorisation/compréhension

Quel site web permet de générer un projet Spring Boot ?

start.spring.io

spring.io/start

initializr.spring.io

create.spring.io

Quelle commande Maven lance l'application Spring Boot ?

mvn run

mvn spring-boot:run

mvn start

mvn boot:run

Sur quel port Spring Boot démarre-t-il par défaut ?

80

3000

8080

8000

Quel fichier de configuration Spring Boot est l'équivalent du .env de Symfony ?

pom.xml

application.properties

spring.config

settings.xml

Quelle annotation regroupe @SpringBootConfiguration, @EnableAutoConfiguration et @ComponentScan ?

@SpringApplication

@SpringBootApp

@SpringBootApplication

@EnableSpring

Quel outil Java gère les dépendances, comme Composer en PHP ?

Gradle uniquement

Maven (pom.xml)

npm

Ant

TP pour réfléchir et résoudre des problèmes

Dans ce TP, vous allez créer le projet MonBlog depuis Spring Initializr et vérifier qu'il démarre correctement.

Étape 1 — Générer le projet sur start.spring.io

Rendez-vous sur https://start.spring.io et configurez le projet avec les paramètres suivants :

• Project : Maven
• Language : Java
• Spring Boot : 3.3.x
• Group : org.joliciel
• Artifact : monblog
• Java : 21
• Dépendances : Spring Web, Thymeleaf, Spring Data JPA, MySQL Driver, Validation, Flyway Migration

Téléchargez le ZIP, décompressez-le, et ouvrez le dossier dans IntelliJ IDEA.

Bonne pratique - Toujours utiliser Java 21 LTS

Java 21 est une version LTS (Long Term Support), c'est-à-dire qu'elle bénéficiera de mises à jour de sécurité pendant plusieurs années. En production, on utilise toujours une version LTS. Évitez d'utiliser une version intermédiaire (20, 22...) pour un projet professionnel.

Étape 2 — Vérifier la structure du projet

Après avoir ouvert le projet dans IntelliJ, vérifiez que le fichier principal existe bien à l'emplacement attendu.

Bonne pratique - Nommage des packages

Le nom du package suit la convention domaine.reversed.nomprojet. Ici org.joliciel.monblog correspond à joliciel.org (domaine) + monblog (projet). Tous les packages du projet sont des sous-packages de ce package racine.

Étape 3 — Configurer application.properties

Ouvrez src/main/resources/application.properties et configurez le nom de l'application.

Bonne pratique - Commenter application.properties

Utilisez des commentaires (ligne commençant par #) pour organiser votre fichier application.properties en sections : base de données, serveur, JPA, etc. Cela facilite la maintenance quand le fichier grossit.

📌 Une solution

Vous devez être connecté pour voir le contenu.

Email : Mot de passe :