Marco SpringMVC (explicación detallada)

1. Introducción

1.1 ¿Qué es MVC?

Spring MVC es un marco web liviano impulsado por solicitudes basado en Java que implementa el patrón de diseño MVC. Al separar el modelo (M), la vista (V) y el controlador (C), la capa web se desacopla de las responsabilidades y las aplicaciones web complejas se dividido en partes con una lógica clara, simplificando el desarrollo, reduciendo errores y facilitando la cooperación entre los desarrolladores dentro del equipo.

1.2, ventajas y desventajas de SpringMVC

Ventajas de MVC:
múltiples vistas comparten un modelo, lo que mejora en gran medida la reutilización del código. Los
tres módulos de MVC son independientes entre sí y tienen una arquitectura débilmente acoplada.
El controlador mejora la flexibilidad y la capacidad de configuración de las aplicaciones y
favorece la gestión de la ingeniería de software.

Arquitectura de sistema perfecta = acoplamiento flexible + alta reutilización + alta escalabilidad

Desventajas de MVC:
principios complejos
, mayor complejidad de la estructura e implementación del sistema,
acceso ineficiente a los datos del modelo mediante vistas

1.3, patrón MVC

1. Componente correspondiente a la vista: archivo JSP o HTML
2. Componente correspondiente al controlador: Servlet
3. Componente correspondiente al modelo: JavaBean
   
   JSP Model1
   
   JSP Model2
4. Servlet: acepta solicitudes de front-end y llama a JavaBeans
5. JavaBean: maneja negocios y opera bases de datos
6. JSP: responde a los resultados del procesamiento al navegador y los presenta al usuario
   
   MVC procesando
   
   Spring MVC
7. Reemplace Servlet en el modelo JSP Model2 con Controlador
8. Una vez que el Controlador recibe la solicitud, completa el procesamiento comercial y utiliza el objeto modelo para almacenar los resultados del procesamiento.
9. El Controlador llama a la Vista del analizador de vista correspondiente para ver los resultados del procesamiento y, finalmente, el cliente obtiene la información de respuesta.

Segundo, use SpringMvc

21. Cree el proyecto maven-web y modifique el archivo web.xml en el directorio WEB-INF en el directorio webapp.

2.2, el contenido del archivo web.xml es el siguiente

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>
  <servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>


<!--  页面中输入的中文，调到后端，出现乱码解决的问题  -->
  <filter>
    <filter-name>encodingFilter</filter-name>
    <filter-class>
      org.springframework.web.filter.CharacterEncodingFilter
    </filter-class>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
      <param-name>forceEncoding</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

</web-app>

2.3, introduce las dependencias de springMVC

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.xinxi2</groupId>
  <artifactId>SpringMvc1</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>SpringMvc1 Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
    <spring.version>5.2.5.RELEASE</spring.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>


  <!-- log4j 日志jar-->

  <dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
  </dependency>

  <!-- 连接mysql5 的驱动 -->
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.10</version>
  </dependency>

  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>${spring.version}</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>${spring.version}</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>${spring.version}</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>${spring.version}</version>
  </dependency>
  <dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.2</version>
  </dependency>

  <!-- mybatis依赖 -->
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.2.2</version>
  </dependency>
  <!-- 参考版本对应 http://www.mybatis.org/spring/ -->
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.2.2</version>
  </dependency>

  <!-- 数据源管理  使用了dbcp2数据 -->
  <dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-dbcp2</artifactId>
    <version>2.1.1</version>
  </dependency>
  <dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
    <version>2.4.2</version>
  </dependency>

  <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>
  </dependency>
  <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jsp-api</artifactId>
    <version>2.0</version>
    <scope>provided</scope>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>${spring.version}</version>
  </dependency>

  <!-- commons 文件上传jar -->
  <dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>1.4</version>
  </dependency>
  <dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.1</version>
  </dependency>

  <!-- jstl -->
  <dependency>
    <groupId>jstl</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
  </dependency>

  <!-- 加入JSON转换工具 -->
  <dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.47</version>
  </dependency>

  </dependencies>

  <build>
    <finalName>SpringMvc1</finalName>
  </build>
</project>

2.4, cree el archivo springmvc.xml

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

	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context.xsd">

<!--  扫描  -->
    <context:component-scan base-package="com.controller"></context:component-scan>
</beans>

2.5, crea una clase de controlador

import java.util.List;
import java.util.Map;


//标记该类为处理层类
@Controller
@RequestMapping("/hello")

public class HelloController {
    
    
   	
    //把请求路径映射到该方法上
    @RequestMapping("/hello01")
    public String hello01(){
    
    
        System.out.println("hello01");
        
        //请求转发到hello01.jsp界面
        return "hello01.jsp";
    }
}

2.6, proceso de ejecución springMVC

1. El cliente solicita http://localhost:8080/springMVC17/hello
2. Ven al servidor Tomcat.
3. El controlador front-end de Springmvc, DipatcherServlet, acepta todas las solicitudes.
4. Compruebe qué @RequestMaping coincide con la dirección de su solicitud.
5. Ejecute el método correspondiente. El método devuelve una cadena. Springmvc analiza la cadena en la página web que se reenviará.
6. Concatene la cadena a través del analizador de vistas.
7. Obtenga la dirección empalmada y busque la página web correspondiente.
8. Renderizar la página web al cliente.

2.7, use el modelo para cargar datos

    @RequestMapping("/hello03")
    public String hello03(Student student,Model model){
    
    
        System.out.println("hello03"+student.getUsername()+"  "+student.getPwd()+" "+student.getBirthday()+" "+student.getAge());
        model.addAttribute("linyuhao","hh");
        return "hello01.jsp";
    }

Cargar datos usando HttpServletRequest

    @RequestMapping("/hello04")
    public String hello04(HttpServletRequest request){
    
    
        System.out.println("hello04");
        request.setAttribute("guangtou","gg");
        return "hello01.jsp";
    }

2.8, use Map para cargar datos

    @RequestMapping("/hello05")
    public String hello05(Map map){
    
    
        System.out.println("hello05");
        int count = 1/0;
        map.put("wangdao","qq");
        return "redirect:/login.jsp";
    }

2.9, problema de carga de recursos estáticos

Esto requiere que carguemos los recursos estáticos en el archivo de configuración springMVC, además

<!--  解决了静态资源的加载问题  -->
    <mvc:resources mapping="/static/**" location="/static/"></mvc:resources>

3. Cómo implementar la redirección de páginas

En el método de la capa del controlador, el valor de retorno es de tipo Cadena y se devuelve una interfaz utilizando el método de reenvío de solicitudes. Si desea utilizar la redirección para saltar a otras páginas, agregue redirección: en el valor de retorno, / cuando springmvc ve Cuando la cadena que devuelves contiene redirección:, se considerará que deseas redirigir.

devolver “redireccionamiento:/login.jsp”;

    @RequestMapping("/hello05")
    public String hello05(Map map){
    
    
        System.out.println("hello05");
        int count = 1/0;
        map.put("wangdao","qq");
        return "redirect:/login.jsp";
    }

4. Interceptor

4.1 Crear interceptor

package com.Interceptor;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class LoginInterceptor implements HandlerInterceptor {
    
    
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    
    
        System.out.println("preHandle");
//        拦截规则，自己根据业务需求实现
        String username = request.getParameter("username");
        if (null==username || "".equals(username)){
    
    
            response.sendRedirect("/index.jsp");
            return false;
        }
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    
    
        System.out.println("postHandle:handle执行完,渲染之前");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    
    
        System.out.println("afterCompletion:handle执行完,渲染之后");
    }
}

La clase de interceptor que creamos necesita implementar la interfaz HandlerInterceptor y anular el método preHandle.
Si queremos utilizar el interceptor que definimos, debemos registrar el interceptor en el archivo springmvc.xml.

    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/hello/**"/>
            <mvc:exclude-mapping path="/hello/hello04"/>
            <bean class="com.Interceptor.LoginInterceptor"></bean>
        </mvc:interceptor>
    </mvc:interceptors>

5. Carga de archivos

5.1 Subir al servidor local

El primer paso es importar las dependencias para cargar archivos.

  <!-- commons 文件上传jar -->
  <dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>1.4</version>
  </dependency>
  <dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.1</version>
  </dependency>

El segundo paso es crear una página. Lo que hay que tener en cuenta aquí es que el método de envío debe ser posterior al envío. El tipo de formulario enctype debe configurarse en el formato multipart/form-data. El atributo de nombre de la etiqueta de entrada aquí no se puede omitir y debe ser recibido por la capa del controlador.Los nombres de los parámetros son los mismos.

<%--
  Created by IntelliJ IDEA.
  User: lenovo
  Date: 2023/6/25
  Time: 16:39
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>上传文件</title>
</head>
<body>
    <form action="/hello/hello03" method="post" enctype="multipart/form-data">
        <input type="text" name="username"><br>
        <input type="file" name="photo"><br>
        <input type="text" name="age"><br>
        <input type="text" name="birthday">
        <input type="submit" value="提交">
    </form>
</body>
</html>

El tercer paso es configurar el analizador de carga de archivos en el archivo de configuración springMVC.

<!--  配置multipartResolver，用于上传文件，使用spring的CommonsMultipartResolver  -->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="maxInMemorySize" value="5000000"></property>
        <property name="defaultEncoding" value="UTF-8"></property>
    </bean>

El cuarto paso es crear un método que implemente la interfaz de carga de archivos, @RequestMapping representa la interfaz solicitada.

    @RequestMapping("/uploadPage")
    public String uploadPage(){
    
    
        return "upload.jsp";
    }

    @RequestMapping("/upload")
    @ResponseBody // 此方法的返回值就是响应体的内容
    public String upload(String username, MultipartFile photo,HttpServletRequest request){
    
    

        String fileType = photo.getOriginalFilename();
        int index = fileType.lastIndexOf(".");
        fileType = fileType.substring(index);
        String path = request.getSession().getServletContext().getRealPath("static"+File.separator+"uploadfiles");
        long filename = System.currentTimeMillis();
        System.out.println(path);
        System.out.println(fileType);
        System.out.println(path+"\\"+filename+fileType);
        File file = new File(path+"\\"+filename+fileType);
        try {
    
    
            photo.transferTo(file);
        } catch (IOException e) {
    
    
            e.printStackTrace();
        }
        return "上传成功!";
    }

6. Suplemento de contenido

@RestController es equivalente a @Controller+@ResponseBody.
Todos los métodos bajo esta anotación devuelven datos json.
@RequestMapping: Función: asigna la ruta de solicitud al método de respuesta.

@RequestParam(value = “u”): establece el nombre del parámetro de solicitud que acepta. parámetros de consulta

@Param(value="name"): establece los parámetros en el archivo de mapeo del asignador en mybatis

@RequestMapping(value = “/addUser”, método = RequestMethod.POST)
: indica el método de solicitud aceptado por esta interfaz. Se puede aceptar cualquier método de solicitud si no se configura.
@GetMapping("addUser"): indica que solo se aceptan solicitudes en el método de envío get

@RequestBody: convierte los datos json solicitados en un objeto java. Del front-end al back-end
@ResponseBody: convierte datos java a json del back-end al front-end