Exemple de Spring MVC

Tutoriels
Spring

Bienvenue dans l’exemple Spring MVC. Il y a quelque temps dans le tutoriel Spring MVC, j’ai expliqué comment créer une application Spring MVC à l’aide de Spring Tool Suite. Mais aujourd’hui, je vais créer une application Spring MVC « hello world » de base en utilisant Maven et Eclipse.

Exemple Spring MVC

Spring MVC est basé sur l’architecture Modèle-Vue-Contrôleur. L’image ci-dessous montre l’architecture Spring MVC à un niveau élevé. La classe DispatcherServlet est la classe contrôleur frontal qui prend toutes les demandes et commence à les traiter. Nous devons la configurer dans le fichier web.xml. Son rôle est de transmettre la demande à la classe contrôleur appropriée et d’envoyer la réponse une fois que les pages de vue ont rendu la page de réponse. HomeController.java sera la seule classe contrôleur dans notre exemple d’application Spring MVC. home.jsp, user.jsp sont les pages de vue dans notre exemple d’application Spring MVC « hello world ». User.java sera la seule classe modèle que nous aurons dans notre application web exemple Spring MVC.

Exemple de projet Hello World Spring MVC dans Eclipse

L’image ci-dessous montre notre projet d’exemple Spring MVC dans Eclipse. Commençons et créons notre projet à partir de zéro.

Configuration du projet Eclipse Spring MVC

Depuis qu’il s’agit d’une application web et que nous voulons utiliser Maven pour la gestion des dépendances, tout d’abord, nous devons créer une application web dynamique, puis la convertir en projet Maven. Les images ci-dessous montrent comment faire cela et obtenir la structure de notre projet prête. Cliquez avec le bouton droit de la souris sur la fenêtre de l’explorateur de projets, puis cliquez sur « Nouveau -> Projet Web Dynamique » comme indiqué dans l’image ci-dessous. Indiquez le nom comme « spring-mvc-example » dans la page contextuelle suivante, le reste des éléments ne devrait pas nécessiter de modifications. À la page suivante, indiquez le dossier source comme « src/main/java ». Vous devrez peut-être supprimer le dossier « src » de la liste avant de l’ajouter. Ensuite, sur la page du module web, indiquez la racine de contexte de l’application comme « spring-mvc-example » et assurez-vous de cocher l’option « Générer le descripteur de déploiement web.xml ». Cliquez sur Terminer et vous aurez un nouveau projet web dynamique dans l’explorateur de projets Eclipse.

Conversion d’un projet Web dynamique en projet Maven

Nous voulons utiliser Maven pour gérer facilement nos dépendances Spring MVC. Alors convertissons notre projet web en Maven. Cliquez avec le bouton droit sur le projet et sélectionnez « Configurer -> Convertir en projet Maven ». Ensuite, fournissez les configurations pom.xml comme indiqué ci-dessous. Le squelette de notre projet d’application web Maven est prêt. Maintenant, nous pouvons commencer à apporter des modifications et à créer notre exemple d’application Spring MVC « Bonjour tout le monde ».

Ajout de dépendances Spring MVC à pom.xml

Nous devons ajouter les dépendances spring-web et spring-webmvc dans pom.xml, ainsi que les dépendances servlet-api, jsp-api et jstl. Notre fichier pom.xml final ressemblera à ceci.

<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.journaldev.spring.mvc</groupId>
	<artifactId>spring-mvc-example</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>war</packaging>
	<name>Spring MVC Example</name>
	<description>Spring MVC Hello World Example</description>

	<!-- Add Spring Web and MVC dependencies -->
	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>4.3.9.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
			<version>4.3.9.RELEASE</version>
		</dependency>
		<!-- Servlet -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>servlet-api</artifactId>
			<version>2.5</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>javax.servlet.jsp</groupId>
			<artifactId>jsp-api</artifactId>
			<version>2.1</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>jstl</artifactId>
			<version>1.2</version>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.6.1</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
				</configuration>
			</plugin>
			<plugin>
				<artifactId>maven-war-plugin</artifactId>
				<version>3.0.0</version>
				<configuration>
					<warSourceDirectory>WebContent</warSourceDirectory>
				</configuration>
			</plugin>
		</plugins>
		<finalName>${project.artifactId}</finalName> <!-- added to remove Version from WAR file -->
	</build>
</project>

Remarquez la configuration finalName dans la construction, afin que le nom de notre fichier WAR n’inclue pas les détails de version. Lorsque le projet est construit par Eclipse, vous remarquerez que tous les jars apparaissent dans la section des dépendances Maven.

Spring MVC DispatcherServlet en tant que contrôleur frontal

Nous devons ajouter le framework Spring MVC à notre application web, pour cela nous devons configurer DispatcherServlet dans web.xml comme indiqué ci-dessous.

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns="https://java.sun.com/xml/ns/javaee" xsi:schemaLocation="https://java.sun.com/xml/ns/javaee https://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
  <display-name>spring-mvc-example</display-name>

	<!-- Add Spring MVC DispatcherServlet as front controller -->
	<servlet>
        <servlet-name>spring</servlet-name>
        <servlet-class>
                org.springframework.web.servlet.DispatcherServlet
        </servlet-class>
        <init-param>
       		<param-name>contextConfigLocation</param-name>
       		<param-value>/WEB-INF/spring-servlet.xml</param-value>
    		</init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
 
    <servlet-mapping>
        <servlet-name>spring</servlet-name>
        <url-pattern>/</url-pattern> 
    </servlet-mapping>
    
 </web-app>

La paramètre d’initialisation contextConfigLocation est utilisé pour fournir l’emplacement du fichier de configuration des beans Spring.

Fichier de configuration de l’exemple de bean Spring MVC

La prochaine étape consiste à créer le fichier de configuration du bean Spring spring-servlet.xml comme indiqué ci-dessous.

<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="https://www.springframework.org/schema/mvc"
	xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns:beans="https://www.springframework.org/schema/beans"
	xmlns:context="https://www.springframework.org/schema/context"
	xsi:schemaLocation="https://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd
		https://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
		https://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

	<!-- DispatcherServlet Context: defines this servlet's request-processing 
		infrastructure -->

	<!-- Enables the Spring MVC @Controller programming model -->
	<annotation-driven />
	<context:component-scan base-package="com.journaldev.spring" />

	<!-- Resolves views selected for rendering by @Controllers to .jsp resources 
		in the /WEB-INF/views directory -->
	<beans:bean
		class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<beans:property name="prefix" value="/WEB-INF/views/" />
		<beans:property name="suffix" value=".jsp" />
	</beans:bean>

</beans:beans>

Il existe trois configurations importantes.

  1. annotation-driven indique à DispatcherServlet de rechercher les classes de contrôleur utilisant l’annotation @Controller .
  2. context:component-scan indique à DispatcherServlet où rechercher les classes de contrôleur.
  3. InternalResourceViewResolver configuration du bean pour spécifier l’emplacement des pages de vue et le suffixe utilisé. Les méthodes de la classe du contrôleur renvoient le nom de la page de vue, puis le suffixe est ajouté pour déterminer la page de vue à utiliser pour le rendu de la réponse.

Classe de contrôleur Spring MVC

Nous avons une seule classe de contrôleur pour répondre à deux URI – « / « pour la page d’accueil et « /user » pour la page utilisateur.

package com.journaldev.spring.controller;

import java.text.DateFormat;
import java.util.Date;
import java.util.Locale;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import com.journaldev.spring.model.User;

@Controller
public class HomeController {

	/**
	 * Simply selects the home view to render by returning its name.
	 */
	@RequestMapping(value = "/", method = RequestMethod.GET)
	public String home(Locale locale, Model model) {
		System.out.println("Home Page Requested, locale = " + locale);
		Date date = new Date();
		DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG, locale);

		String formattedDate = dateFormat.format(date);

		model.addAttribute("serverTime", formattedDate);

		return "home";
	}

	@RequestMapping(value = "/user", method = RequestMethod.POST)
	public String user(@Validated User user, Model model) {
		System.out.println("User Page Requested");
		model.addAttribute("userName", user.getUserName());
		return "user";
	}
}

Remarquez que pour simplifier, je n’ai pas utilisé de framework de journalisation tel que log4j.

Classe de modèle Spring MVC

Nous avons une classe de modèle simple avec une seule variable et ses méthodes getter-setter. C’est une classe POJO simple.

package com.journaldev.spring.model;

public class User {
	private String userName;

	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}
}

Pages de vue Spring MVC

Nous avons deux pages de vue telles que définies ci-dessous. home.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
	pageEncoding="UTF-8"%>
<%@ taglib uri="https://java.sun.com/jsp/jstl/core" prefix="c"%>
<%@ page session="false"%>
<html>
<head>
<title>Home</title>
</head>
<body>
	<h1>Hello world!</h1>

	<P>The time on the server is ${serverTime}.</p>

	<form action="user" method="post">
		<input type="text" name="userName"><br> <input
			type="submit" value="Login">
	</form>
</body>
</html>

user.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "https://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>User Home Page</title>
</head>
<body>
<h3>Hi ${userName}</h3>
</body>
</html>

Remarquez que Spring MVC se charge de mapper les variables de formulaire aux variables de classe de modèle, c’est pourquoi nous avons le même nom de variable dans les deux endroits. C’est tout, notre projet d’exemple Spring MVC est prêt à être déployé et testé.

Déploiement du projet Eclipse Spring MVC

Nous pouvons utiliser l’option d’exportation Eclipse en tant que fichier WAR pour le déployer directement dans le répertoire webapps d’un serveur tomcat en cours d’exécution. Cependant, vous pouvez également utiliser la ligne de commande pour construire le projet, puis le copier dans le répertoire de déploiement de votre conteneur de servlet préféré.

Test d’exemple Spring MVC

Une fois que le projet Spring MVC est déployé, vous pouvez accéder à la page d’accueil à l’adresse https://localhost:8080/spring-mvc-example/. Modifiez le port et le context-root de Tomcat en conséquence. C’est tout pour l’exemple de Spring MVC, j’ai essayé de le rendre aussi simple que possible. Mais si vous rencontrez des problèmes, veuillez me le faire savoir dans les commentaires et je tenterai de vous aider. Vous pouvez télécharger le projet final de l’exemple Spring MVC via le lien suivant.

Télécharger le projet d’exemple Spring MVC

Références : Page officielle

Source:
https://www.digitalocean.com/community/tutorials/spring-mvc-example