Explication détaillée de SpringMVC (super complet)

Language 2023-08-18 23:48:24 views: null

Table des matières

1. Introduction à SpringMvc

1. Passez en revue le modèle MVC

1.1 Conception

Le modèle de conception MVC fait généralement référence au cadre MVC, M (Modèle) fait référence à la couche de modèle de données, V (Vue) fait référence à la couche de vue et C (Contrôleur) fait référence à la couche de contrôle. Le but de l'utilisation de MVC est de séparer les codes d'implémentation de M et V, de sorte qu'un même programme puisse avoir des expressions différentes. Parmi eux, la définition de View est relativement claire, qui est l'interface utilisateur.

​ Dans le développement de projets Web, il est très important de pouvoir répondre aux demandes des utilisateurs de manière opportune et correcte. L'utilisateur clique sur un chemin d'URL sur la page Web, ce qui équivaut à l'envoi par l'utilisateur d'une demande au serveur Web. Après avoir obtenu la demande, comment analyser l'entrée de l'utilisateur, exécuter la logique de traitement pertinente et enfin passer à la bonne page pour afficher le résultat de la rétroaction, ces tâches sont souvent effectuées par la couche de contrôle (Contrôleur).

Au cours du processus de demande, les informations de l'utilisateur sont encapsulées dans la classe d'entité Utilisateur, qui appartient à la couche de modèle de données (Modèle) dans le projet Web.

​ Dans l'étape d'affichage de la demande, la page Web de résultat redirigée appartient à la couche de vue (View).

Ainsi, la couche de contrôle est responsable de l'interaction entre le premier plan et l'arrière-plan, la couche de modèle de données encapsule les données d'entrée/sortie de l'utilisateur et la couche de vue sélectionne la vue appropriée pour afficher le résultat final de l'exécution. le flux de développement et de traitement est appelé modèle MVC.

Lors de l'apprentissage du développement Servlet et JSP, JavaBean équivaut à Model, Servlet équivaut à Controller et JSP équivaut à View.

Résumé comme suit :

  • Couche de visualisation (View) : responsable du formatage des données et de leur présentation aux utilisateurs, y compris l'affichage des données, l'interaction de l'utilisateur, la validation des données, la conception de l'interface et d'autres fonctions.
  • Couche de contrôle (Controller): responsable de la réception et de la transmission de la demande, après traitement de la demande, spécification de la vue et envoi du résultat de la réponse au client.
  • Couche de modèle de données (Modèle) : l'objet de modèle a le plus de tâches de traitement et constitue la partie principale de l'application. Il est responsable du traitement de la logique des données (règles métier) et de la réalisation des opérations sur les données (c'est-à-dire l'accès aux données dans le base de données).

1.2 Avantages et inconvénients

Tout a des avantages et des inconvénients, examinons les avantages et les inconvénients de MVC.

1.2.1 Avantages

  • Plusieurs vues partagent un modèle, améliorant considérablement la réutilisabilité du code
  • Les trois modules de MVC sont indépendants les uns des autres, architecture faiblement couplée
  • Les contrôleurs augmentent la flexibilité et la configurabilité des applications
  • Propice à la gestion du génie logiciel

En bref, nous pouvons enfin créer une architecture parfaite de couplage lâche + haute réutilisabilité + haute applicabilité grâce au modèle de conception MVC.

1.2.2 Inconvénients

  • Le principe est complexe
  • Complexité accrue de la structure et de la mise en œuvre du système
  • Les vues ont un accès inefficace aux données du modèle

2. Le concept de Spring MVC

1. Conception

  • Spring MVC est un framework de développement Web léger basé sur le modèle de conception MVC fourni par Spring, qui est essentiellement équivalent à Servlet.
  • Spring MVC est l'implémentation la plus clairement structurée de Servlet + JSP + JavaBean.
  • Étant donné que Spring MVC lui-même fait partie du framework Spring, on peut dire qu'il est parfaitement intégré au framework Spring. Il présente des avantages inhérents en termes de performances et constitue le cadre de développement Web le plus courant et la compétence de développement la plus populaire dans l'industrie aujourd'hui.
  • Dans le framework Spring MVC, le contrôleur remplace le servlet pour assumer la responsabilité du contrôleur, qui est utilisé pour recevoir la demande, appeler le modèle correspondant pour le traitement et renvoyer le résultat du traitement une fois que le processeur a terminé le traitement métier. Le contrôleur appelle la vue correspondante et rend le résultat du traitement, et enfin le client obtient les informations de réponse.
  • Prise en charge pilotée par les annotations et RESTful pour Spring MVC.

2. Avantages

  • Répartition claire des rôles, Spring MVC fournit une répartition très claire des rôles en termes de modèle, de vue et de contrôleur.Ces trois aspects remplissent vraiment leurs fonctions et sont responsables de chacun.
  • Fonction de configuration flexible, vous pouvez configurer la classe en tant que Bean via XML.
  • Un grand nombre d'interfaces de contrôleur et de classes d'implémentation sont fournies. Les développeurs peuvent utiliser les classes d'implémentation de contrôleur fournies par Spring ou implémenter eux-mêmes des interfaces de contrôleur.
  • Cela n'a vraiment rien à voir avec l'implémentation de la couche View. Il n'oblige pas les développeurs à utiliser JSP, mais peut utiliser des technologies telles que Velocity et FreeMarker selon les exigences du projet.
  • Assistance à l'internationalisation
  • programmation à l'interface
  • Intégration transparente avec le framework Spring

3. Le premier programme Spring MVC

3.1 Étapes à suivre

3.1.1 Créer une application Web et importer des dépendances

<properties>
    <!-- spring版本号 -->
    <spring.version>4.0.2.RELEASE</spring.version>
    <!-- log4j日志文件管理包版本 -->
    <slf4j.version>1.7.7</slf4j.version>
    <log4j.version>1.2.17</log4j.version>
  </properties>
  <!--依赖-->
  <dependencies>
    <!-- junit -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
    </dependency>
    <!-- JSTL标签类 -->
    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
    <!-- servlet依赖的jar包start -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>javax.servlet.jsp-api</artifactId>
      <version>2.3.1</version>
    </dependency>
    <!-- 映入JSON -->
    <dependency>
      <groupId>org.codehaus.jackson</groupId>
      <artifactId>jackson-core-asl</artifactId>
      <version>1.9.4</version>
    </dependency>
    <dependency>
      <groupId>org.codehaus.jackson</groupId>
      <artifactId>jackson-mapper-asl</artifactId>
      <version>1.9.4</version>
    </dependency>
    <!-- spring核心包 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-oxm</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <!-- 日志 -->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>${log4j.version}</version>
    </dependency>
    <!-- 格式化对象，方便输出日志 -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>1.1.41</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>${slf4j.version}</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>${slf4j.version}</version>
    </dependency>
    <!--lombok-->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.12</version>
    </dependency>
    <dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>2.4</version>
    </dependency>
    <dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>1.2.2</version>
    </dependency>
  </dependencies>
  <build>
    <!--resources配置解决mybatis的mapperXml配置在java路径不被扫描的问题 -->
    <resources>
      <resource>
        <directory>src/main/java</directory>
      </resource>
      <resource>
        <directory>src/main/resources</directory>
      </resource>
    </resources>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
      <!-- 跳过测试 -->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <configuration>
          <skipTests>true</skipTests>
        </configuration>
      </plugin>
    </plugins>
  </build>

3.1.2 Configuration Spring MVC

Spring MVC est basé sur Servlet, et DispatcherServlet est le cœur de l'ensemble du framework Spring MVC, principalement responsable de l'interception des requêtes et de leur envoi aux processeurs correspondants pour traitement. Donc, pour configurer Spring MVC, vous devez d'abord définir DispatcherServlet. Comme pour tous les servlets, l'utilisateur doit être configuré dans web.xml.

Créez des répertoires java et de ressources sous le répertoire principal.

3.1.2.1 Définir 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" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         version="3.0">
  <!-- 部署 DispatcherServlet -->
  <servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:config/springmvc-servlet.xml</param-value>
    </init-param>
    <!-- 表示容器再启动时立即加载servlet -->
    <load-on-startup>1</load-on-startup>
    <!--支持异步处理-->
    <async-supported>true</async-supported>
  </servlet>
  <servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <!-- 处理所有URL -->
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

Précautions:

  1. Lorsque Spring MVC est initialisé, il recherche les fichiers de configuration dans le répertoire WEB-INF de l'application. La règle de nommage des fichiers de configuration est "servletName-servlet.xml", comme springmvc-servlet.xml.
  2. Vous pouvez également stocker le fichier de configuration Spring MVC n'importe où dans le répertoire de l'application, mais vous devez utiliser l'élément init-param du servlet pour charger le fichier de configuration et spécifier l'emplacement du fichier de configuration Spring MVC via le paramètre contextConfigLocation .
<!-- 部署 DispatcherServlet -->
<servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet </servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:config/springmvc-servlet.xml</param-value>
    </init-param>
    <!-- 表示容器再启动时立即加载servlet -->
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>
3.1.2.2 Création de contrôleurs

Créez le package com.hqyj.cl.controller dans le répertoire src et créez deux classes de contrôleur de style traditionnel (implémentant l'interface Controller) dans le package, RegisterController et LoginController, pour gérer les hyperliens "enregistrement" et "connexion" sur le page d'accueil respectivement demande. Controller est l'interface du contrôleur et il n'y a qu'une seule méthode handleRequest dans l'interface, qui est utilisée pour traiter les requêtes et renvoyer ModelAndView.

  1. LoginController
public class LoginController implements Controller {
    
    
    public ModelAndView handleRequest(HttpServletRequest arg0,
                                      HttpServletResponse arg1) throws Exception {
    
    
        return new ModelAndView("/WEB-INF/jsp/login.jsp");   //注意文件路径是否在WEB-INF文件夹中
    }
}
  1. RegistreContrôleur
public class RegisterController implements Controller {
    
    
    public ModelAndView handleRequest(HttpServletRequest arg0,
                                      HttpServletResponse arg1) throws Exception {
    
    
        return new ModelAndView("/WEB-INF/jsp/register.jsp");
    }
}
3.1.2.3 Créer un fichier de configuration Spring MVC

Créez le fichier springmvc-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"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- LoginController控制器类，映射到"/login" -->
    <bean name="/login"
          class="com.hqyj.cl.controller.LoginController"/>
    <!-- LoginController控制器类，映射到"/register" -->
    <bean name="/register"
          class="com.hqyj.cl.controller.RegisterController"/>
</beans>
3.1.2.4 Créer une page
  1. index.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
</head>
<body>
<h2>Hello World!</h2>
未注册的用户，请
<a href="${pageContext.request.contextPath}/register"> 注册</a>！
<br /> 已注册的用户，去
<a href="${pageContext.request.contextPath}/login"> 登录</a>！
</body>
</html>
  1. login.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>login</title>
</head>
<body>
login
</body>
</html>
  1. registre.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>register</title>
</head>
<body>
register
</body>
</html>
3.1.2.5 Configuration du serveur Tomcat

légèrement

3.1.2.6 Essais

légèrement

2. Spring MVC View Resolver (ViewResolver)

View Resolver (ViewResolver) est une partie importante de Spring MVC, responsable de la résolution des noms de vue logiques en objets de vue spécifiques.

1. Classes d'analyse de vue couramment utilisées

1.1 URLBasedViewResolver

1.1.1 Aperçu

UrlBasedViewResolver est une implémentation simple de ViewResolver, qui fournit principalement un moyen de fusionner des URL pour résoudre des vues.

1.1.2 Principe

​ UrlBasedViewResolver spécifie le préfixe via l'attribut prefix, et l'attribut suffix spécifie le suffixe. Lorsque l'objet ModelAndView renvoie un nom de vue spécifique, il concatène le préfixe de préfixe et le suffixe de suffixe avec le nom de vue spécifique pour obtenir un chemin de chargement spécifique du fichier de ressources de vue, chargeant ainsi le fichier de vue réel et le renvoyant à l'utilisateur.

1.1.3 Configuration

​ Pour utiliser UrlBasedViewResolver, en plus de configurer les attributs de préfixe et de suffixe, vous devez également configurer "viewClass" pour indiquer quelle vue résoudre. L'exemple de code est le suivant

<!--配置视图解析器之URLBasedViewResolver-->
<bean id="viewResolver" class="org.springframework.web.servlet.view.UrlBasedViewResolver">
    <!--不能省略-->
    <property name="viewClass" value="org.springframework.web.servlet.view.InternalResourceView"/>
    <!--前缀-->
    <property name="prefix" value="/WEB-INF/jsp/"/>
    <!--后缀-->
    <property name="suffix" value=".jsp"/>
</bean>
1.1.3.1 Descriptif
  • Le résolveur de vue ci-dessus est configuré avec deux attributs, préfixe et suffixe, ce qui raccourcit le chemin de la vue. Les chemins de vue des classes de contrôleur RegisterController et LoginController dans le premier programme Spring MVC n'ont besoin que de fournir le registre et la connexion, et le résolveur de vue ajoutera automatiquement le préfixe et le suffixe, qui sont résolus ici en tant que /WEB-INF/jsp/register. jsp et /WEB-INF/jsp/login.jsp.
  • Lorsque vous utilisez UrlBasedViewResolver, vous devez spécifier l'attribut viewClass pour indiquer quelle vue résoudre. Généralement, InternalResourceView est utilisé plus souvent pour afficher jsp, mais lorsque nous utilisons JSTL, nous devons utiliser JstlView.
  • Le contenu stocké dans le répertoire /WEB-INF/ ne peut pas être obtenu directement via la demande de requête, donc pour des raisons de sécurité, le fichier jsp est généralement placé dans le répertoire WEB-INF

1.2 InternalResourceViewResolver

1.2.1 Aperçu

InternalResourceViewResolver est le "résolveur de vue de ressource interne", qui est le type de résolveur de vue le plus couramment utilisé dans le développement quotidien. C'est une sous-classe de URLBasedViewResolver et possède toutes les fonctionnalités de URLBasedViewResolver.

1.2.2 Principe

UrlBasedViewResolver spécifie le préfixe via l'attribut prefix et l'attribut suffix spécifie le suffixe. Lorsque l'objet ModelAndView renvoie un nom de vue spécifique, il concatène le préfixe de préfixe et le suffixe de suffixe avec le nom de vue spécifique pour obtenir un chemin de chargement spécifique du fichier de ressources de vue, chargeant ainsi le fichier de vue réel et le renvoyant à l'utilisateur.

1.2.3 Configuration

Utiliser UrlBasedViewResolver Outre la configuration des attributs de préfixe et de suffixe, vous devez également configurer "viewClass" pour indiquer quelle vue résoudre. L'exemple de code est le suivant

<!--配置视图解析器之InternalResourceViewResolver-->
<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <!--可以省略-->
    <property name="viewClass" value="org.springframework.web.servlet.view.InternalResourceView"/>
    <!--前缀-->
    <property name="prefix" value="/WEB-INF/jsp/"/>    <!--注意路径-->
    <!--后缀-->
    <property name="suffix" value=".jsp"/>
</bean>
1.2.3.1 Descriptif
  • InternalResourceViewResolver peut résoudre automatiquement le nom de la vue renvoyée en un objet de type InternalResourceView.
  • InternalResourceView stockera les attributs de modèle renvoyés par la méthode du processeur Controller dans les attributs de requête correspondants, puis redirigera la requête vers l'URL cible côté serveur via le RequestDispatcher. C'est-à-dire que lors de l'utilisation de InternalResourceViewResolver pour résoudre la vue, il n'est pas nécessaire de spécifier l'attribut viewClass séparément.

3. Processus d'exécution Spring MVC

1. Organigramme d'exécution

[Le transfert d'image du lien externe a échoué, le site source peut avoir un mécanisme de lien antivol, il est recommandé d'enregistrer l'image et de la télécharger directement (img-UPAiYIZX-1682512822611) (G:\Desktop\Lesson Preparation\Class\ssm\ Carte du didacticiel \ Organigramme d'exécution Spring MVC .png)]

2. Aperçu du processus d'exécution

Le flux d'exécution de SpringMVC est le suivant

  1. L'utilisateur clique sur un chemin de requête pour lancer une requête HTTP, qui sera soumise à DispatcherServlet (contrôleur frontal) ;
  2. DispatcherServlet demande un ou plusieurs HandlerMapping (mappeur de processeur) et renvoie une chaîne d'exécution (HandlerExecutionChain).
  3. DispatcherServlet envoie les informations Handler renvoyées par la chaîne d'exécution à HandlerAdapter (adaptateur de processeur) ;
  4. HandlerAdapter trouve et exécute le gestionnaire correspondant (souvent appelé contrôleur) en fonction des informations du gestionnaire ;
  5. Une fois le gestionnaire exécuté, il renverra un objet ModelAndView au HandlerAdapter (l'objet sous-jacent de Spring MVC, y compris le modèle de données Model et les informations de vue View);
  6. Une fois que le HandlerAdapter a reçu l'objet ModelAndView, il le renvoie au DispatcherServlet ;
  7. Une fois que DispatcherServlet a reçu l'objet ModelAndView, il demande à ViewResolver (résolveur de vue) de résoudre la vue ;
  8. ViewResolver fait correspondre le résultat de la vue correspondante en fonction des informations de la vue et le renvoie à DispatcherServlet ;
  9. Après avoir reçu la vue de vue spécifique, DispatcherServlet rend la vue, remplit les données de modèle dans le modèle dans le champ de demande de la vue de vue et génère la vue finale (vue) ;
  10. Les vues sont responsables de l'affichage des résultats dans le navigateur (client).

3. Interface Spring MVC

Les composants impliqués dans Spring MVC sont DispatcherServlet (contrôleur frontal), HandlerMapping (mappeur de processeur), HandlerAdapter (adaptateur de processeur), Handler (processeur), ViewResolver (résolveur de vue) et View (vue). La description de la fonction de chaque composant est la suivante

3.1 DispatcherServlet

​ DispatcherServlet est le contrôleur frontal. Comme le montre la figure 1, toutes les requêtes de Spring MVC doivent être distribuées uniformément via DispatcherServlet.

DispatcherServlet est l'équivalent d'un transitaire ou d'une unité centrale de traitement, qui contrôle l'exécution de l'ensemble du processus et planifie uniformément chaque composant pour réduire le couplage entre les composants et faciliter l'expansion entre les composants.

3.2 Cartographie des gestionnaires

​ HandlerMapping est un mappeur de processeur, sa fonction est de trouver un gestionnaire correspondant (Handler) via une annotation ou une configuration XML en fonction du chemin URL de la requête.

3.3 Adaptateur de gestionnaire

​ HandlerAdapter est un adaptateur de processeur, dont la fonction est d'exécuter le processeur concerné (Handler) selon des règles spécifiques en fonction du processeur (Handler) trouvé par le mappeur.

​ A l'étape servlet, pour résoudre une requête correspondant à une servlet, il existe deux méthodes

1. Lorsque la méthode passe des paramètres, passez-en un de plus et trouvez la méthode de servlet correspondante

2. Encapsulez un baseServlet, qui est utilisé pour hériter du httpsservlet, et invoquez-le pendant le fonctionnement par réflexion. Les servlets définis ultérieurement hériteront de la baseServlet

3.4 Gestionnaire

​ Handler est un processeur, souvent appelé Controller, qui est cohérent avec le rôle joué par Java Servlet. Sa fonction est d'exécuter la logique de traitement des requêtes associées, de renvoyer les données correspondantes et d'afficher les informations, et de les encapsuler dans l'objet ModelAndView.

3.5 Afficher le résolveur

View Resolver est un résolveur de vue, son rôle est d'effectuer des opérations d'analyse et de résoudre le nom de la vue logique en une vue réelle via les informations de vue dans l'objet ModelAndView (comme le retour d'une vraie page JSP via un chemin JSP).

3.6 Affichage

View est une vue, qui est elle-même une interface, et la classe d'implémentation prend en charge différents types de vue (JSP, FreeMarker, Thymeleaf, etc.).

四、@Controller、@RequestMapping

Spring version 2.5 ajoute la fonction d'annotation Spring MVC pour remplacer la configuration Spring MVC traditionnelle basée sur XML.

1. Avantages de l'utilisation des annotations

  • Plusieurs méthodes de traitement peuvent être écrites dans la classe de contrôleur basée sur des annotations et plusieurs requêtes (actions) peuvent être traitées, ce qui permet d'écrire des opérations connexes dans la même classe de contrôleur, réduisant ainsi le nombre de classes de contrôleur et facilitant .
  • Les contrôleurs basés sur des annotations n'ont pas besoin de déployer des mappages dans les fichiers de configuration, mais doivent uniquement utiliser @RequestMapping pour annoter une méthode de traitement des demandes.

2、@Contrôleur

L'annotation @Controller est utilisée pour déclarer qu'une instance d'une classe est un contrôleur.

2.1 Étapes à suivre

  1. Ajouter des annotations à la classe Controller
package com.hqyj.cl.controller;

import org.springframework.stereotype.Controller;

@Controller
public class AnnotationTest {
    
    
    // 方法代码
}
  1. analyse du package de configuration springmvc-servlet.xml

Spring MVC utilise le mécanisme d'analyse pour rechercher toutes les classes de contrôleur basées sur des annotations dans l'application. Par conséquent, pour que la classe de contrôleur soit analysée par le framework Spring MVC, vous devez déclarer spring-context dans le fichier de configuration et utiliser l'élément pour spécifier le package de base de la <context:component-scan/>classe de contrôleur (Assurez-vous que toutes les classes de contrôleur sont sous le package de base et ses sous-packages).

<!-- 使用扫描机制扫描控制器类，控制器类都在com.hqyj.controller包及其子包下 -->
<context:component-scan base-package="com.hqyj.controller" />

3、@RequestMapping

  • Il existe plusieurs méthodes pour traiter les demandes dans un contrôleur, telles que l'ajout d'utilisateurs, la modification des informations utilisateur, la suppression d'utilisateurs spécifiés et l'obtention de listes d'utilisateurs en fonction de conditions, etc. dans UserController. Chaque méthode est responsable de différentes opérations de demande et @RequestMapping est responsable du mappage de la demande à la méthode de contrôleur correspondante.
  • L'annotation @RequestMapping peut être utilisée sur des classes ou des méthodes. Utilisé sur une classe, cela signifie que toutes les méthodes de la classe qui répondent aux requêtes utilisent cette adresse comme chemin parent.

3.1 Propriétés communes

3.1.1 attribut de valeur

L'attribut value est l'attribut par défaut de l'annotation @RequestMapping, donc s'il n'y a que l'attribut value, le nom de l'attribut peut être omis, et s'il y a d'autres attributs, le nom de l'attribut value doit être écrit.

3.1.1.1 Exemple de code
@RequestMapping(value="user")
@RequestMapping("user")

3.1.2 propriété de chemin

​ Même usage que l'attribut value

3.1.3 attribut de nom

L'attribut name est équivalent au commentaire de la méthode, ce qui rend la méthode plus facile à comprendre.

3.1.3.1 Exemple de code
@RequestMapping(value = "user",name = "用户操作")

3.1.4 attribut de méthode

L'attribut method est utilisé pour indiquer quelles requêtes HTTP sont prises en charge par la méthode. Si l'attribut method est omis, la méthode prend en charge toutes les requêtes HTTP.

3.1.4.1 Exemple de code
// 只支持 GET 请求
@RequestMapping(value = "selectAllUser",method = RequestMethod.GET)
// 指定支持多个 HTTP 请求，该方法同时支持 GET 和 POST 请求。
@RequestMapping(value = "checkUser",method = {
    
    RequestMethod.GET,RequestMethod.POST})

3.1.5 attribut params

L'attribut params est utilisé pour spécifier les paramètres spécifiés dans la requête.

3.1.5.1 Exemple de code
// 请求中必须包含 type 参数时才能执行该请求
@RequestMapping(value = "selectAllUser",params = "type")
public String toUser() {
    
    
    return "userList";
}
// 请求中必须包含 type 参数，且 type 参数值为 1 时才能够执行该请求
@RequestMapping(value = "selectAllUser",params = "type=1")
public String toUser() {
    
    
    return "userList";
}

3.2 Mappage par URL de requête

3.2.1 Annotations au niveau de la méthode

@Controller
public class UserController {
    
    
    @RequestMapping(value = "/user/login")
    public String login() {
    
    
        return "login";
    }
    @RequestMapping(value = "/user/register")
    public String register() {
    
    
        return "register";
    }
}

3.2.2 Annotations au niveau de la classe

@Controller
@RequestMapping("/user")
public class UserController {
    
    
    @RequestMapping("/login")
    public String login() {
    
    
        return "login";
    }
    @RequestMapping("/register")
    public String register() {
    
    
        return "register";
    }
}

3.3 Mappage par paramètres ou méthodes de requête

​ La valeur de @RequestMapping indique l'URL de la requête ; method indique la méthode de requête, qui est définie comme une requête GET ici. S'il s'agit d'une requête POST, elle ne peut pas saisir la méthode de traitement de selectUserByUsername. params indique les paramètres de la requête, où le nom du paramètre est username.

@Controller
public class UserController {
    
    
    @RequestMapping(value = "/user/userList" method=RequestMethod.GET, params="username")
    public String selectUserByUsername(String username) {
    
    
        return "userList";
        
    @RequestMapping(value = "/user/userList2" method=RequestMethod.GET)
    public String selectUserByUsername2(@RequestParam("username") String username) {
    
    
        return "userList";
}

3.4 Types de paramètres

Le type org.springframework.ui.Model, qui est un type Spring MVC qui contient un Map. Spring MVC créera des objets org.springframework.ui.Model chaque fois qu'une méthode de gestion de requête est appelée.

3.4.1 Type de modèle

@Controller
@RequestMapping("/user")
public class UserController {
    
    
    @RequestMapping("/register")
    public String register(Model model) {
    
    
        /*在视图中可以使用EL表达式${success}取出model中的值*/
        model.addAttribute("success", "注册成功");
        return "register";
    }
}

3.4.1 Cas

  1. manette
@Controller
@RequestMapping(value = "user",name = "用户操作")
public class UserController {
    
    
    // 登录
    @RequestMapping("/login")
    public String login(Model model){
    
    
        /*在视图中可以使用EL表达式${info}取出model中的值*/
        model.addAttribute("info", "登录成功");
        return "index";
    }
}
  1. sommaire
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>index</title>
</head>
<body>
    ${info},系统首页！
</body>
</html>

Cinq, paramètres de passage Spring MVC

Il existe de nombreuses façons pour Spring MVC Controller de recevoir les paramètres de requête, certains conviennent aux méthodes de requête get, certains conviennent aux méthodes de post-requête et certains conviennent aux deux. Il existe principalement les moyens suivants :

  • Recevoir les paramètres de la requête via le bean entité
  • Recevoir les paramètres de la demande via les paramètres formels de la méthode de traitement
  • Recevoir les paramètres de la requête via HttpServletRequest
  • Recevoir les paramètres de requête dans l'URL via @PathVariable
  • Recevoir les paramètres de la requête via @RequestParam

1. Recevoir les paramètres de la requête via le bean entité

Les paramètres de demande de réception d'Entity Bean s'appliquent aux méthodes de demande get et post-submit. Il convient de noter que le nom de la propriété du bean doit être le même que le nom du paramètre de requête. L'exemple de code est le suivant

@RequestMapping("/login")
public String login(User user, Model model) {
    
    
    if ("admin".equals(user.getUsername())
            && "112112".equals(user.getPassword())) {
    
    
        model.addAttribute("message", "登录成功");
        return "index"; // 登录成功，跳转到 index.jsp
    } else {
    
    
        model.addAttribute("message", "用户名或密码错误");
        return "login";
    }
}

url obtenir les paramètres d'épissage de la méthode d'arrière-plan de la demande

2. Recevoir les paramètres de la demande via les paramètres formels de la méthode de traitement

Recevoir des paramètres de requête via les paramètres formels de la méthode de traitement consiste à écrire directement les paramètres de formulaire dans les paramètres formels de la méthode correspondante de la classe contrôleur, c'est-à-dire que les noms de paramètres formels sont exactement les mêmes que les noms de paramètres de requête. Cette méthode de réception des paramètres s'applique aux demandes d'obtention et de publication des soumissions. L'exemple de code est le suivant

@RequestMapping("/login")
public String login(String username, String password, Model model) {
    
    
    if ("admin".equals(username)
            && "112112".equals(password)) {
    
    
        model.addAttribute("message", "登录成功");
        return "index"; // 登录成功，跳转到 index.jsp
    } else {
    
    
        model.addAttribute("message", "用户名或密码错误");
        return "login";
    }
}

3. Recevoir les paramètres de la requête via HttpServletRequest

​ Identique à la méthode d'acquisition dans la phase servlet, les paramètres de la méthode de la couche contrôleur incluent le paramètre HttpServletRequest, et les paramètres de la requête peuvent être obtenus.

4. Recevez les paramètres de la requête dans l'URL via @PathVariable

@RequestMapping(value = "/login/{username}/{password}")
public String login(@PathVariable("username") String username, @PathVariable("password") String password) {
    
    
    System.out.println(username);
    System.out.println(password);
    return "index";
}

Lors de l'accès http://localhost:8080/user/login/admin/123456au chemin, le code ci-dessus liera automatiquement les variables de modèle {username} et {password} dans l'URL aux paramètres du même nom annotés par @PathVariable, à savoir username=admin, password=123456.

5. Recevoir les paramètres de la requête via @RequestParam

Utilisez l'annotation @RequestParam au niveau du paramètre de méthode pour spécifier ses paramètres de requête correspondants. @RequestParam a les trois paramètres suivants :

  • valeur : nom du paramètre ;
  • required : s'il faut inclure ce paramètre, la valeur par défaut est true, indiquant que le chemin de la requête doit inclure ce paramètre, s'il n'est pas inclus, une erreur sera signalée ;
  • defaultValue : La valeur du paramètre par défaut, si cette valeur est définie, required=true sera invalide, et elle sera fausse automatiquement, si ce paramètre n'est pas passé, la valeur par défaut sera utilisée

La réception des paramètres de demande via @RequestParam s'applique aux méthodes de demande d'obtention et de publication, l'exemple de code est le suivant

  1. UtilisateurContrôleur
@RequestMapping("/goRequestParam")
private String goRequestParam(){
    
    
    return "requestParam";
}
@RequestMapping("/requestParam")
public String requestParam(
    @RequestParam(value = "username",required = true) String username, 
    @RequestParam(value = "password",required = false,defaultValue = "111") String password){
    
    
    System.out.println(username + " " + password);
    return "index";
}
  1. requestParam.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>RequestParam</title>
</head>
<body>
<form action="/user/requestParam" method="get">
    用户名:<input type="text" name="username"><br>
    密码:<input type="password" name="password"><br>
    <input type="submit" value="submit">
</form>
</body>
</html>
  1. index.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>index</title>
</head>
<body>
<a href="../user/login">登录</a><br>
<a href="../user/register">注册</a><br>
<a href="../user/goRequestParam">RequestParam</a><br>
</body>
</html>

​ La différence entre cette méthode et "Recevoir les paramètres de la requête via les paramètres formels de la méthode de traitement" est la suivante : lorsque les paramètres de la requête sont incohérents avec les noms de paramètres reçus, "Recevoir les paramètres de la requête via les paramètres formels de la méthode de traitement" ne signale pas une erreur 400, tandis que "By @ RequestParam "recevoir les paramètres de la demande" signalera une erreur 400.

Six, redirection et transfert Spring MVC

  • Les méthodes de requête Spring MVC sont divisées en deux types : le transfert et la redirection, qui sont traités au niveau du contrôleur à l'aide des mots clés de transfert et de redirection respectivement.
  • Dans le framework Spring MVC, l'instruction return de la méthode de traitement dans la classe du contrôleur est transmise par défaut , mais elle est transmise à la vue.
  • La redirection consiste à diriger l'utilisateur de la requête de traitement en cours vers une autre vue (telle que JSP) ou requête de traitement. Toutes les informations stockées dans la requête précédente (demande) seront invalidées et entreront dans une nouvelle portée de requête ;
  • Le transfert consiste à transférer la demande de traitement actuelle de l'utilisateur vers une autre vue ou demande de traitement, et les informations stockées dans la demande précédente ne seront pas invalidées.
  • Le transfert est un comportement de serveur, la redirection est un comportement de client.

1. Processus de transfert

  • Le navigateur client envoie une requête http et le serveur Web accepte la requête, appelle une méthode interne pour terminer le traitement de la requête et les actions de transfert à l'intérieur du conteneur, et envoie la ressource cible au client ; le chemin de transfert ici doit être l'URL sous le même conteneur Web, il ne peut pas être redirigé vers d'autres chemins Web et la demande dans son propre conteneur est transmise au milieu.
  • Ce qui est affiché dans la barre d'adresse du navigateur du client est toujours le chemin de sa première visite, c'est-à-dire que le client n'a pas l'impression que le serveur a fait une redirection. Le comportement de transfert est que le navigateur ne fait qu'une seule demande d'accès.

2. Processus de redirection

  • Le navigateur client envoie une requête http et le serveur Web envoie une réponse de code d'état 302 et le nouvel emplacement correspondant au navigateur client après l'avoir accepté. Lorsque le navigateur client trouve qu'il s'agit d'une réponse 302, il envoie automatiquement une nouvelle requête http , et que l'URL de la demande est la nouvelle adresse d'emplacement, le serveur trouve la ressource en fonction de cette demande et l'envoie au client.
  • L'emplacement ici peut être redirigé vers n'importe quelle URL. Étant donné que le navigateur réémet la demande, il n'y a pas de concept de livraison de la demande. Le chemin de redirection est affiché dans la barre d'adresse du navigateur du client, et le client peut observer le changement d'adresse. Le comportement de redirection est que le navigateur effectue au moins deux demandes d'accès.

3. Cas

@RequestMapping("/login")
public String login() {
    
    
    //转发到一个请求方法（同一个控制器类可以省略/index/）
    return "forward:/user/isLogin";
}
@RequestMapping("/isLogin")
public String isLogin() {
    
    
    //重定向到一个请求方法
    return "redirect:/user/isRegister";
}
@RequestMapping("/isRegister")
public String isRegister() {
    
    
    //转发到一个视图
    return "register";
}

4. Questions nécessitant une attention particulière

​ Dans le framework Spring MVC, qu'il s'agisse d'une redirection ou d'un transfert, il doit être conforme à la configuration du résolveur de vue. S'il est directement transféré vers une ressource qui ne nécessite pas DispatcherServlet, par exemple

return "forward:/html/my.html";

Vous devez configurer dans springmvc-servlet.xml

<mvc:resources location="/html/" mapping="/html/**" />

7. @Autowired et @Service

Les annotations @Autowired et @Service sont nécessaires pour injecter des dépendances dans les contrôleurs Spring MVC.

1. Introduction

L'annotation @Autowired appartient au package org.springframework.beans.factory.annotation, qui peut annoter des variables, des méthodes et des constructeurs de membres de classe pour terminer le travail d'assemblage automatique ;

L'annotation @Service appartient au package org.springframework.stereotype et enregistrera automatiquement la classe d'annotation dans le conteneur Spring.

2. Cas

  1. springmvc-servlet.xml

Des éléments doivent être ajoutés dans le fichier de configuration springmvc-servlet.xml <component-scan/>pour analyser les packages de base dépendants

<context:component-scan base-package="com.hqyj.cl.service"/>
  1. Classe d'entité
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    
    
    private String name;
    private String pwd;
}
  1. Créer l'interface UserService
public interface UserService {
    
    
    boolean login(User user);
    boolean register(User user);
}
  1. Créer une classe UserServiceImpl pour implémenter l'interface UserService
@Service
public class UserServiceImpl implements UserService {
    
    
    @Override
    public boolean login(User user) {
    
    
        if ("admin".equals(user.getName()) && "111".equals(user.getPwd())) {
    
    
            return true;
        }
        return false;
    }
    @Override
    public boolean register(User user) {
    
    
        if ("admin".equals(user.getName()) && "111".equals(user.getPwd())) {
    
    
            return true;
        }
        return false;
    }
}

Remarque : La fonction d'ajout d'annotation @Service est de permettre à la classe d'être analysée par Spring

  1. Créer la classe UserController
@Controller
@RequestMapping("/user")
public class UserController {
    
    
    @Autowired
    private UserService userService;
    @RequestMapping("/login")
    public String getLogin(Model model) {
    
    
        User user = new User();
        user.setName("admin");
        user.setPwd("111");
        userService.login(user);
        model.addAttribute("user", user);
        return "login";
    }
    @RequestMapping("/register")
    public String getRegister(Model model) {
    
    
        User user = new User();
        user.setName("admin");
        user.setPwd("111");
        userService.login(user);
        model.addAttribute("user", user);
        return "register";
    }
}

Remarque : l'ajout de l'annotation @Autowired sur UserService entraînera l'injection d'une instance de UserService dans l'instance UserController

  1. springmvc-servlet.xml
<!-- 配置包扫描路径，作用自动检测标注Bean -->
<context:component-scan base-package="com.hqyj.cl" />
<mvc:annotation-driven />
<bean id="viewResolver"
      class="org.springframework.web.servlet.view.InternalResourceView">
    <!--前缀 -->
    <property name="prefix" value="/WEB-INF/jsp/" />
    <!--后缀 -->
    <property name="suffix" value=".jsp" />
</bean>
  1. web.xml
<!-- 部署 DispatcherServlet -->
<servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 表示容器再启动时立即加载servlet -->
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <!-- 处理所有URL -->
    <url-pattern>/</url-pattern>
</servlet-mapping>
  1. index.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head lang="en">
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title></title>
</head>
<body>
<h2>Hello World!</h2>
未注册的用户，请
<a href="${pageContext.request.contextPath}/user/register"> 注册</a>！
<br /> 已注册的用户，去
<a href="${pageContext.request.contextPath}/user/login"> 登录</a>！
</body>
</html>
  1. login.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title></title>
</head>
<body>
    登录页面！ 欢迎 ${user.name} 登录
</body>
</html>
  1. registre.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
         pageEncoding="UTF-8" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title></title>
</head>
<body>
    注册页面！
    注册账号成功，用户名为： ${user.name }
</body>
</html>

Huit, @ModelAttribute (comprendre)

L'annotation très importante @ModelAttribute dans Spring MVC est utilisée pour lier les paramètres de requête aux objets Model. L'objet modèle est créé avant la méthode du contrôleur, donc la méthode annotée par @ModelAttribute sera exécutée avant chaque méthode du contrôleur. utiliser le moins possible

1. Objectif

  • appliquée à la méthode
  • appliqué aux paramètres de la méthode
  • Appliqué à la méthode, et la méthode utilise également @RequestMapping

1.1 Appliqué à la méthode

1.1.1 Appliqué aux méthodes sans valeur de retour

  1. ModelAttributeController
@Controller
@RequestMapping("/model")
public class ModelAttributeController {
    
    
    // 方法无返回值
    @ModelAttribute
    public void myModel(@RequestParam(required = false) String name, Model model) {
    
    
        model.addAttribute("name", name);
    }
    @RequestMapping("/index")
    public String model() {
    
    
        return "index";
    }
    
    // 上述代码合二为一
    /*    @RequestMapping("/index")
    public String model(@RequestParam(required = false) String name, Model model) {
        model.addAttribute("name", name);
        return "index";
    }*/
}
  1. index.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>index</title>
</head>
<body>
    ${name}
</body>
</html>

accéder:

​ En utilisant http://localhost:8080/model/index?name=%E5%BC%A0%E4%B8%89l'accès, la page affichera la valeur correspondant au nom. Conseil : la chaîne après le nom n'est pas un caractère tronqué, mais un problème de conversion de chaîne. La signification ici est Zhang San.

1.1.2 Appliqué aux méthodes avec valeurs de retour

En utilisant cette méthode, le nom de l'objet de la valeur de retour sera placé dans le modèle implicite par défaut. Dans le modèle, la clé est la lettre initiale minuscule du type de valeur de retour et la valeur est la valeur renvoyée. Équivalent àmodel.addAttribute("string", name);

  1. ModelAttributeController
@Controller
@RequestMapping("/model")
public class ModelAttributeController {
    
    
     // 方法有返回值
    @ModelAttribute()
    public String myModel(@RequestParam(required = false) String name) {
    
    
        return name;
    }
    @RequestMapping("/index")
    public String model() {
    
    
        return "index";
    }
}
  1. index.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>index</title>
</head>
<body>
    ${string}
</body>
</html>

Dans des circonstances normales, essayez de ne pas renvoyer de valeurs de types de données tels que string, int et float dans le programme. Utilisez @ModelAttribute pour annoter l'attribut de valeur afin de personnaliser la clé, exemple de code

@ModelAttribute("name")
public String myModel(@RequestParam(required = false) String name) {
    
    
    return name;
}

Équivalent à

model.addAttribute("name", name);

1.2 Appliqué aux paramètres de la méthode

​ @ModelAttribute est annoté sur les paramètres de la méthode.Lorsque la méthode est appelée, la valeur du modèle sera injectée. Ceci est très simple en pratique et est souvent utilisé pour mapper des attributs de formulaire sur ** des objets de modèle. **

  1. ModelAttributeController
@Controller
@RequestMapping("/model")
public class ModelAttributeController {
    
    
    @RequestMapping("/register")
    public String register(@ModelAttribute("user") User user) {
    
    
        if ("admin".equals(user.getName()) && "111".equals(user.getPwd())) {
    
    
            return "login";
        } else {
    
    
            return "register";
        }
    }
}
  1. login.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
         pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title></title>
</head>
<body>
登录页面！ 欢迎 ${user.name} 登录
</body>
</html>
  1. index.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
         pageEncoding="UTF-8" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title></title>
</head>
<body>
注册页面！
注册账号成功，用户名为： ${user.name }
</body>
</html>

1.2.1 Descriptif

@ModelAttribute("user") User L'instruction user a deux fonctions :

  • Encapsuler l'entrée des paramètres de requête dans l'objet utilisateur
  • Créer une instance d'utilisateur

Il est stocké dans l'objet Model avec "user" comme valeur de clé, qui a la même fonction que l'instruction "model.addAttribute("user",user)". Si aucune valeur de clé n'est spécifiée, c'est-à-dire "@ModelAttribute User user", alors lors de la création d'une instance User, "user" est stocké comme valeur de clé dans l'objet Model, qui a la même fonction que "model.addAtttribute( Instruction "utilisateur", utilisateur)".

1.3 ModelAttribute+RequestMapping

  1. ModelAttributeController
@Controller
public class ModelAttributeController {
    
    
    // @ModelAttribute和@RequestMapping同时放在方法上 方法直接返回页面名称 会把类路径拼接到url中
    @RequestMapping("/index")
    @ModelAttribute("name")
    public String model(@RequestParam(required = false) String name) {
    
    
        return name;
    }
}

  1. index.jsp

    Le chemin de la requête est http://localhost:8080/j230101SpringMVC_war_exploded/index?name=admin Le paramètre name a une valeur

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>index</title>
</head>
<body>
    ${name}
</body>
</html

1.3.1 Descriptif

Lorsque les annotations @ModelAttribute et @RequestMapping sont appliquées simultanément aux méthodes, elles ont les effets suivants :

  1. La valeur de retour de la méthode sera stockée dans l'objet Model et la clé est la valeur de l'attribut value de ModelAttribute ;
  2. La valeur de retour de la méthode n'est plus le chemin d'accès de la méthode, et le chemin d'accès deviendra la valeur value de @RequestMapping, par exemple : @RequestMapping(value = "/index") La page redirigée est le index.jsp page;
  3. Lorsque vous utilisez cette méthode, n'ajoutez pas de chemin de classe, sinon cela pourrait provoquer des erreurs de chemin.

1.4 La différence entre Model et ModelAndView

  • Modèle : le paramètre par défaut qui existe dans chaque requête et sa méthode addAttribute() peuvent être utilisés pour transmettre la valeur du serveur à la page client.
  • ModelAndView : Contient deux parties, modèle et vue. Lorsque vous l'utilisez, vous devez l'instancier vous-même, utiliser Model pour transmettre des valeurs et vous pouvez également définir le nom de la vue.

1.5 Exercices

La méthode annotée avec @ModelAttribute sera appelée avant chaque méthode de traitement de requête de la classe contrôleur. Cette fonctionnalité peut être utilisée pour contrôler les autorisations de connexion.

  1. Contrôleur de base
public class BaseController {
    
    
    @ModelAttribute
    public void isLogin(HttpSession session) throws Exception {
    
    
        if (session.getAttribute("user") == null) {
    
    
            throw new Exception("没有权限");
        }
    }
}
  1. UtilisateurContrôleur
@RequestMapping("/user")
public class UserController extends BaseController {
    
    
    @RequestMapping("/selectAllUser")
    public String selectAllUser() {
    
    
        return "userList";
    }
}

Neuf, interaction de données Spring MVC JSON

Spring MVC doit convertir le format et le type des données transmises dans le processus de liaison de données. Il peut convertir des données de types tels que String et d'autres types de données tels que JSON. Nous utilisons la technologie FastJson d'Alibaba pour implémenter Spring MVC afin de traiter les données au format JSON. La page doit introduire jquery. Faites attention au filtrage des ressources (première méthode). Spring version 4.0.2 (les autres versions de package 4.3.13 sont trop basses, mais 4.0 ne prend pas en charge l'attribut name de requestmaping)

1. Cas

  1. Importer les dépendances dans le fichier pom.xml (importé avant)
<!-- 格式化对象，方便输出日志 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.1.41</version>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>${slf4j.version}</version>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>${slf4j.version}</version>
</dependency>
<!-- jackson -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.9.6</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-annotations</artifactId>
    <version>2.9.6</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.6</version>
</dependency>
  1. La valeur de retour de la méthode JSONController peut être définie comme une collection Map
@Controller
@RequestMapping("/json")
public class JSONController {
    
    
    @RequestMapping("/index")
    public String index() {
    
    
        return "index";
    }
    @RequestMapping("/testJson")
    @ResponseBody
    public User testJson(User user) {
    
    
        // 打印接收的 JSON数据
        System.out.println("username=" + user.getUsername() + ",password=" + user.getPassword());
        // 返回JSON格式的响应
        return user;
    }
}
  1. index.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
    <title>测试JSON交互</title>
    <script type="text/javaScript" src="../static/js/jquery-2.1.1.min.js"></script>
</head>
<body>
<form>
    用户名：<input type="text" name="username" id="username"/>
    <br>
    密码：<input type="password" name="password" id="password"/>
    <br>
    <input type="button" value="login" οnclick="login()"/>
</form>
</body>
<script type="text/javaScript">
    function login() {
        $.ajax({
            //请求路径
            url: "../json/testJson",
            //请求类型
            type: "post",
            //定义回调响应的数据格式为JSON字符串，该属性可以省略
            dataType: "json",
            //data表示发送的数据
            data: {
                username: $("#username").val(),
                password: $("#password").val(),
            },
            contentType: "application/x-www-form-urlencoded", //设置请求参数的格式
            processData: true, //设置ajax内部是否自动处理请求参数，默认为true，可省略，如果data给的是个js对象，要么不设置，要么设为true
            //成功响应的结果
            success: function (data) {
                if (data != null) {
                    alert("输入的用户名：" + data.username + "，密码：" + data.password);
                }
            },error:function () {
                alert("服务器错误");
            }
        });
    }
</script>
</html>

2, type de contenu

Il existe trois types courants de contentType :

// 普通表单提交的数据的格式为application/x-www-form-urlencoded
application/x-www-form-urlencoded
// 发送以ContentType为application/json格式的请求参数，需要把data的内容转为json格式，使用JSON.stringify(param)
application/json
// 上传文件时，请求消息将以multipart/form-data格式封装请求参数
multipart/form-data

// Pour envoyer des paramètres de requête avec ContentType au format application/json, vous devez convertir le contenu des données au format json, utilisez JSON.stringify(param)
application/json

Les variables peuvent être définies en ajax

laisser utilisateur = JSON.stringify({

​ nom d'utilisateur :$("nom d'utilisateur").val(),

​ mot de passe :$("mot de passe").val(),

});

Les données suivantes : peuvent être modifiées en :

data:user ; Pour passer au backend, vous devez utiliser l'annotation @requestBody dans les paramètres de la méthode backend pour obtenir une connexion vide publique (utilisateur @requestBodyUser)

10. Spring MVC Interceptor (Intercepteur)

​ L'intercepteur de Spring MVC est similaire au filtre de Java Servlet. Il est principalement utilisé pour intercepter les demandes des utilisateurs et effectuer le traitement correspondant. Il est généralement utilisé pour la vérification de l'autorité, la journalisation des informations de demande et pour juger si les utilisateurs sont connectés. Et autres fonctions.

1. Définir l'intercepteur

​ Définir un intercepteur, nous l'implémentons en implémentant l'interface HandlerInterceptor

1.1 Cas

  1. Implémenter l'interface HandlerInterceptor
public class MyInterceptor implements HandlerInterceptor {
    
    
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
    
    
        // 获取请求的URL
        String url = request.getRequestURI();
        // login.jsp或登录请求放行，不拦截
        if (url.indexOf("/goLogin") >= 0 || url.indexOf("/login") >= 0) {
    
    
            return true;
        }
        // 获取 session
        HttpSession session = request.getSession();
        Object obj = session.getAttribute("user");
        if (obj != null)
            return true;
        // 没有登录且不是登录页面，转发到登录页面，并给出提示错误信息
        request.setAttribute("msg", "还没登录，请先登录！");
        request.getRequestDispatcher("login").forward(request, response);
        return false;
    }
    @Override
    public void afterCompletion(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, Exception arg3) throws Exception {
    
    
    }
    @Override
    public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, ModelAndView arg3) throws Exception {
    
    
    }
}

La définition de l'intercepteur implémente l'interface HandlerInterceptor et implémente les trois méthodes dans l'interface, expliquées comme suit

  • preHandle( ) : cette méthode est exécutée avant la méthode de requête de traitement du contrôleur. Sa valeur de retour indique s'il faut interrompre l'opération suivante. Retourner true indique que l'exécution continue vers le bas, et retourner false indique que l'opération suivante est interrompue.
  • postHandle() : cette méthode est exécutée après l'appel de la méthode de demande de traitement du contrôleur et avant l'analyse de la vue. Cette méthode peut être utilisée pour modifier davantage le modèle et la vue dans le domaine de la demande.
  • afterCompletion() : cette méthode est exécutée après l'exécution de la méthode de demande de traitement du contrôleur, c'est-à-dire qu'elle est exécutée une fois le rendu de la vue terminé. Grâce à cette méthode, certaines tâches telles que le nettoyage des ressources et l'enregistrement des informations de journal peuvent être réalisées.
  1. intercepteur de configuration springmvc-servlet.xml
<!-- 配置拦截器 -->
<mvc:interceptors>
    <mvc:interceptor>
        <!-- 配置拦截器作用的路径 -->
        <mvc:mapping path="/**" />
        <bean class="com.hqyj.cl.utils.MyInterceptor" />
    </mvc:interceptor>
</mvc:interceptors>
  1. UtilisateurContrôleur
@Controller
@RequestMapping("/user")
public class UserController {
    
    
    // 登录页面初始化
    @RequestMapping("/goLogin")
    public String initLogin() {
    
    
        return "login";
    }

    // 处理登录功能
    @RequestMapping("/login")
    public String login(User user, HttpSession session) {
    
    
        if ("admin".equals(user.getUsername()) && "111".equals(user.getPassword())) {
    
    
            // 登录成功，将用户信息保存到session对象中
            session.setAttribute("user", user);
            // 重定向到主页面的跳转方法
            return "redirect:main";
        }
        return "login";
    }

    // 跳转到主页面
    @RequestMapping("/main")
    public String goMain() {
    
    
        return "main";
    }
    
    // 退出登录
    @RequestMapping("/logout")
    public String logout(HttpSession session) {
    
    
        // 清除 session
        session.invalidate();
        return "login";
    }
}
  1. login.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title></title>
</head>
<body>
${ msg }
<form action="../user/login" method="post">
    用户名：<input type="text" name="username" /><br>
    密码：<input type="password" name="password" /><br>
    <input type="submit" value="登录" />
</form>
</body>
</html>
  1. main.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title></title>
</head>
<body>
欢迎 ${ sessionScope.get("user").username }，登录！<br />
<a href="../user/logout">退出</a>
</body>
</html>

11. Téléchargement et téléchargement de fichiers

1. Téléchargement de fichier

  1. Ajoutez les dépendances suivantes au fichier pom.xml
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.4</version>
</dependency>
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.2.2</version>
</dependency>
  1. springmvc-servlet.xml
<!-- 配置MultipartResolver，用于上传文件，使用spring的CommonsMultipartResolver -->
<bean id="multipartResolver"
    class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <property name="maxUploadSize" value="5000000" />
    <property name="defaultEncoding" value="UTF-8" />
</bean>
  • defaultEncoding : Le format d'encodage de la requête, la valeur par défaut est ISO-8859-1, ici est défini sur UTF-8 (Remarque : defaultEncoding doit être cohérent avec pageEncoding dans JSP, afin de lire correctement le contenu du formulaire).
  • maxUploadSize : la limite supérieure de la taille du fichier téléchargé, en octets.
  1. soumission du formulaire fileUpload.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>文件上传</title>
</head>
<body>
    <form action="${pageContext.request.contextPath }/file/upload"
        method="post" enctype="multipart/form-data">
        选择文件：<input type="file" name="file"><br> 
        <input type="submit" value="提交">	
    </form>
</body>
</html>
  1. FichierContrôleur
@Controller
@RequestMapping("/file")
public class FileController {
    
    
    @RequestMapping("/upload")
    @ResponseBody
    public String upload(MultipartFile file, HttpServletRequest request) throws IOException {
    
    
        // 获取上传文件名
        String originalFileName = file.getOriginalFilename();
        // 得到当前的classpath的绝对路径的URI表示法
        String rootPath = Thread.currentThread().getContextClassLoader().getResource("").getPath();
        int index = rootPath.indexOf("target");
        String path = rootPath.substring(1,index) + "src/main/webapp/static/images/book";
        // 新文件
        File newFile = new File(path,originalFileName);
        // 判断目标文件所在目录是否存在
        if( !newFile.getParentFile().exists()) {
    
    
            // 如果目标文件所在的目录不存在，则创建父目录
            newFile.getParentFile().mkdirs();
        }
        // 将内存中的数据写入磁盘
        file.transferTo(newFile);
        return  "success";
    }
}

1.1 Extension

Téléchargement de fichier avec ajax

    <form id="uploadForm">
        <input type="file" name="file">
        <br>
        <input type="button" value="button" οnclick="upload()">
    </form>
    <script>
        function upload() {
            var formData = new FormData($("#uploadForm")[0]);
            // 发送ajax请求
            $.ajax({
                url:'/file/upload',
                type:"post",
                data:formData,
                processData : false,  //必须false才会避开jQuery对 formdata 的默认处理
                contentType : false,  //必须false才会自动加上正确的Content-Type
                success:function (data) {
                    console.log(data);
                },error:function () {
                    alert("服务器错误");
                }
            })
        }
    </script>

2. Téléchargement de fichiers

  1. fileDown.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>文件下载</title>
</head>
<body>
<form action="/file/down" method="get">
    <input type="submit" value="下载">
</form>
</body>
</html>
  1. FichierContrôleur
@RequestMapping("/down")
@ResponseBody
public String down(HttpServletResponse response) throws Exception{
    
    
    // 下载文件的路径
    String rootPath = Thread.currentThread().getContextClassLoader().getResource("").getPath();
	// 截取到需要的文件存放路径
    int index = rootPath.indexOf("target");
    String path = rootPath.substring(1,index) + "src/main/webapp/static/images/book";
    // 下载文件的名字，假设为banner_1.jpg
    String fileName = "banner_1.jpg";
    //获取输入流
    InputStream is = new BufferedInputStream(new FileInputStream(new File(path,fileName)));
    //转码，免得文件名中文乱码
    String filename = URLEncoder.encode(fileName,"UTF-8");
    //设置文件下载头
    response.addHeader("Content-Disposition", "attachment;filename=" + filename);
    //1.设置文件ContentType类型，这样设置，会自动判断下载文件类型
    response.setContentType("multipart/form-data");
    BufferedOutputStream out = new BufferedOutputStream(response.getOutputStream());
    int len = 0;
    while((len = is.read()) != -1){
    
    
        out.write(len);
        out.flush();
    }
    out.close();
    return "success";
}

12. Problème de filtrage des ressources SpringMVC

**Description du problème :** Dans le fichier web.xml, après avoir configuré le code suivant, toutes les URL de requête seront interceptées, y compris js, css et d'autres ressources statiques, ce qui nous empêche d'utiliser ces ressources statiques.

<!-- 部署 DispatcherServlet -->
<servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 表示容器再启动时立即加载servlet -->
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <!-- 处理所有URL -->
    <url-pattern>/</url-pattern>
</servlet-mapping>

** Une des solutions : ** Dans le fichier springmvc-servlet.xml, ajoutez le code suivant

<!-- 默认的注解映射，必须加，不然没办法兼顾二者 -->
<mvc:annotation-driven />
<!--配置静态资源放行 如果web.xml中servlet-name定义为default，则default-servlet-name="default"可以不写-->
<mvc:default-servlet-handler default-servlet-name="default"/>

Dans le fichier web.xml, ajoutez le code suivant

<servlet-mapping>
    <servlet-name>default</servlet-name>
    <!-- 处理所有URL -->
    <url-pattern>/static/*</url-pattern>
</servlet-mapping>

**Solution 2 : **Dans le fichier springmvc-servlet.xml, ajoutez le code suivant

<?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">
    <!-- 包扫描-->
    <context:component-scan base-package="com.hqyj.cl.controller"/>
    <!-- 默认的注解映射，必须加，不然没办法兼顾二者 -->
    <mvc:annotation-driven />
    <mvc:resources mapping="/static/**" location="/static/"/>
	<!-- interceptors -->  
    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <!-- 不拦截的请求 -->
            <mvc:exclude-mapping path="/static/**"/>
            <bean class="com.hqyj.cl.utils.MyInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>
    <!--配置视图解析器之InternalResourceViewResolver-->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--指定viewclass 必须指定-->
        <property name="viewClass" value="org.springframework.web.servlet.view.InternalResourceView"/>
        <!--前缀-->
        <property name="prefix" value="/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>
  • emplacement : signifie que le répertoire spécifié par l'emplacement ne doit pas être intercepté et demandé directement, ici fait référence à tous les fichiers sous le fichier de ressources dans le répertoire racine
  • mappage : fait référence à tous les fichiers sous le fichier de ressources (** représente tous les fichiers)

Je suppose que tu aimes

Origine blog.csdn.net/ailaohuyou211/article/details/130394223
conseillé
Classement
du quotidien
Plus
2024-05-18(31)
2024-05-17(4)
2024-05-16(25)
2024-05-15(5)
2024-05-14(11)
2024-05-13(7)
2024-05-12(22)
2024-05-11(31)
2024-05-10(33)
2024-05-09(31)

Code World

© 2018 codetd.com