Il suffit d'apprendre l'intégration de l'environnement Spring et Web et le démarrage rapide de SpringMVC

Language 2022-04-20 08:39:17 views: null

Il suffit d'apprendre l'intégration de l'environnement Spring et Web et le démarrage rapide de SpringMVC

Baojianfeng vient de l'affûtage et le parfum des fleurs de prunier vient du froid glacial.
--encouragement mutuel

Environnement Web intégré Spring

1.1 ApplicationContext Méthode d'acquisition du contexte d'application

L'objet de contexte d'application est obtenu via new ClasspathXmlApplicationContext (fichier de configuration Spring), mais chaque fois qu'un bean est obtenu à partir du conteneur, newClasspathXmlApplicationContext (fichier de configuration Spring) doit être écrit. L'inconvénient est que le
fichier de configuration est chargé plusieurs fois, et l'objet de contexte d'application est créé plusieurs fois.
Dans un projet Web, ServletContextListener peut être utilisé pour surveiller le démarrage de l'application Web. Lorsque l'application Web démarre, nous pouvons charger le fichier de configuration Spring, créer l'objet de contexte d'application ApplicationContext et le stocker dans le plus grand domaine servletContext de domaine, donc que nous pouvons obtenir l'objet ApplicationContext du contexte d'application du domaine n'importe où.

1.2 Spring fournit des outils pour obtenir le contexte de l'application

L'analyse ci-dessus n'a pas besoin d'être implémentée manuellement. Spring fournit un écouteur ContextLoaderListener qui encapsule les fonctions ci-dessus. L'écouteur charge les fichiers de configuration Spring, crée des objets de contexte d'application et les stocke dans le domaine ServletContext. Un outil client WebApplicationContextUtils est fourni pour The l'utilisateur obtient l'objet de contexte d'application.

Il n'y a donc que deux choses à faire :
① Configurer l'écouteur ContextLoaderListener dans web.xml (importer les coordonnées spring-web)
② Utiliser WebApplicationContextUtils pour obtenir l'objet de contexte d'application ApplicationContext

1.3 Importer les coordonnées du web intégré Spring

<dependency>
 <groupId>org.springframework</groupId> 
 <artifactId>spring-web</artifactId>
  <version>5.0.5.RELEASE</version>
</dependency>

1.4 Configurer l'écouteur ContextLoaderListener

<!--全局参数-->
 <context-param>
  <param-name>contextConfigLocation</param-name> 
  <param-value>classpath:applicationContext.xml</param-value>
</context-param>
<!--Spring的监听器--> <listener> 
<listener-class>org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>

1.5 Obtention d'objets de contexte d'application via des outils

ApplicationContext applicationContext = WebApplicationContextUtils.getWebApplicationContext(servletContext);
Object obj = applicationContext.getBean("id");

SpringMVC

Présentation de SpringMVC

SpringMVC est un framework Web léger piloté par les requêtes basé sur Java qui implémente le modèle de conception MVC. Il s'agit d'un produit de suivi de SpringFrameWork et a été intégré à Spring Web Flow.
SpringMVC est devenu l'un des frameworks MVC les plus courants et, avec la sortie de Spring3.0, il a dépassé Struts2 de manière globale et est devenu le meilleur framework MVC. Il utilise un ensemble d'annotations pour faire d'une simple classe Java un contrôleur permettant de gérer les requêtes sans avoir à implémenter d'interface. Il prend également en charge les demandes de style de programmation RESTful.

Démarrage rapide de SpringMVC

Exigence : le client initie la requête, le serveur reçoit la requête, exécute la logique et effectue un saut de vue.

Étapes de développement :
① Importer les coordonnées liées à SpringMVC
② Configurer le contrôleur principal SpringMVC DispathcerServlet
③ Créer une classe Controller et afficher la page
④ Utiliser des annotations pour configurer l'adresse de mappage des méthodes métier dans la classe Controller
⑤ Configurer le fichier principal SpringMVC spring-mvc.xml
⑥ Le client lance la requête test

① Importer les coordonnées de Spring et SpringMVC

<!--Spring坐标-->
 <dependency>
  <groupId>org.springframework</groupId> 
  <artifactId>spring-context</artifactId> <version>5.0.5.RELEASE</version>
</dependency>
<!--SpringMVC坐标--> <dependency> 
<groupId>org.springframework</groupId>
 <artifactId>spring-webmvc</artifactId>
  <version>5.0.5.RELEASE</version>
</dependency>

① Importer les coordonnées de Servlet et Jsp

<!--Servlet坐标-->
 <dependency> 
 <groupId>javax.servlet</groupId>
  <artifactId>servlet-api</artifactId>
   <version>2.5</version>
</dependency>
<!--Jsp坐标--> 
<dependency> 
<groupId>javax.servlet.jsp</groupId>
 <artifactId>jsp-api</artifactId>
  <version>2.0</version>
</dependency>

② Configurer le contrôleur principal de SpringMVC dans web.xml

<servlet> 
<servlet-name>DispatcherServlet</servlet-name> 
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> 
<init-param> 
<param-name>contextConfigLocation</param-name>
 <param-value>classpath:spring-mvc.xml</param-value>
</init-param> 
<load-on-startup>1</load-on-startup>
</servlet>
 
 <servlet-mapping>
  <servlet-name>DispatcherServlet</servlet-name> 
 <url-pattern>/</url-pattern>
</servlet-mapping>

③ Créer un contrôleur et une méthode commerciale

public class QuickController {
    
    
public String quickMethod(){
    
    
System.out.println("quickMethod running.....");
return "index"; } }

③ Créer la page de vue index.jsp

<html>
 <body><h2>Hello SpringMVC!</h2>
</body>
</html>

④ Remarques sur la configuration

@Controller
public class QuickController {
    
    
@RequestMapping("/quick")
public String quickMethod(){
    
    
System.out.println("quickMethod running.....");
return "index"; } }

⑤ Créer spring-mvc.xml

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
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
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<!--配置注解扫描--> <context:component-scan base-package="com.itheima"/>
</beans>

Diagramme de processus SpringMVC

insérez la description de l'image ici

Résolution du composant SpringMVC

Le flux d'exécution de SpringMVC

insérez la description de l'image ici
① L'utilisateur envoie une requête au contrôleur frontal DispatcherServlet.
② DispatcherServlet reçoit la demande et appelle le mappeur de processeur HandlerMapping.
③ Le mappeur de processeur trouve un processeur spécifique (qui peut être recherché en fonction de la configuration XML et des annotations), génère un objet processeur et un intercepteur de processeur (le cas
échéant, génère) et le renvoie à DispatcherServlet.
④ DispatcherServlet appelle l'adaptateur de processeur HandlerAdapter.
⑤ HandlerAdapter est adapté pour appeler un processeur spécifique (Controller, également appelé contrôleur back-end).
⑥ L'exécution du contrôleur se termine et revient à ModelAndView.
⑦ HandlerAdapter renvoie le résultat d'exécution du contrôleur ModelAndView à DispatcherServlet.
⑧ DispatcherServlet passe ModelAndView au résolveur de vue ViewReslover.
⑨ ViewReslover renvoie la vue spécifique après l'analyse.
⑩ DispatcherServlet rend la vue en fonction de la vue (c'est-à-dire remplit les données du modèle dans la vue). Le DispatcherServlet répond à l'utilisateur.

Analyse des composants SpringMVC

  1. Contrôleur frontal :
    les demandes des utilisateurs de DispatcherServlet atteignent le contrôleur frontal, ce qui équivaut à C dans le modèle MVC. DispatcherServlet est le centre de l'ensemble du contrôle de processus, qui appelle d'autres composants pour traiter les demandes des utilisateurs. L'existence de DispatcherServlet réduit le couplage entre composants sexe

  2. Mappeur de gestionnaire : HandlerMapping
    HandlerMapping est chargé de trouver le gestionnaire, c'est-à-dire le gestionnaire selon la demande de l'utilisateur. SpringMVC fournit différents mappeurs pour implémenter différentes méthodes de mappage, telles que : la méthode du fichier de configuration, la méthode de l'interface d'implémentation, la méthode d'annotation, etc.

  3. Adaptateur de gestionnaire : HandlerAdapter
    exécute le processeur via HandlerAdapter, qui est l'application du mode adaptateur, et d'autres types de processeurs peuvent être exécutés en étendant l'adaptateur.

  4. Handler : Handler
    C'est le contrôleur métier spécifique à écrire dans notre développement. La demande de l'utilisateur est transmise au gestionnaire par le DispatcherServlet. Le gestionnaire gère les demandes spécifiques des utilisateurs.

  5. Résolveur de vue : résolveur
    de vue Le résolveur de vue est responsable de la génération de la vue de vue à partir du résultat du traitement. Le résolveur de vue résout d'abord le nom de la vue logique en nom de vue physique, c'est-à-dire l'adresse de page spécifique, puis génère l'objet de vue de vue, et rend enfin la vue pour transmettre le résultat du traitement. La page est affichée à l'utilisateur.

  6. View : View
    Le framework SpringMVC prend en charge de nombreux types de vues View, notamment : jstlView, freemarkerView, pdfView, etc. La vue la plus couramment utilisée est jsp. En général, les données de modèle doivent être affichées aux utilisateurs via des balises de page ou une technologie de modèle de page, et des pages spécifiques doivent être développées par les programmeurs en fonction des besoins de l'entreprise.

Analyse des annotations SpringMVC

Rôle @RequestMapping
 : utilisé pour établir la relation correspondante entre l'URL de la requête et la méthode de traitement de la requête
. Emplacement :

  1. class, le répertoire d'accès de premier niveau pour l'URL de la requête. S'il n'est pas écrit ici, il équivaut au répertoire racine de l'application
  2. En termes de méthode, le répertoire d'accès de second niveau de l'URL de requête est combiné avec le répertoire de premier niveau marqué par @ReqquestMapping sur la classe pour former un chemin virtuel d'accès

Les attributs:

  1. valeur : l'URL utilisée pour spécifier la requête. Il a la même fonction que l'attribut path
    2.method : permet de spécifier la méthode de la requête
    3.params : permet de spécifier les conditions de limitation des paramètres de la requête. Il prend en charge les expressions simples. Il est nécessaire que la clé et la valeur du paramètre de requête soient exactement les mêmes que la configuration

Par exemple :
params = {"accountName"}, indiquant que le paramètre de requête doit avoir accountName
params = {"moeny ! 100"}, indiquant que l'argent dans le paramètre de requête ne peut pas être 100

Présentation de l'espace de noms mvc

命名空间：xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
约束地址：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

SpringMVC est basé sur le conteneur Spring, donc lorsque vous effectuez des opérations SpringMVC, vous devez stocker le contrôleur dans le conteneur Spring. Si vous
utilisez l' annotation @Controller, vous devez utiliser <context:component-scan base-package="com. itheima.controller" /> effectue une analyse des composants.

Configuration du résolveur de vues SpringMVC

SpringMVC a une configuration de composants par défaut. Les composants par défaut sont configurés dans le fichier de configuration DispatcherServlet.properties. L'adresse du fichier de configuration est
org/springframework/web/servlet/DispatcherServlet.properties. L'analyseur de vue par défaut est configuré dans ce fichier, comme suit :

org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver

En regardant le code source de l'analyseur, vous pouvez voir les paramètres par défaut de l'analyseur, comme suit :

REDIRECT_URL_PREFIX = "redirect:" --重定向前缀
FORWARD_URL_PREFIX = "forward:" --转发前缀（默认值）
prefix = ""; --视图名称前缀
suffix = ""; --视图名称后缀

Nous pouvons modifier le préfixe et le suffixe de la vue par injection de propriété

<!--配置内部资源视图解析器-->
 <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> 
<property name="prefix" value="/WEB-INF/views/"></property> <
property name="suffix" value=".jsp"></property>
</bean>

Je suppose que tu aimes

Origine blog.csdn.net/JIAYOUYAA/article/details/124173328
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