Spring MVC教程

Spring MVC是一个Java框架，用于构建Web应用程序。它遵循Model-View-Controller设计模式。它实现了核心Spring框架的所有基本功能，例如控制反转，依赖注入。

Spring MVC通过 DispatcherServlet 提供了一种优雅的解决方案，可以在Spring框架中使用MVC。在这里， DispatcherServlet 是一个类，用于接收传入的请求并将其映射到正确的资源，例如控制器，模型和视图。

Spring Web Model-View-Controller

Model-模型包含应用程序的数据。数据可以是单个对象或对象的集合。 Controller-控制器包含应用程序的业务逻辑。在这里，@ Controller批注用于将类标记为控制器。 View-视图以特定格式表示所提供的信息。通常，JSP + JSTL用于创建视图页面。尽管spring还支持其他视图技术，例如Apache Velocity，Thymeleaf和FreeMarker。 Front Controller-在Spring Web MVC中，DispatcherServlet类用作前端控制器。它负责管理Spring MVC应用程序的流程。

了解Spring Web MVC的流程

如图所示，所有传入的请求都被充当前端控制器的DispatcherServlet拦截。 DispatcherServlet从XML文件获取处理程序映射的条目，并将请求转发给控制器。 Le contrôleur retourne l'objet ModelAndView. DispatcherServlet vérifie les entrées du résolveur de vue dans le fichier XML et appelle le composant de vue spécifié.

Avantages du cadre Spring MVC

Voyons quelques avantages du cadre Spring MVC : -

Séparation des rôles-Spring MVC sépare chaque rôle, où des objets spécialisés peuvent réaliser les objets modèle, le contrôleur, les objets commande, le résolveur de vue, DispatcherServlet, validateur, etc. Léger-Il utilise un conteneur servlet léger pour développer et déployer votre application. Configuration puissante-Il fournit une configuration fiable pour les classes du cadre et de l'application, y compris des références faciles à gérer entre les contextes, par exemple, de la contrôleur Web à l'objet métier et au validateur. Développement rapide-Spring MVC favorise le développement rapide et parallèle. Code métier réutilisable-Sans créer de nouveaux objets, cela nous permet d'utiliser des objets d'affaires existants. Facile à tester-Dans Spring, nous créons généralement des classes JavaBeans pour vous permettre d'injecter des données de test à l'aide des méthodes setter. Mapping flexible-Il fournit des annotations spécifiques pour rediriger facilement les pages.

Exemple du cadre Spring Web MVC

Voyons un exemple simple du cadre Spring Web MVC. Les étapes sont les suivantes :

Charger le fichier jar Spring ou ajouter la dépendance dans Maven Créer une classe contrôleur Fournir des entrées de contrôleur dans le fichier web.xml Définir les beans dans un fichier XML distinct Afficher un message dans une page JSP Démarrer le serveur et déployer le projet

Structure de répertoire de Spring MVC

Structure de répertoire de Spring MVC utilisée avec Maven

Fichiers jar nécessaires ou dépendances Maven

Pour exécuter cet exemple, vous devez charger :

Fichier jar Spring Core Fichier jar Spring Web JSP + Fichier jar JSTL (si vous utilisez d'autres technologies de vue, chargez le fichier jar correspondant).

Télécharger tous les fichiers jar de Spring, y compris JSP et JSTL.

Si vous utilisez Maven, vous n'avez pas besoin d'ajouter de fichier jar. Maintenant, vous devez ajouter les dépendances Maven au fichier pom.xml.

1、dans le fichier pom.xml, fournir des informations sur le projet et la configuration.

pom.xml

<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 http://maven.apache.org/maven.apache.org-maven4v
　　_0_0.xsd">4<modelVersion>/.0.0
　　modelVersion>3<groupId>com.w/<groupId>javax.servlet
　　codebox/artifactId>
　　<artifactId>SpringMVC/<packaging>war
　　packaging>1-<version>0.0./version>
　　SNAPSHOT/name>
　　<name>SpringMVC Maven Webapp//<url>http:/maven.apache.org
　　url>
　　　　api
　　　　　　<dependencies>/<groupId>javax.servlet
　　　　　　<groupId>junit/artifactId>
　　　　　　<version>3webmvc<8webmvc<1</version>
　　　　　　<artifactId>junit/<scope>test
　　　　</dependency>
　　　　
　　　　<!--　.RELEASE<//https:/mvnrepository.com/scope>/spring-org.springframework　-->
api
　　　　webmvc/<groupId>javax.servlet
　　　　<groupId>org.springframework-<artifactId>spring/artifactId>
　　　　<version>5webmvc<1webmvc<1./version>
</dependency>
<!--　.RELEASE<//https:/mvnrepository.com/artifact/artifact-javax.servlet　-->
api　　
　　　　<dependency>/<groupId>javax.servlet　　
　　　　groupId>-<artifactId>servlet/artifactId>　　
　　　　<version>3.0-alpha-1</version>　　
</dependency>
　　</dependencies>
　　<build>
　　　　<finalName>SpringMVC</finalName>
　　</build>
</project>

2、create a controller class

To create a controller class, we use two annotations @Controller and @RequestMapping.

@Controller annotation marks this class as a Controller.

@Requestmapping annotation is used to map classes with specified URL names.

HelloController.java

package com.w3codebox;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public　class　HelloController　{
@RequestMapping("/)

　　public　String　display()
　　{
　　　　return　"index";
　　}　
}

3、fournit des entrées de contrôleur dans le fichier web.xml

Dans ce fichier xml, nous spécifions la classe Servlet DispatcherServlet en tant que contrôleur frontal dans Spring Web MVC. Toutes les requêtes entrantes pour les fichiers html seront redirigées vers DispatcherServlet.

web.xml

<?xml　version="1.0"　encoding="UTF-8"?>
<web-app　xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"　xmlns="http://java.sun.com/xml/ns/javaee"　xsi:schemaLocation="http://java.sun.com/xml/ns/javaee　http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"　id="WebApp_ID"　version="3.0">
　　<display-name>SpringMVC</display-name>
　　　<servlet>　　
　　　　<servlet-name>spring</servlet-name>　　
　　　　<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>　　
　　　　<load-on-startup>1</load-on-startup>　　　　
</servlet>　　
<servlet-mapping>　　
　　　　<servlet-name>spring</servlet-name>　　
　　　　<url-pattern>/</url-pattern>　　
</servlet-mapping>　　
</web-app>

4、définit bean dans le fichier xml.

C'est un fichier de configuration important où vous devez spécifier les composants View.

context: component-l'élément scan définit le paquet de base du DispatcherServlet. Il recherchera les classes de contrôleur.

Ce fichier xml doit être situé dans le WEB-INF répertoire.

spring-servlet.xml

<?xml　version="1.0"　encoding="UTF-8"?>
<beans　xmlns="http://www.springframework.org/schema/beans"
　　xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"　
　　xmlns:context="http://www.springframework.org/schema/context"
　　xmlns:mvc="http://www.springframework.org/schema/mvc"
　　xsi:schemaLocation="
　　　　http://www.springframework.org/schema/beans
　　　　　　http://www.springframework.org/schema/beans/spring-beans.xsd
　　　　　　http://www.springframework.org/schema/context
　　　　　　http://www.springframework.org/schema/context/spring-context.xsd
　　　　　　http://www.springframework.org/schema/mvc
　　　　　　　　http://www.springframework.org/schema/mvc/spring-mvc.xsd">
　　<!--　Fournir un soutien pour le balayage des composants　-->
　　<context:component-scan base-package="com.w3codebox"　/>
　　<!--Fournir un soutien pour la conversion, le formatage et la validation　-->
　　<mvc:annotation-driven/>
</beans>

5Affichage du message dans une page JSP

Ceci est une page JSP simple qui affiche le message renvoyé par le Controller.

index.jsp

<html>
<body>
<p>Bienvenue dans le tutoriel Spring MVC</p>
</body>
</html>

Sortie:

Index MVC Spring