Aprendizaje de SpringMvc: cree un nuevo proyecto springWeb en la idea y la solicitud del navegador y la respuesta del servidor y el archivo SpringMvc relacionado

conducir fuera

---

¿Qué es mvc, qué es springMvc, cómo crear un proyecto springWeb,
cómo enviar solicitudes y respuestas en springMvc y cómo responder?
Archivos de procesamiento de SpringMvc relacionados: cargar archivos, renombrar uuid, asignación de recursos estáticos, ruta de configuración de yaml, archivo de configuración de primavera preliminar;

Conocimientos básicos: arquitectura de tres capas y MVC

1. Arquitectura de tres niveles

1. Capa de presentación (vista): capa WEB, utilizada para la interacción de datos con los clientes. controlador de servlet
2. Capa empresarial: servicio que maneja la lógica empresarial específica de la empresa
3. Capa de persistencia: dao-mapper utilizado para operar la base de datos

2. MVC modelo

1. El nombre completo de MVC es Model View Controller Model View Controller, y cada parte realiza sus propias funciones.

2. Modelo: modelo de datos, clase JavaBean, utilizado para la encapsulación de datos.

3. Ver: se refiere a JSP y HTML utilizados para mostrar datos a los usuarios Android-http, Apple, applets

4. Controlador: se utiliza para recibir las solicitudes de los usuarios, el controlador de todo el proceso. Se utiliza para la verificación de datos, etc.

SpringWeb proyecto IDEA construcción

1. Crear un nuevo proyecto maven normal

2. Paquete de importación, archivo pom.xml

(1) Heredar un padre

    <!--    继承一个父-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.0.RELEASE</version>
    </parent>

(2) Paquete de proyecto web + motor de plantillas front-end

       <!--    做web项目的包-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        
<!--        前端模板引擎，类似于jsp-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>

(3) Archivo pom.xml completo

<?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.tianju</groupId>
    <artifactId>springMvc620</artifactId>
    <version>1.0-SNAPSHOT</version>

<!--    继承一个父-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.0.RELEASE</version>
    </parent>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>

        <!--    做web项目的包-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

<!--        前端模板引擎，类似于jsp-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        
<!--        其他需要的包-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>2.0.22</version>
        </dependency>

    </dependencies>
    
</project>

3. Escriba el archivo Main.java de la clase de inicio principal @SpringBootApplication

Puntos principales:

• Es la clase de configuración de spingMvc: @SpringBootApplication;
• Inicio: SpringApplication.run(Main.class);
• El problema de la jerarquía de directorios y otros directorios del mismo nivel;

Archivo principal.java

package com.tianju;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;


/**
 * springMvc的主启动类
 * 1.本质是配置类；@SpringBootApplication :@Configuration是它的爷爷辈
 * 2.启动容器，SpringApplication.run(Main.class);
 */
@SpringBootApplication
public class Main {
    
    
    public static void main(String[] args) {
    
    
        // 集成了的new对象，放容器，启动执行
        ApplicationContext ac = SpringApplication.run(Main.class);
    }
}

4. Escriba el archivo de configuración de primavera del archivo application.yml

Puntos principales:

• El nombre del archivo es aplicación.yml
• Si el color es amarillo, debe haber un espacio

server:
  port: 80

5. Inicio, ejecute main.java para comenzar

Solicitud preliminar del navegador SpringMvc

1. Conociendo springMvc @RequestMapping("/demo")

Puntos principales:

• 1. El controlador debe estar en el contenedor: @Controller
• 2. Se utiliza para procesar las solicitudes del navegador: @RequestMapping(“/demo”)
• @RequestMapping("/demo") puede estar en la clase o en el método: directorios de primer y segundo nivel;

Archivo ResponseControllerDemo.java

package com.tianju.controller;

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

/**
 * controller层，
 * 1.在容器中: @Controller
 * 2.用来处理网络请求：即 @RequestMapping("/demo")
 * 既可以放在类上：一级目录；
 * 也可以在方法上：二级目录：http://localhost/demo/hello
 */
@Controller
@RequestMapping("/demo") // 一级目录
public class ResponseControllerDemo {
    
    
    @RequestMapping({
    
    "/hello","/hello2"}) // 二级目录
    @ResponseBody
    public String hello(){
    
    
        return "Hello SpringMvc";
    }
}

2. Derivado de @RequestMapping

@PostMapping，@GetMapping，@DeleteMapping，@PutMapping

@RequestMapping

@PostMapping(“/hola”)
@GetMapping
@DeleteMapping
@PutMapping

Excepción 405: el servidor solo puede procesar la publicación y el navegador solicita el método de obtención

La forma en que el navegador solicita Solicitud para pasar parámetros

1. Tipos de datos básicos y String

Puntos principales:

• Si no se pasa la cadena, el valor predeterminado es una cadena vacía;
• No se pasa entero, el valor predeterminado es nulo;

http://localhost/demo/hello?username=&age=

package com.tianju.controller;

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

/**
 * controller层，
 * 1.在容器中: @Controller
 * 2.用来处理网络请求：即 @RequestMapping("/demo")
 * 既可以放在类上：一级目录；
 * 也可以在方法上：二级目录：http://localhost/demo/hello
 */
@Controller
@RequestMapping("/demo") // 一级目录
public class ResponseControllerDemo {
    
    
    @RequestMapping("/hello") // 二级目录
    @ResponseBody
    public String hello(String username,Integer age){
    
    
        System.out.println(username);
        System.out.println(age);
        return "Hello SpringMvc";
    }
}

2. Enviar nombre, recibir es nombre de usuario, @RequestParam(valor = "nombre")

Puntos principales:

• De forma predeterminada, se debe pasar el valor y, si no se pasa, se informará una excepción 400;

• Si no desea pasarlo, agregue required=false;

• También puede dar un valor predeterminado, defaultValue="admin"; [Aplicación: al paginar, el valor predeterminado es la primera página y el valor predeterminado es 10 datos por página]

http://localhost/demo/hello?name=hell

    @RequestMapping("/hello") // 二级目录
    @ResponseBody
    public String hello(@RequestParam(value = "name") String username){
    
    
        System.out.println(username);
        return "Hello SpringMvc";
    }

400 excepción, @RequestParam agregado (valor = "nombre") debe pasar el valor

Excepción 400, el tipo de backend es Integer, el frontend es una cadena y la conversión falla

2. [Aplicación] Puede usar @RequestParam(value = “pageNum”, defaultValue = “1”) para la paginación

package com.tianju.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * controller层，
 * 1.在容器中: @Controller
 * 2.用来处理网络请求：即 @RequestMapping("/demo")
 * 既可以放在类上：一级目录；
 * 也可以在方法上：二级目录：http://localhost/demo/hello
 */
@Controller
@RequestMapping("/demo") // 一级目录
public class ResponseControllerDemo {
    
    
    @RequestMapping("/hello") // 二级目录
    @ResponseBody
    public String hello(@RequestParam(value = "pageNum",defaultValue = "1") Integer pageNum,
                        @RequestParam(value = "pageSize",defaultValue = "10") Integer pageSize){
    
    
        System.out.println(pageNum);
        System.out.println(pageSize);
        return "Hello SpringMvc";
    }
}

3.Consulta de estilo de reposo xxx/búsqueda/teléfono móvil/blanco----xxx/búsqueda? artículo=teléfono móvil y color=blanco

Puntos principales:

• Ruta de acceso: @RequestMapping("/buscar/{elemento}/{color}");
• Obtener parámetros: @PathVariable("elemento")

http://localhost/demo/search/mobilephone/red

package com.tianju.controller;

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

import java.security.SignedObject;

/**
 * controller层，
 * 1.在容器中: @Controller
 * 2.用来处理网络请求：即 @RequestMapping("/demo")
 * 既可以放在类上：一级目录；
 * 也可以在方法上：二级目录：http://localhost/demo/hello
 */
@Controller
@RequestMapping("/demo") // 一级目录
public class ResponseControllerDemo {
    
    

    // http://localhost/demo/search/mobilephone/red
    @RequestMapping("/search/{item}/{color}") // 二级目录
    @ResponseBody
    public String hello(@PathVariable("item") String item,
                        @PathVariable("color") String color){
    
    
        System.out.println(item);
        System.out.println(color);
        return "Hello SpringMvc";
    }
}

4. El backend usa recepción de objetos + matriz/colección

Puntos principales:

• Los objetos se pueden usar para recibir datos desde el front-end, y el mapeo se realizará automáticamente
• Se pueden pasar arreglos o colecciones

http://localhost/demo/add/user?username=peter&password=123&hobby=learn&hobby=game

package com.tianju.controller;

import com.tianju.entity.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import java.security.SignedObject;

/**
 * controller层，
 * 1.在容器中: @Controller
 * 2.用来处理网络请求：即 @RequestMapping("/demo")
 * 既可以放在类上：一级目录；
 * 也可以在方法上：二级目录：http://localhost/demo/hello
 */
@Controller
@RequestMapping("/demo") // 一级目录
public class ResponseControllerDemo {
    
    

    // http://localhost/demo/add/user?username=peter
    // &password=123&hobby=learn&hobby=game
    @RequestMapping("/add/user") // 二级目录
    @ResponseBody
    public String hello(User user){
    
    
        System.out.println(user);
        return "Hello SpringMvc";
    }
}

5. Fecha de procesamiento, el formato predeterminado es 2021/05/28, [continuará]

Puntos principales:

• De forma predeterminada, solo se pueden enviar fechas con el formato 28/05/2021

http://localhost/demo/date?birthday=2021/05/28

package com.tianju.controller;

import com.tianju.entity.User;
import lombok.Data;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import java.security.SignedObject;
import java.util.Date;

/**
 * controller层，
 * 1.在容器中: @Controller
 * 2.用来处理网络请求：即 @RequestMapping("/demo")
 * 既可以放在类上：一级目录；
 * 也可以在方法上：二级目录：http://localhost/demo/hello
 */
@Controller
@RequestMapping("/demo") // 一级目录
public class ResponseControllerDemo {
    
    

    // http://localhost/demo/date?birthday=2021/05/28
    @RequestMapping("/date") // 二级目录
    @ResponseBody
    public String hello(Date birthday){
    
    
        System.out.println(birthday);
        return "Hello SpringMvc";
    }
}

400 excepción, la conversión del formato de fecha falló

No se pudo convertir del tipo [java.lang.String] al tipo [java.util.Date] para el valor '2021-5-28'; la excepción anidada es java.lang.IllegalArgumentException]

6. Cómo obtener el encabezado de la solicitud, el valor de la cookie y la solicitud y respuesta originales, etc.

Puntos principales:

• escribe lo que necesitas;

• Solicitud HttpServletRequest,

• HttpSesión httpSesión,

http://localhost/demo/set/session
http://localhost/demo/native

package com.tianju.controller;

import com.tianju.entity.User;
import lombok.Data;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.security.SignedObject;
import java.util.Date;

/**
 * controller层，
 * 1.在容器中: @Controller
 * 2.用来处理网络请求：即 @RequestMapping("/demo")
 * 既可以放在类上：一级目录；
 * 也可以在方法上：二级目录：http://localhost/demo/hello
 */
@Controller
@RequestMapping("/demo") // 一级目录
public class ResponseControllerDemo {
    
    

    // http://localhost/demo/date?birthday=2021/05/28
    @RequestMapping("/native") // 二级目录
    @ResponseBody
    public String hello(HttpServletRequest request,
                        HttpSession httpSession,
                        HttpServletResponse response,
                        @RequestHeader("Connection") String connection,
                        @CookieValue("JSESSIONID") String jsessionid){
    
    
        // 1.request里面就可以获得session，之前servlet就是这样的
        HttpSession session = request.getSession();
        // 2.加上httpSession，也能获得；
        Object username = httpSession.getAttribute("username");
        System.out.println(username);
        System.out.println(response);
        System.out.println("----获取请求头里的connection------");
        System.out.println(connection);
        System.out.println(jsessionid);
        return "Hello SpringMvc";
    }

    @RequestMapping("/set/session")
    @ResponseBody
    public String setSession(HttpSession session){
    
    
        session.setAttribute("username", "peter");
        System.out.println(session);
        return "success";
    }
}

Encabezado de solicitud
para obtener conexión y jsessionid

El servidor responde con Response: el backend envía contenido al frontend

Necesita un paquete, motor de plantilla frontal, similar a jsp

<!--        前端模板引擎，功能类似于jsp-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>

1. Responda a una visualización de tiempo Json + @JsonFormat [con pozos]

Puntos principales:

• La respuesta es json, agregue @ResponseBody;

• Para el problema de visualización de la hora, se requiere GMT+8:

• @JsonFormat(patrón = “aaaa-MM-DD hh:mm:ss”, zona horaria = “GMT+8”)

• Si la respuesta de un controlador es todo json, se puede usar @RestController en lugar de @Controller y @ResponseBody

Tenga en cuenta aquí, el formato de conversión de fecha es incorrecto, DD debe cambiarse a minúsculas dd

conversión de formato de fecha

    @JsonFormat(pattern = "yyyy-MM-dd hh:mm:ss",timezone = "GMT+8")
    private Date birthday;

código del controlador

package com.tianju.controller;

import com.tianju.entity.ResData;
import com.tianju.entity.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.Arrays;
import java.util.Date;

/**
 * 响应相关：1.响应json；2.响应页面
 * 要点：
 * 1.在容器@Controller；
 * 2.路径；@RequestMapping("/resp")；
 * 3.如果是响应json，需要加@ResponseBody;
 * 4.如果响应页面，则返回值是string
 * 补充：如果一个controller响应都是json
 * 则，@RestController代替 @Controller 和 @ResponseBody
 */
@Controller
@RequestMapping("/resp")
//@RestController // 等价于@Controller + @ResponseBody
public class ResponseControllerDemo {
    
    
    @RequestMapping("/json")
    @ResponseBody // 如果响应是json，必须加
    public ResData respJson(){
    
    
        User user = new User("peter", "123",
                new Date(), Arrays.asList(new String[]{
    
    "learn","movie"}));
        return new ResData(200, "success", user);
    }
}

No puede escribir el cuerpo de respuesta, use @RestController

2. Responda a una página y devuelva el valor Cadena

Puntos principales:

• 1. El valor de retorno es una cadena;
• 2. No se puede agregar el cuerpo de respuesta

El servidor responde al código html y lo muestra en la página de inicio

El acceso a los archivos en recursos se puede modificar, no recomendado

conexión de acceso

http://localhost/resp/list

código de fondo

    /**
     * 响应一个页面
     * @return list页面，会在前面拼 /templates，后面拼.html
     * 最终访问到xxx/templates/opus/list.html
     */
    @RequestMapping("/list")
    public String respHtml(){
    
    
        return "/opus/list";
    }

2. Página de respuesta, ModelAndView y datos compartidos [[${usename}]]

Puntos principales:

<html lang="en" xmlns:th="http://www.thymeleaf.org">

// 1.定义要跳转的页面，2.添加要共享的数据
        ModelAndView mv = new ModelAndView("opus/list");
        mv.addObject("username", "peter");

La primera forma: no recomendada

El segundo método: este método se utilizará para compartir datos en el futuro

Los valores compartidos se muestran en la interfaz

    @RequestMapping("/listAndData")
    public ModelAndView respHtmlData(){
    
    
        // 1.定义要跳转的页面，2.添加要共享的数据
        ModelAndView mv = new ModelAndView("opus/list");
        mv.addObject("username", "peter");
        return mv;
    }

3. Si quieres manejarlo tú mismo, usa void

Puntos clave: sin valor de retorno, use void

package com.tianju.controller;

import com.alibaba.fastjson.JSON;
import com.tianju.entity.ResData;
import com.tianju.entity.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Arrays;
import java.util.Date;

/**
 * 响应相关：1.响应json；2.响应页面
 * 要点：
 * 1.在容器@Controller；
 * 2.路径；@RequestMapping("/resp")；
 * 3.如果是响应json，需要加@ResponseBody;
 * 4.如果响应页面，则返回值是string
 * 补充：如果一个controller响应都是json
 * 则，@RestController代替 @Controller 和 @ResponseBody
 */
@Controller
@RequestMapping("/resp")
//@RestController // 等价于@Controller + @ResponseBody
public class ResponseControllerDemo {
    
    
    @RequestMapping("/json")
    @ResponseBody // 如果响应是json，必须加
    public ResData respJson(){
    
    
        User user = new User("peter", "123",
                new Date(), Arrays.asList(new String[]{
    
    "learn","movie"}));
        return new ResData(200, "success", user);
    }

    /**
     * 响应一个页面
     * @return list页面，会在前面拼 /templates，后面拼.html
     * 最终访问到xxx/templates/opus/list.html
     */
    @RequestMapping("/list")
    public String respHtml(){
    
    
        return "/opus/list";
    }

    @RequestMapping("/listAndData")
    public ModelAndView respHtmlData(){
    
    
        // 1.定义要跳转的页面，2.添加要共享的数据
        ModelAndView mv = new ModelAndView("opus/list");
        mv.addObject("username", "peter");
        return mv;
    }

    /**
     * 如果想自己处理，就用void
     */
    @RequestMapping("/self")
    public void test(HttpServletResponse response) throws IOException {
    
    
        ResData resData = new ResData(200, "success", null);
        response.getWriter().write(JSON.toJSONString(resData));
    }
}

SpringMvc maneja la carga de archivos

1. Cargue el archivo y guárdelo en el MultipartFile local

Puntos principales:

• 1. Enviar con envío de publicación + segmento enctype="multipart/form-data";
• 2. Reciba con MultipartFile para recibir, puede obtener el tamaño del nombre, etc.;
• 3. Guardar en local puede usar transferTo u obtener el procesamiento del flujo de entrada;

Puede obtener la imagen, obtener el tamaño de la imagen y procesar el tamaño

Código del controlador de fondo

package com.tianju.controller;

import com.tianju.entity.ResData;
import org.apache.commons.io.IOUtils;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * 上传文件：
 * 要点：
 * 1.前端怎么提交：
 * 2.后端怎么接收：
 * 3.接收后怎么处理：
 */
//@RestController // 等价于@Controller 和 @ResponseBody
@Controller
@RequestMapping("/file")
public class UploadController {
    
    
    // 1.先到上传图片的页面
    @RequestMapping("/uploadPage")
    public String uploadPage(){
    
    
        return "/opus/upload";
    }

    // 2.处理前端上传的图片
    @RequestMapping("/upload")
    @ResponseBody
    public ResData uploadImg(MultipartFile headImg) throws IOException {
    
    
        long size = headImg.getSize(); // 文件大小
        String filename = headImg.getOriginalFilename(); // 文件名
        System.out.println("上传的文件："+filename+"，文件大小"+size);
        // 对文件进行处理
        // (1)拿到输入流，然后保存到本地；以后也可能通过网络发送到其他地方
        InputStream inputStream = headImg.getInputStream();
        FileOutputStream outputStream = new FileOutputStream("D:/06/" + filename);
        IOUtils.copy(inputStream, outputStream);
        // 谁建的谁关
        outputStream.close();

        // (2)不用流直接存到本地文件中
        headImg.transferTo(new File("D:\\620\\"+filename));
        return new ResData(200, "ok", null);
    }

}

Código de página de front-end upload.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<!-- 提交方法必须是post，并且用分段提交 -->
<form action="/file/upload"
      method="post"
      enctype="multipart/form-data">
    <input type="file" name="headImg">
    <input type="submit" value="提交">
</form>

</body>
</html>

2. El problema de cargar archivos con el mismo nombre se sobrescribe: cambie el nombre con uuid

Puntos principales:

• 1. Renombrar con uuid, eliminar - de uuid, reemplazar método;
• 2. Obtenga el sufijo del archivo cargado int i = originalFilename.lastIndexOf(“.”);substring(i);
• 3. Guardar en local

package com.tianju.controller;

import com.tianju.entity.ResData;
import org.apache.commons.io.IOUtils;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.UUID;

/**
 * 上传文件：
 * 要点：
 * 1.前端怎么提交：
 * 2.后端怎么接收：
 * 3.接收后怎么处理：
 */
//@RestController // 等价于@Controller 和 @ResponseBody
@Controller
@RequestMapping("/file")
public class UploadController {
    
    
    // 1.先到上传图片的页面
    @RequestMapping("/uploadPage")
    public String uploadPage(){
    
    
        return "/opus/upload";
    }

    // 2.处理前端上传的图片
    @RequestMapping("/upload")
    @ResponseBody
    public ResData uploadImg(MultipartFile headImg) throws IOException {
    
    
        long size = headImg.getSize(); // 文件大小
        String originalFilename = headImg.getOriginalFilename(); // 文件名
        System.out.println("上传的文件："+originalFilename+"，文件大小"+size);
        // 对文件进行处理 (2)不用流直接存到本地文件中
        // 获得uuid，并把中间-去掉
        String randomStr = UUID.randomUUID().toString().replace("-", "");
        // 获取上传文件的后缀
        int i = originalFilename.lastIndexOf(".");
        String suffix = originalFilename.substring(i, originalFilename.length());
        headImg.transferTo(new File("D:\\620\\"+randomStr+suffix));
        return new ResData(200, "ok", null);
    }

}

3. Imágenes de la computadora local para mostrar—mapeo de recursos estáticos—archivo de protocolo:

Puntos principales:

• 1. Cree una nueva clase de configuración para implementar la interfaz WebMvcConfigurer;
• 2. método addResourceHandlers, archivo de protocolo de archivo local:

Protocolo de archivo local, /** indica que también se pueden encontrar subdirectorios

Acceso a la página web de imágenes locales

archivo springMvcConfig.java

package com.tianju.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * springMvc的配置类，spring的相关配置都在这里
 * 要点：
 * 1.是配置类；@Configuration
 * 2.是springMvc的配置类：implements WebMvcConfigurer
 */
@Configuration
public class SpringMvcConfig implements WebMvcConfigurer {
    
    

    /**
     * 能够把服务器上的一个目录，映射成一个路径，http可以直接访问到
     * @param registry
     */
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
    
    
        // 在浏览器上，如果访问/bookImg/1.jpg，springMvc就去D:\620\1.jpg找对应的文件
        // /bookimg/** 表示子目录下的文件也能找到
        registry.addResourceHandler("/bookimg/**")
                .addResourceLocations("file:D:\\620\\");
    }
}

4. Coloque la ruta del archivo cargado en el archivo de configuración de Spring y obtenga @Value ("${imgLocation}")

Puntos principales:

• Configure en el archivo application.yml;
• Consíguelo a través de @Value("${imgLocation}";

archivo de aplicación.yml

server:
  port: 80

## 图片上传的路径
imgLocation: D:\\620\\

Otra adquisición de archivos:

package com.tianju.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * springMvc的配置类，spring的相关配置都在这里
 * 要点：
 * 1.是配置类；@Configuration
 * 2.是springMvc的配置类：implements WebMvcConfigurer
 */
@Configuration
public class SpringMvcConfig implements WebMvcConfigurer {
    
    
    @Value("${imgLocation}")
    private String imgLocation;

    /**
     * 能够把服务器上的一个目录，映射成一个路径，http可以直接访问到
     * @param registry
     */
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
    
    
        // 在浏览器上，如果访问/bookImg/1.jpg，springMvc就去D:\620\1.jpg找对应的文件
        // /bookimg/** 表示子目录下的文件也能找到
        registry.addResourceHandler("/bookimg/**")
                .addResourceLocations("file:"+imgLocation);
    }
}

---

Resumir

1. Controlador de vista de modelo controlador de vista de modelo;
2. idea crea un proyecto springWeb, un proyecto común, heredando un padre, la clase de inicio principal @SpringBootApplication, archivo de configuración application.yml;
3. Solicitud del navegador @RequestMapping("/demo") , Se puede usar en clases, métodos, directorios de primer y segundo nivel
4. Parámetro de solicitud @RequestParam(value = "pageNum", defaultValue = "1"), que se puede usar en la paginación
5. Solicitud: consulta xxx/búsqueda/móvil /blanco, @RequestMapping("/búsqueda/{elemento}/{color}")----@PathVariable("elemento"); 6. Solicitud: obtener solicitud, parámetro más solicitud HttpServletRequest
;
7 Respuesta del servidor, página de respuesta, respuesta a json, hágalo usted mismo
8. Respuesta a JSON, @ResponseBody, formato de hora, @JsonFormat(patrón = "yyyy-MM-DD hh:mm:ss", zona horaria = "GMT+ 8"); 9.
Página de respuesta: el valor devuelto es una cadena y @ResponseBody no se puede agregar;
10. Página de respuesta con algunos datos: ModelAndView y datos compartidos [[${usename}]];
11. Subir archivo Recepción de MultipartFile, envío de publicaciones segmentadas: enctype="multipart/form -data";
12. Asignación de recursos estáticos: clase de configuración springMvcConfig @Configuration, interfaz de implementación WebMvcConfigurer, método addResourceHandlers, archivo de protocolo de archivo local:/; 13.
Obtenga el valor en el archivo application.yml, use @Value(" $ {imgLocation}";