Spring - Framework MVC

Le framework Spring Web MVC fournit une architecture Model-View-Controller (MVC) et des composants prêts à l'emploi qui peuvent être utilisés pour développer des applications Web flexibles et faiblement couplées. Le modèle MVC permet de séparer les différents aspects de l'application (logique d'entrée, logique métier et logique d'interface utilisateur), tout en fournissant un couplage lâche entre ces éléments.

le Model encapsule les données de l'application et en général, elles seront constituées de POJO.
le View est responsable du rendu des données du modèle et en général, il génère une sortie HTML que le navigateur du client peut interpréter.
le Controller est responsable du traitement des demandes des utilisateurs et de la construction d'un modèle approprié et le transmet à la vue pour le rendu.

Le DispatcherServlet

Le framework MVC (Spring Web model-view-controller) est conçu autour d'un DispatcherServlet qui gère toutes les requêtes et réponses HTTP. Le flux de travail de traitement des demandes de Spring Web MVC DispatcherServlet est illustré dans le diagramme suivant:

Voici la séquence d'événements correspondant à une requête HTTP entrante à DispatcherServlet -

Après avoir reçu une requête HTTP, DispatcherServlet consulte HandlerMapping pour appeler le contrôleur approprié .
Le contrôleur prend la demande et appelle les méthodes de service appropriées en fonction de la méthode GET ou POST utilisée. La méthode de service définit les données du modèle en fonction de la logique métier définie et renvoie le nom de la vue au DispatcherServlet .
Le DispatcherServlet prendra l'aide de ViewResolver pour récupérer la vue définie pour la demande.
Une fois la vue finalisée, le DispatcherServlet transmet les données du modèle à la vue qui est finalement rendue sur le navigateur.

Tous les composants mentionnés ci-dessus, c'est-à-dire HandlerMapping, Controller et ViewResolver, font partie de WebApplicationContext w qui est une extension du simple ApplicationContext avec quelques fonctionnalités supplémentaires nécessaires pour les applications Web.

Configuration requise

Vous devez mapper les demandes que vous souhaitez que DispatcherServlet gère, en utilisant un mappage d'URL dans leweb.xmlfichier. Voici un exemple pour montrer la déclaration et le mappage pourHelloWeb Exemple de DispatcherServlet -

<web-app id = "WebApp_ID" version = "2.4"
   xmlns = "http://java.sun.com/xml/ns/j2ee" 
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://java.sun.com/xml/ns/j2ee 
   http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
    
   <display-name>Spring MVC Application</display-name>
   
   <servlet>
      <servlet-name>HelloWeb</servlet-name>
      <servlet-class>
         org.springframework.web.servlet.DispatcherServlet
      </servlet-class>
      <load-on-startup>1</load-on-startup>
   </servlet>

   <servlet-mapping>
      <servlet-name>HelloWeb</servlet-name>
      <url-pattern>*.jsp</url-pattern>
   </servlet-mapping>

</web-app>

le web.xmlLe fichier sera conservé dans le répertoire WebContent / WEB-INF de votre application Web. Lors de l'initialisation deHelloWeb DispatcherServlet, le framework essaiera de charger le contexte d'application à partir d'un fichier nommé [servlet-name]-servlet.xmlsitué dans le répertoire WebContent / WEB-INF de l'application. Dans ce cas, notre fichier seraHelloWebservlet.xml.

Ensuite, la balise <servlet-mapping> indique quelles URL seront gérées par quel DispatcherServlet. Ici toutes les requêtes HTTP se terminant par.jsp sera géré par le HelloWeb DispatcherServlet.

Si vous ne souhaitez pas utiliser le nom de fichier par défaut comme [nom-servlet] -servlet.xml et l'emplacement par défaut comme WebContent / WEB-INF , vous pouvez personnaliser ce nom et cet emplacement de fichier en ajoutant l'écouteur de servlet ContextLoaderListener dans votre fichier web.xml comme suit -

<web-app...>

   <!-------- DispatcherServlet definition goes here----->
   ....
   <context-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>/WEB-INF/HelloWeb-servlet.xml</param-value>
   </context-param>

   <listener>
      <listener-class>
         org.springframework.web.context.ContextLoaderListener
      </listener-class>
   </listener>
   
</web-app>

Maintenant, vérifions la configuration requise pour HelloWeb-servlet.xmlfichier, placé dans le répertoire WebContent / WEB-INF de votre application Web -

<beans xmlns = "http://www.springframework.org/schema/beans"
   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-3.0.xsd
   http://www.springframework.org/schema/context 
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:component-scan base-package = "com.tutorialspoint" />

   <bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
      <property name = "prefix" value = "/WEB-INF/jsp/" />
      <property name = "suffix" value = ".jsp" />
   </bean>

</beans>

Voici les points importants sur HelloWeb-servlet.xml fichier -

Le fichier [servlet-name] -servlet.xml sera utilisé pour créer les beans définis, en remplaçant les définitions de tous les beans définis avec le même nom dans la portée globale.
La balise <context: component-scan ...> sera utilisée pour activer la capacité d'analyse des annotations Spring MVC qui permet d'utiliser des annotations telles que @Controller et @RequestMapping, etc.
Le InternalResourceViewResolver aura des règles définies pour résoudre les noms de vue. Conformément à la règle définie ci-dessus, une vue logique nomméehelloest déléguée à une implémentation de vue située dans /WEB-INF/jsp/hello.jsp .

La section suivante vous montrera comment créer vos composants réels, c'est-à-dire le contrôleur, le modèle et la vue.

Définition d'un contrôleur

Le DispatcherServlet délègue la demande aux contrôleurs pour exécuter la fonctionnalité qui lui est spécifique. le@ControllerL'annotation indique qu'une classe particulière joue le rôle d'un contrôleur. le@RequestMapping L'annotation est utilisée pour mapper une URL vers une classe entière ou une méthode de gestionnaire particulière.

@Controller
@RequestMapping("/hello")
public class HelloController { 
   @RequestMapping(method = RequestMethod.GET)
   public String printHello(ModelMap model) {
      model.addAttribute("message", "Hello Spring MVC Framework!");
      return "hello";
   }
}

le @Controllerl'annotation définit la classe comme un contrôleur Spring MVC. Ici, la première utilisation de@RequestMapping indique que toutes les méthodes de manipulation de ce contrôleur sont relatives à la /hellochemin. Annotation suivante@RequestMapping(method = RequestMethod.GET)est utilisé pour déclarer la méthodeprintHello () comme méthode de service par défaut du contrôleur pour gérer la requête HTTP GET. Vous pouvez définir une autre méthode pour gérer toute requête POST à la même URL.

Vous pouvez écrire le contrôleur ci-dessus sous une autre forme où vous pouvez ajouter des attributs supplémentaires dans @RequestMapping comme suit -

@Controller
public class HelloController {
   @RequestMapping(value = "/hello", method = RequestMethod.GET)
   public String printHello(ModelMap model) {
      model.addAttribute("message", "Hello Spring MVC Framework!");
      return "hello";
   }
}

le value L'attribut indique l'URL vers laquelle la méthode du gestionnaire est mappée et le methodL'attribut définit la méthode de service pour gérer la requête HTTP GET. Les points importants suivants doivent être notés à propos du contrôleur défini ci-dessus -

Vous définirez la logique métier requise dans une méthode de service. Vous pouvez appeler une autre méthode à l'intérieur de cette méthode selon les besoins.
En fonction de la logique métier définie, vous allez créer un modèle dans cette méthode. Vous pouvez utiliser différents attributs de modèle de setter et ces attributs seront accessibles par la vue pour présenter le résultat final. Cet exemple crée un modèle avec son attribut "message".
Une méthode de service définie peut renvoyer une chaîne, qui contient le nom du viewà utiliser pour rendre le modèle. Cet exemple renvoie "hello" comme nom de vue logique.

Création de vues JSP

Spring MVC prend en charge de nombreux types de vues pour différentes technologies de présentation. Ceux-ci incluent - JSP, HTML, PDF, feuilles de calcul Excel, XML, modèles Velocity, XSLT, JSON, Atom et flux RSS, JasperReports, etc. Mais le plus souvent, nous utilisons des modèles JSP écrits avec JSTL.

Écrivons un simple hello voir dans /WEB-INF/hello/hello.jsp -

<html>
   <head>
      <title>Hello Spring MVC</title>
   </head>
   
   <body>
      <h2>${message}</h2>
   </body>
</html>

Ici ${message}est l'attribut que nous avons configuré dans le contrôleur. Vous pouvez avoir plusieurs attributs à afficher dans votre vue.

Exemples de framework Spring Web MVC

Sur la base des concepts ci-dessus, laissez-nous vérifier quelques exemples importants qui vous aideront à créer vos applications Web Spring -

Sr.No.	Exemple et description
1	Exemple Spring MVC Hello World Cet exemple explique comment écrire une application Spring Web Hello World simple.
2	Exemple de gestion de formulaire Spring MVC Cet exemple explique comment écrire une application Web Spring à l'aide de formulaires HTML pour soumettre les données au contrôleur et afficher un résultat traité.
3	Exemple de redirection de page Spring Apprenez à utiliser la fonctionnalité de redirection de page dans Spring MVC Framework.
4	Exemple de pages statiques de printemps Apprenez à accéder aux pages statiques avec les pages dynamiques dans Spring MVC Framework.
5	Exemple de gestion des exceptions de ressort Apprenez à gérer les exceptions dans Spring MVC Framework.

↰ Previous page Next page ↱