Comment créer une application Spring MVC en utilisant Maven dans IntelliJ IDEA

Introduction

Ce tutoriel vous guidera tout au long du processus de création d'une application Spring MVC en utilisant Maven dans l'environnement de développement IntelliJ IDEA. Nous aborderons les étapes essentielles, depuis la configuration de l'environnement de développement jusqu'à l'utilisation de Docker pour la conteneurisation, afin de vous aider à commencer à développer des applications web modernes.

Skills Graph

Introduction à Spring MVC

Spring MVC est un framework d'applications web populaire faisant partie de l'écosystème Spring. Il suit le modèle architectural Modèle-Vue-Contrôleur (MVC - Model-View-Controller), qui sépare la logique de l'application en trois composants interconnectés : le modèle, la vue et le contrôleur.

Qu'est-ce que Spring MVC?

Spring MVC est un framework d'applications web basé sur Java qui offre un modèle de programmation et de configuration complet pour la création d'applications web. Il simplifie le développement d'applications web en gérant les tâches et les modèles courants associés au développement web, tels que la gestion des requêtes, le rendu des vues et la liaison de données.

Composants clés de Spring MVC

Les principaux composants du framework Spring MVC sont :

1. Modèle (Model): Le modèle représente les données et la logique métier de l'application. Il est responsable de la gestion des données et de l'état de l'application.

2. Vue (View): La vue est responsable du rendu de l'interface utilisateur de l'application. Elle est chargée de présenter les données à l'utilisateur et de gérer les interactions de l'utilisateur.

3. Contrôleur (Controller): Le contrôleur est l'intermédiaire entre le modèle et la vue. Il reçoit les requêtes de l'utilisateur, traite les données et les transmet à la vue pour le rendu.

Avantages de l'utilisation de Spring MVC

Certains des principaux avantages de l'utilisation de Spring MVC sont les suivants :

1. Séparation des préoccupations: Le modèle MVC favorise une séparation claire des préoccupations, rendant le code plus facilement maintenable et testable.
2. Flexibilité: Spring MVC offre une architecture flexible et configurable, permettant aux développeurs de personnaliser le framework pour répondre à leurs besoins spécifiques.
3. Évolutivité: Spring MVC est conçu pour être évolutif, ce qui le rend adapté à la création d'applications web à grande échelle.
4. Intégration avec d'autres modules Spring: Spring MVC s'intègre parfaitement avec d'autres modules Spring, tels que Spring Security, Spring Data et Spring Boot, offrant une expérience de développement complète et cohérente.

En comprenant les concepts et les composants de base de Spring MVC, vous serez mieux équipé pour créer des applications web robustes et évolutives en utilisant ce puissant framework.

Configuration de l'environnement de développement avec IntelliJ IDEA

Pour commencer à développer une application Spring MVC en utilisant Maven dans IntelliJ IDEA, vous devrez configurer votre environnement de développement. Voici comment vous pouvez le faire :

Installation du Java Development Kit (JDK)

Tout d'abord, vous devrez installer le Java Development Kit (JDK) sur votre système Ubuntu 22.04. Vous pouvez le faire en exécutant les commandes suivantes dans votre terminal :

sudo apt update
sudo apt install openjdk-11-jdk

Vérifiez l'installation en vérifiant la version de Java :

java -version

Installation d'IntelliJ IDEA

Ensuite, vous devrez installer IntelliJ IDEA, un environnement de développement intégré (IDE - Integrated Development Environment) populaire pour le développement Java. Vous pouvez télécharger la dernière version d'IntelliJ IDEA sur le site officiel : https://www.jetbrains.com/idea/download/

Une fois le téléchargement terminé, extrayez le fichier ZIP et exécutez la commande suivante pour démarrer l'IDE :

./idea.sh

Configuration du projet Spring MVC

1. Ouvrez IntelliJ IDEA et créez un nouveau projet en sélectionnant "Create New Project" à partir de l'écran d'accueil.
2. Choisissez "Maven" comme type de projet, puis cliquez sur "Next".
3. Indiquez un nom et un emplacement pour le projet, puis cliquez sur "Finish".
4. Dans la structure du projet, cliquez avec le bouton droit sur le dossier "src/main/java" et sélectionnez "New" > "Package". Créez un package pour votre application, par exemple "com.labex.springmvc".
5. Cliquez avec le bouton droit sur le package et sélectionnez "New" > "Java Class". Créez une nouvelle classe pour votre contrôleur Spring MVC, par exemple "HelloController.java".

package com.labex.springmvc;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class HelloController {

    @GetMapping("/")
    public String hello(Model model) {
        model.addAttribute("message", "Hello from LabEx Spring MVC!");
        return "hello";
    }
}

6. Créez un nouveau dossier appelé "templates" sous le répertoire "src/main/resources". C'est là que vous placerez vos modèles de vues Spring MVC.
7. À l'intérieur du dossier "templates", créez un nouveau fichier appelé "hello.html" et ajoutez le contenu suivant :

<!doctype html>
<html xmlns:th="http://www.thymeleaf.org">
  <head>
    <title>Hello LabEx</title>
  </head>
  <body>
    <h1 th:text="${message}"></h1>
  </body>
</html>

Vous avez maintenant configuré l'environnement de développement de base pour votre application Spring MVC en utilisant IntelliJ IDEA et Maven. Vous pouvez passer à l'étape suivante, qui consiste à développer l'application Spring MVC.

Création d'une application Spring MVC avec Maven

Maintenant que vous avez configuré votre environnement de développement, commençons à créer une application Spring MVC en utilisant Maven.

Configuration du projet Maven

1. Ouvrez le fichier pom.xml de votre projet IntelliJ IDEA.
2. Ajoutez les dépendances nécessaires pour Spring MVC et Thymeleaf (le moteur de modèle de vue) en ajoutant le code suivant à l'intérieur de la section <dependencies> :

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>2.7.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
        <version>2.7.0</version>
    </dependency>
</dependencies>

3. Ajoutez le plugin Maven Spring Boot à la section <plugins> du fichier pom.xml :

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

Implémentation du contrôleur Spring MVC

Dans le fichier HelloController.java, vous pouvez définir la logique du contrôleur qui gérera les requêtes entrantes et renverra la vue appropriée :

package com.labex.springmvc;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class HelloController {

    @GetMapping("/")
    public String hello(Model model) {
        model.addAttribute("message", "Hello from LabEx Spring MVC!");
        return "hello";
    }
}

Configuration de l'application Spring MVC

Pour configurer l'application Spring MVC, vous devrez créer un fichier SpringMvcApplication.java dans le package racine (par exemple com.labex.springmvc) avec le contenu suivant :

package com.labex.springmvc;

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

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

Exécution de l'application Spring MVC

1. Dans le terminal d'IntelliJ IDEA, accédez au répertoire de votre projet et exécutez la commande suivante pour construire et démarrer l'application :

mvn spring-boot:run

2. Une fois l'application en cours d'exécution, ouvrez votre navigateur web et accédez à http://localhost:0000/. Vous devriez voir le message "Hello from LabEx Spring MVC!" affiché sur la page.

Félicitations ! Vous avez créé avec succès une application Spring MVC en utilisant Maven dans IntelliJ IDEA. Vous pouvez maintenant continuer à améliorer votre application en ajoutant plus de fonctionnalités, telles que des contrôleurs, des services et des vues.

Résumé

Dans ce tutoriel, vous avez appris à créer une application Spring MVC en utilisant Maven dans IntelliJ IDEA, ainsi qu'à utiliser Docker pour la conteneurisation. En suivant les étapes décrites, vous devriez maintenant être en mesure de configurer votre environnement de développement, de créer un projet Spring MVC et de packager votre application en tant que conteneur Docker pour le déploiement. Cette connaissance sera précieuse au fur et à mesure que vous continuerez à explorer et à développer des applications web avec Spring MVC et Docker.