Processus détaillé de création de l'environnement SpringMVC

Cet article vous présente le processus détaillé de création de l'environnement SpringMVC. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il vous sera utile.

Spring MVC fournit un excellent framework Web basé sur le concept de conception MVC pour la couche de présentation. Il s'agit actuellement de l'un des frameworks MVC les plus courants.

Après Spring 3.0, il a complètement dépassé Struts2 et est appelé le meilleur framework MVC. Après avoir appris SpringMVC, vous ressentirez la cruauté que Struts2 vous apporte en un instant.

Spring MVC utilise un ensemble d'annotations MVC pour faire de POJO un contrôleur pour le traitement des requêtes. Il n'est pas nécessaire d'implémenter d'interface et le degré de couplage est faible.

Et Spring MVC offre un bon support pour le style de repos. .

Utilise une structure de composants enfichables faiblement couplés, qui est plus extensible et flexible que les autres frameworks MVC.

Créez un environnement Spring MVC

1) Créez un environnement MVC basé sur la méthode d'interface. Implémentez l'interface du contrôleur pour implémenter MVC

2) Sur la base de la méthode d'annotation, dans Spring 3.0 et les versions ultérieures, l'utilisation d'annotations simplifie grandement la configuration MVC traditionnelle, et la flexibilité et la maintenabilité sont grandement améliorées.

Pour implémenter SpringMVC, la première étape consiste à importer le package jar correspondant

Ensuite, c'est avec Struts2 également configurer un contrôleur principal dans Web.xml. Utilisé pour intercepter les requêtes.

<!-- 配置SpringMVC的请求的Servlet -->
  <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:applicationContext.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>

Vous sentez-vous familier lorsque vous voyez cela, ce ne sont que quelques lignes de plus que Struts2. init-param est le fichier Spring à charger lors de l'initialisation. S'il y a plusieurs fichiers, vous pouvez utiliser des virgules pour les séparer

load-on-startup sera chargé immédiatement au démarrage. /Intercepter toutes les demandes. (En même temps, css et js seront également interceptés)

Ensuite, nous écrivons un Controller

package com.miya.spring.mvc.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/Miya")
public class MiyaHelloController {

    @RequestMapping("/hello")
    public String hello(){
        System.out.println("hello Miya");
        return "/hello";
    }
}

Annotation @Controller Sans plus tarder, déclarons un contrôleur.

@RequestMapping est défini sur la classe pour déclarer un espace. Au-dessus de la méthode, déclarez un chemin de requête

et renvoyez une chaîne Où est le chemin auquel vous souhaitez accéder ?

<context:component-scan base-package="com.miya.spring.mvc"/>
    
    <!-- 视图解析器 -->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 前缀 -->
        <property name="prefix" value="/WEB-INF/views"/>
        <!-- 后缀 -->
        <property name="suffix" value=".jsp"/>
    </bean>

Dans notre configuration Spring XML, nous analysons d'abord toutes les annotations, puis configurons un analyseur de vue.

Quand nous renvoyons ce bonjour, c'est préfixe + résultat(bonjour) + suffixe pour accéder à notre vue.

Essayons maintenant de l'exécuter directement dans index.jsp.

<%
response.sendRedirect(request.getContextPath() + "/Miya/hello");    
%>

request.getContextPath() obtient le chemin racine de votre projet Web, qui est webContent (webRoot dans MyEclipse). Ensuite, vous pouvez maintenant voir notre espace de noms Miya suivi du chemin de requête de méthode

hello qui y est défini. L'adresse que nous avons finalement visitée http://localhost:8080/SpringMvcDemo1/Miya/hello a accédé au fichier WEB-INF/views/hello.jsp. Et cette demande est toujours une demande de style repos.

Quand vous arriverez ici, vous constaterez que c'est beaucoup plus pratique que Struts2. Chaque demande de configuration dans Struts2 nécessite que vous configuriez de nombreuses actions dans Struts2, et parfois il y a des milliers de lignes dans le fichier stuts. , et vous êtes trop vieux pour en trouver un. La demande a pris une demi-heure.

Une autre façon de l'implémenter est d'implémenter l'interface Controller fournie par Spring et de réécrire les méthodes dans l'interface.

package com.miya.spring.mvc.controller;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;
public class MiyaWordController implements Controller{
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("/hello");
        return modelAndView;
    }
}

Vous pouvez définir la vue dans ModelAndView. Ce que j'ai défini, c'est bonjour. Ensuite, nous devons configurer un bean au printemps. XML. , name est le chemin de la requête, class est la classe du contrôleur spécifiée

<bean name="/Miya/word" class="com.miya.spring.mvc.controller.MiyaWordController"></bean>

Remarque : nous avons intercepté toutes les requêtes du projet, ce qui entraînera des images, des styles. , et JS pour être bloqué Rapport 404, nous pouvons utiliser spring. Les fichiers de ressources externes sont introduits dans XML, et cette façon d'implémenter les interfaces entraîne un couplage trop élevé, et chaque fonction doit être écrite dans une classe, ce qui rend notre code volumineux. Il est donc recommandé d'utiliser des annotations actuellement. populaire. Et de nombreux frameworks prennent en charge les méthodes d'annotation, et la syntaxe est simple, ce qui rend le code concis.

<!-- 引入外部样式 -->
<mvc:resources location="/css/" mapping="/css/**"></mvc:resources>

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!