Spring - Présentation du framework MVC

Le framework Spring Web MVC fournit une architecture modèle-vue-contrôleur 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 HTML sortie que le navigateur du client peut interpréter.
le Controller est responsable du traitement User Requests et Building Appropriate Model 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 l'illustration suivante.

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 le HandlerMapping pour appeler le contrôleur approprié.
Le contrôleur prend la demande et appelle les méthodes de service appropriées en fonction des GET ou POST method. 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 les navigateurs.

Tous les composants mentionnés ci-dessus, à savoir HandlerMapping, Controller et ViewResolver font partie de WebApplicationContext, qui est une extension de la plaine ApplicationContext avec quelques fonctionnalités supplémentaires nécessaires pour les applications Web.

Configuration requise

Nous devons mapper les demandes que vous souhaitez que DispatcherServlet gère, en utilisant un mappage d'URL dans le web.xmlfichier. Voici un exemple pour montrer la déclaration et le mappage pourHelloWeb 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.xml le fichier sera conservé dans le WebContent/WEB-INFrépertoire de votre application Web. Lors de l'initialisation duHelloWeb 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 seraHelloWeb-servlet.xml.

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

Si vous ne souhaitez pas utiliser le nom de fichier par défaut comme [servlet-name]-servlet.xml et l'emplacement par défaut en tant que 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.xml fichier, 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 quelques points importants sur HelloWeb-servlet.xml fichier -

le [servlet-name]-servlet.xml fichier 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.
le <context:component-scan...> tag sera utilisé pour activer la capacité d'analyse des annotations Spring MVC, qui permet d'utiliser des annotations telles que @Controller et @RequestMapping, etc.
le InternalResourceViewResolveraura 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éehello est déléguée à une implémentation de vue située à /WEB-INF/jsp/hello.jsp.

Voyons maintenant comment créer les 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 /hello chemin.

La prochaine annotation @RequestMapping (method = RequestMethod.GET) est utilisé pour déclarer le printHello()comme méthode de service par défaut du contrôleur pour gérer la requête HTTP GET. Nous pouvons définir une autre méthode pour gérer toute requête POST à la même URL.

Nous pouvons également écrire le contrôleur ci-dessus sous une autre forme, où nous pouvons ajouter des attributs supplémentaires dans le @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 method L'attribut définit la méthode de service pour gérer la requête HTTP GET.

Voici quelques points importants à noter concernant le 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 l'exigence.
En fonction de la logique métier définie, vous allez créer un modèle dans cette méthode. Vous pouvez définir différents attributs de modèle et ces attributs seront accessibles par la vue pour présenter le résultat. 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 "bonjour" 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 inclus -JSPs, HTML, PDF, Excel Worksheets, XML, Velocity Templates, XSLT, JSON, Atom et RSS nourrit, JasperReports, etc. Cependant, les plus courants sont les modèles JSP écrits avec JSTL. Alors, écrivons une simple vue Hello dans /WEB-INF/hello/hello.jsp -

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

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