[SpringMVC desde la entrada hasta el tutorial de combate real] Capítulo 2 Introducción a SpringMVC

2. Introducción a SpringMVC

2.1 Construyendo un proyecto SpringMVC

2.1.1 Crear un proyecto WEB

2.1.2 Importar paquete jar de Spring

    Entre ellos, spring-webmvc-4.3.18.RELEASE.jar es el paquete jar principal de SpringMVC.

Método 1: Importar paquete jar

 Método 2: configuración de dependencia maven

<dependencies>
    <!-- spring核心包-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>4.3.18.RELEASE</version>
    </dependency>
    <!-- springbean包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>4.3.18.RELEASE</version>
    </dependency>
    <!-- springcontext包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.3.18.RELEASE</version>
    </dependency>
    <!-- spring表达式包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-expression</artifactId>
        <version>4.3.18.RELEASE</version>
    </dependency>
    <!-- springAOP包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>4.3.18.RELEASE</version>
    </dependency>
    <!-- springAspects包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>4.3.18.RELEASE</version>
    </dependency>
    <!-- spring对web的支持 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
        <version>4.3.18.RELEASE</version>
    </dependency>
    <!-- springwebMVC -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>4.3.18.RELEASE</version>
    </dependency>

    <!-- 配置javaweb环境 -->
    <!-- servlet-api -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>3.1.0</version>
        <scope>provided</scope>
    </dependency>
    <!-- jsp-api -->
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>jsp-api</artifactId>
        <version>2.1</version>
        <scope>provided</scope>
    </dependency>
    <!-- jstl -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>
</dependencies>

2.1.3 Configurar controlador frontal

    Spring MVC se basa en Servlet, y DispatcherServlet es el núcleo de todo el marco Spring MVC, principalmente responsable de interceptar solicitudes y enviarlas a los procesadores correspondientes para su procesamiento. Entonces, para configurar Spring MVC, primero debe definir DispatcherServlet. Como con todos los servlets, el usuario debe estar configurado en web.xml.
    
    Cuando se inicializa Spring MVC, buscará los archivos de configuración en el directorio WEB-INF de la aplicación. La regla de nomenclatura de los archivos de configuración es "servletName-servlet.xml", como springmvc-servlet.xml.

    También puede almacenar el archivo de configuración de Spring MVC en cualquier lugar del directorio de la aplicación, pero necesita usar el elemento init-param del servlet para cargar el archivo de configuración y especificar la ubicación del archivo de configuración de Spring MVC a través del parámetro contextConfigLocation. código de muestra es el siguiente.

Configure el controlador frontal en web.xml:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <!-- 1、配置前端控制器 -->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--
            springmvc的核心配置文件，格式与spring的applicationContext.xml一致
            默认路径：/WEB-INF/[前端控制器Servlet的名称]-servlet.xml
            4、自定义springmvc配置文件的名称和位置：
            通过Servlet的初始化参数，修改springmvc的配置文件的路径和名称
        -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
        <!-- 3、配置服务器启动时初始化前端控制器-->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <!--
            2、配置进入Spring MVC的请求
            第一种：*.后缀名，表示由DispatcherServlet进行解析以某种扩展名结尾的请求路径。
                    例如：*.do,*.action,*.abc..但是不能配置*.jsp,*.css,*.js等视图类型的后缀或静态资源后缀
                    优点：不会导致静态资源的拦截（静态资源的访问不会进入springmvc的流程），无需单独排除静态资源
                    缺点：不支持RESTful风格的开发
            第二种：/，表示所有的访问服务器的路径都进入Spring MVC的流程中（.jsp文件除外）。
                    优点：支持RESTful风格的开发
                    缺点：当访问静态资源时，因没有相应的处理类，会报出404的错误，需要单独排除静态资源
            注意：/*，此种在Spring MVC中是错误的配置，因为它会拦截所有的静态资源，以及jsp文件。
        -->
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>*.action</url-pattern>
    </servlet-mapping>
</web-app>

Análisis de configuración:

    contextConfigLocation: especifica la ubicación de carga de la configuración de springmvc.Si no se especifica, la carga predeterminada es /WEB-INF/[nombre del servlet]-servlet.xml. Por ejemplo: springmvc-servlet.xml.
    
    patrón de URL: proporcione la ruta de la solicitud para que DispatcherServlet la procese.
        El primer tipo: \*.do, que es analizado por DispatcherServlet y termina con una cierta extensión, lo que no hará que se intercepten los recursos estáticos (jpg, js, css).
        El segundo tipo: /, por lo que DispatcherServlet analiza la dirección a la que se accede, y el análisis de archivos estáticos debe configurarse para evitar que DispatcherServlet analice. De esta manera, se puede realizar una URL de estilo RESTful.
        El tercer tipo: /*, esta configuración es incorrecta. Con esta configuración, cuando finalmente se reenvía a una página jsp, DispatcherServlet seguirá resolviendo la dirección jsp. Si no se puede encontrar el controlador de acuerdo con la página jsp, aparecerá un error. ser informado

2.1.4 Configurar el asignador de procesadores

Configure el asignador de procesadores en el archivo de configuración springmvc:

<?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:util="http://www.springframework.org/schema/util"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/util
       http://www.springframework.org/schema/util/spring-util.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 配置处理器映射器 -->
    <!--
        所有的处理器映射器都实现HandlerMapping接口
        BeanNameUrlHandlerMapping：根据处理器bean标签中name属性值来与请求路径匹配查找相应的处理器对象
    -->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
</beans>

2.1.5 Configurar adaptador de procesador

<!-- 配置处理器适配器 -->
<!--
  所有的处理器适配器都实现HandlerAdapter接口
  SimpleControllerHandlerAdapter：要求在编写处理器时，必须实现org.springframework.web.servlet.mvc.Controller接口
-->
<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

Al ver el código original:

public class SimpleControllerHandlerAdapter implements HandlerAdapter {
    public SimpleControllerHandlerAdapter() {
    }

    public boolean supports(Object handler) {
        return handler instanceof Controller;
    }

    public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return ((Controller)handler).handleRequest(request, response);
    }

    public long getLastModified(HttpServletRequest request, Object handler) {
        return handler instanceof LastModified ? ((LastModified)handler).getLastModified(request) : -1L;
    }
}

    Este adaptador puede ejecutar controladores que implementan la interfaz org.springframework.web.servlet.mvc.Controller.

2.1.6 Controlador de desarrollo

La interfaz del controlador debe implementarse para que el adaptador SimpleControllerHandlerAdapter la ejecute:

/**
 * 处理器：用于请求处理
 *
 * 问题：
 * 1.依赖Spring API的处理器
 * 2.每个处理器仅能处理一个请求
 */
public class HelloWorldController implements Controller {
    /**
     * 处理请求的方法
     * @param request 原生的请求对象
     * @param response 原生的响应对象
     * @return 模型与视图对象
     * @throws Exception
     */
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        System.out.println("Hello Springmvc.....");
        
        //创建ModelAndView对象
        ModelAndView modelAndView = new ModelAndView();
        
        //设置数据（相当于将数据存放到域对象中，request域）
        modelAndView.addObject("message", "Hello Springmvc");
        
        //设置视图（相当于进行请求转发的页面路径）
        modelAndView.setViewName("/success.jsp");
        
        return modelAndView;
    }
}

ModelAndView: contiene datos de modelos y nombres de vistas.

2.1.7 Configuración de controladores

Proporcione el objeto Handler a la gestión de contenedores SpringIOC:

<!-- 配置处理器-->
<bean name="/helloworld.do" class="com.newcapec.controller.HelloWorldController"/>

El valor del atributo de nombre del bean se usa como la URL de solicitud y la ruta comienza con una barra inclinada;

2.1.8 Configurar resolución de vistas

<!-- 视图解析器 -->
<!--
  所有的视图解析器都实现ViewResolver接口
  InternalResourceViewResolver：JSP视图的解析器
-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"/>

2.1.9 Ver escritura

índice.jsp:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <base href="${pageContext.request.contextPath}/">
    <title>Title</title>
</head>
<body>
    <div style="text-align: center;">
        <h1>首页</h1>
        <p><a href="helloworld.do">测试helloworld</a></p>
    </div>
</body>
</html>

exito.jsp：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <base href="${pageContext.request.contextPath}/">
    <title>Title</title>
</head>
<body>
    <div style="text-align: center;">
        <h1>跳转成功页面</h1>
        <div style="color:red;">${message}</div>
    </div>
</body>
</html>

2.2 Asignadores y adaptadores de procesadores no anotados

2.2.1 Mapeador de procesador no anotado

    org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping, al configurar el controlador, configure la URL correspondiente al controlador cuando se accede a él en el atributo de nombre de la etiqueta del bean.

    org.springframework.web.servlet.handler.SimpleUrlHandlerMapping, de acuerdo con la coincidencia del valor del atributo id en la etiqueta del bean del procesador y la ruta de la solicitud, encuentra el objeto controlador correspondiente.Un objeto controlador puede corresponder a varias rutas de solicitud.

<!--
  SimpleUrlHandlerMapping:
  根据处理器bean标签中id属性值与请求路径匹配查找相应的处理器对象，一个处理器对象可对应多个请求路径
-->
<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
    <property name="mappings">
        <props>
            <!-- 请求路径的url为key，处理器bean的id为value-->
            <prop key="/hello.do">helloController</prop>
            <prop key="/hello.action">helloController</prop>
        </props>
    </property>
</bean>

Nota: En el mismo proyecto, varios mapeadores pueden coexistir, y el controlador frontal determina qué mapeadores pueden mapear la URL y dejar que el mapeador correcto lo maneje.

2.2.2 Adaptadores de controlador sin anotaciones

    org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter requiere el controlador escrito para implementar la interfaz del controlador.

    org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter requiere que el controlador escrito implemente la interfaz org.springframework.web.HttpRequestHandler.

<!--
  HttpRequestHandlerAdapter:
  要求在编写处理器时，必须实现HttpRequestHandler接口
-->
<bean class="org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter"/>

2.2.3 Procesador

código:

public class HelloController implements HttpRequestHandler {
    @Override
    public void handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws ServletException, IOException {
        System.out.println("HelloController执行了....");
        httpServletRequest.setAttribute("message", "hello");
        //重定向
        // httpServletResponse.sendRedirect("/success.jsp");
        //请求转发
      	httpServletRequest.getRequestDispatcher("/success.jsp").forward(httpServletRequest, httpServletResponse);
    }
}

Configuración:

<bean id="helloController" class="com.newcapec.controller.HelloController"/>

2.2.4 Ver escritura

índice.jsp:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <base href="${pageContext.request.contextPath}/">
    <title>Title</title>
</head>
<body>
    <div style="text-align: center;">
        <h1>首页</h1>
        <p><a href="helloworld.do">测试helloworld</a></p>
        <p><a href="hello.do">测试hello.do</a></p>
        <p><a href="hello.action">测试hello.action</a></p>
    </div>
</body>
</html>

2.3 Configuración por defecto de SpringMVC

    Hay un archivo de recursos DispatcherServlet.properties en el paquete org.springframework.web.servlet.

     El controlador frontal carga el asignador de procesadores, el adaptador de procesadores, la resolución de vistas y otros componentes de este archivo de propiedades. Si no está configurado en springmvc.xml, se cargará de forma predeterminada.

2.4 Asignadores y adaptadores de procesadores anotados

2.4.1 Asignadores de procesadores y adaptadores diferentes a los de la configuración predeterminada

Usar antes de spring3.1:

    org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping asignador de controladores de anotaciones.
    
    org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter adaptador de procesador de anotaciones.

Usar después de spring3.1:

    org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping asignador de controladores de anotaciones.
    
    org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter adaptador de procesador de anotaciones.

2.4.2 Escaneo de componentes

<!-- springmvc的注解式开发 -->
<!-- 开启组件扫描 -->
<context:component-scan base-package="com.newcapec.controller"/>

2.4.3 Asignación de manejador de asignación de solicitudes

    El asignador del procesador de anotaciones asigna el método marcado como @RequestMapping en la clase, hace coincidir el método marcado por RequestMapping de acuerdo con la URL definida por RequestMapping y devuelve el objeto HandlerMethod al controlador frontal si la coincidencia es exitosa y encapsula el método Method correspondiente a la url en el objeto HandlerMethod.

<!--配置处理器映射器-->
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>

2.4.4 RequestMappingHandlerAdapter

La configuración del adaptador del procesador de anotaciones es la siguiente:

<!--配置处理器适配器-->
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"/>

2.4.5 Procesador del controlador

    La anotación @Controller se usa para declarar que una instancia de una clase es un controlador.
    
    Spring MVC usa el mecanismo de escaneo para encontrar todas las clases de controlador basadas en anotaciones en la aplicación. Por lo tanto, para que Spring MVC escanee la clase de controlador, debe declarar spring-context en el archivo de configuración y usar <context El elemento :component-scan/> especifica el paquete base para las clases de controlador (asegúrese de que todas las clases de controlador estén bajo el paquete base y sus subpaquetes).

/**
 * 注解式处理器
 *
 * 好处：
 * 1.零侵入：无需继承或实现任何的接口或类
 * 2.一个处理器中可以处理多个请求，每个请求对应一个方法
 *
 * @Controller
 * 作用：配置bean和标识当前类为spirngmvc中的处理器
 */
@Controller
public class DemoController {

    /**
     * 处理请求的方法
     *
     * @RequestMapping
     * 作用：将请求的路径与处理请求的方法进行绑定...
     */
    @RequestMapping("/find.do")
    public ModelAndView find(){
        System.out.println("查询请求...");
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("message", "find");
        modelAndView.setViewName("/success.jsp");
        return modelAndView;
    }

    @RequestMapping("/add.do")
    public ModelAndView add(){
        System.out.println("新增请求...");
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("message", "add");
        modelAndView.setViewName("/success.jsp");
        return modelAndView;
    }
}

Nota: Los mapeadores de anotaciones y los adaptadores de anotaciones deben usarse en pares.

2.4.6 Ver escritura

índice.jsp:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <base href="${pageContext.request.contextPath}/">
    <title>Title</title>
</head>
<body>
    <div style="text-align: center;">
        <h1>首页</h1>
        <p><a href="find.do">测试find</a></p>
        <p><a href="add.do">测试add</a></p>
    </div>
</body>
</html>

exito.jsp：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <base href="${pageContext.request.contextPath}/">
    <title>Title</title>
</head>
<body>
    <div style="text-align: center;">
        <h1>跳转成功页面</h1>
        <div style="color:red;">${message}</div>
    </div>
</body>
</html>

2.5 Resumen del programa de inicio

• Comprender el uso del controlador frontal SpringMVC, el mapeador de procesadores , el adaptador de procesador y la resolución de vistas a través del programa de inicio. La comprensión no anotativa es suficiente y la anotación debe dominarse con soltura.