Spring MVC详解（IDEA版学习笔记）

喜欢ヅ旅行 2023-01-04 10:24 56阅读 0赞

> 别人可以替你开车，但不能替你走路；可以替你做事，但不能替你感受。人生的路要靠自己行走，成功要靠自己去争取。天助自助者，成功者自救。你好，我是梦阳辰，期待与你相遇！

### 文章目录 ###

*  01.概述
 *  02.Spring MVC原理分析
 *  03.使用注解开发Spring MVC（重点）
 *  04.控制器（Controller)
 *  05.RestFul风格
 *  06.跳转方式（转发和重定向）
 *  07.获取前端请求参数&数据回显
 *  08.解决乱码问题
 *  JSON数据
 *   *  Controller返回json数据（Jackson)
     *  FastJson
     *  json-lib的用法

# 01.概述 #

Spring Web MVC是基于Servlet API构建的原始Web框架，从一开始就已包含在Spring框架中。正式名称“ Spring Web MVC”来自其源模块（spring-webmvc）的名称，但更通常称为“ Spring MVC”。是基于java实现MVC的轻量级Web框架。

官方文档：[https://docs.spring.io/spring-framework/docs/current/reference/html/web.html][https_docs.spring.io_spring-framework_docs_current_reference_html_web.html]

**什么是MVC**  
MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范。

是将业务逻辑、数据、显示分离的方法来组织代码。

MVC主要作用是降低了视图与业务逻辑间的双向偶合。

MVC不是一种设计模式，MVC是一种**架构模式**。当然不同的MVC存在差异。

Model（模型）：数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或JavaBean组件（包含数据和行为），不过现在一般都分离开来：Value Object（数据Dao） 和 服务层（行为Service）。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。

View（视图）：负责进行模型的展示，一般就是我们见到的用户界面，客户想看到的东西。

Controller（控制器）：接收用户请求，委托给模型进行处理（状态改变），处理完毕后把返回的模型数据返回给视图，由视图负责展示。也就是说控制器做了个调度员的工作。  
**为什么要学习SpringMVC呢?**

Spring MVC的特点:  
1.轻量级，简单易学

2.高效，基于请求响应的MVC框架

3.与Spring兼容性好，无缝结合

4.约定优于配置

5.功能强大:RESTful、数据验证、格式化、本地化、主题等

6.简洁灵活

Spring的web框架围绕DispatcherServlet \[ 调度Servlet \] 设计。

DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始，使用Java 5或者以上版本的用户可以采用基于注解形式进行开发，十分简洁；

正因为SpringMVC好 , 简单 , 便捷 , 易学 , 天生和Spring无缝集成(使用SpringIoC和Aop) , 使用约定优于配置 . 能够进行简单的junit测试 . 支持Restful风格 .异常处理 , 本地化 , 国际化 , 数据验证 , 类型转换 , 拦截器  
**中心控制器：**

与其他许多Web框架一样，Spring MVC围绕前端控制器模式进行设计Servlet，其中DispatcherServlet，Central提供了用于请求处理的共享算法，而实际工作是由可配置的委托组件执行的。该模型非常灵活，并支持多种工作流程。

Spring的web框架围绕DispatcherServlet设计。DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始，使用Java 5或者以上版本的用户可以采用基于注解的controller声明方式。

Spring MVC框架像许多其他MVC框架一样,以请求为驱动，围绕一个中心Servlet分派请求及提供其他功能，DispatcherServlet是一个实际的Servlet(它继承自HttpServlet基类)。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70]

# 02.Spring MVC原理分析 #

**SpringMVC的原理如下图所示:**  
当发起请求时被前置的控制器拦截到请求，根据请求参数生成代理请求，找到请求对应的实际控制器，控制器处理请求，创建数据模型，访问数据库，将模型响应给中心控制器，控制器使用模型与视图渲染视图结果，将结果返回给中心控制器，再将结果返回给请求者。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70 2]

图为SpringMVC的一个较完整的流程图，实线表示SpringMVC框架提供的技术，不需要开发者实现，虚线表示需要开发者实现。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70 3]  
DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心。用户发出请求，DispatcherServlet接收请求并拦截请求。

HandlerMapping为处理器映射。DispatcherServlet调用HandlerMapping,HandlerMapping根据请求url查找Handler。

HandlerExecution表示具体的Handler,其主要作用是根据url查找控制器，如上url被查找控制器为：hello。

HandlerExecution将解析后的信息传递给DispatcherServlet,如解析控制器映射等。

HandlerAdapter表示处理器适配器，其按照特定的规则去执行Handler。

Handler让具体的Controller执行。

Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView。

HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。

DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名。

视图解析器将解析的逻辑视图名传给DispatcherServlet。

DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。

最终视图呈现给用户。

**原理分析案例：**  
导入依赖：

<dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.11</version>
          <scope>test</scope>
        </dependency>
    
        
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-webmvc</artifactId>
          <version>5.3.2</version>
        </dependency>
    
        <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>servlet-api</artifactId>
          <version>2.5</version>
        </dependency>
    
        <dependency>
          <groupId>javax.servlet.jsp</groupId>
          <artifactId>jsp-api</artifactId>
          <version>2.2</version>
        </dependency>
    
        <dependency>
        <groupId>javax.servlet</groupId>
          <artifactId>jstl</artifactId>
          <version>1.2</version>
        </dependency>

web.xml配置

spring配置文件中配置：

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           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.xsd">
    
        
        <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
        
        <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
    
        
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
            
            <property name="prefix" value="/jsp/"/>
            
            <property name="suffix" value=".jsp"/>
        </bean>
        
        
        <bean id="/mengyangchen" class="com.mengyangchen.controller.FirstController"/>
    
    </beans>

控制层：

package com.mengyangchen.controller;
    
    import org.springframework.web.servlet.ModelAndView;
    import org.springframework.web.servlet.mvc.Controller;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    public class FirstController implements Controller { 
        @Override
        public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception { 
            //ModelAndView 模型和视图
            ModelAndView modelAndView = new ModelAndView();
    
            //业务
            String information ="你好，梦阳辰！";
            //封装对象，放在ModelAndView中
            modelAndView.addObject("msg",information);
            //封装要跳转的视图，放在ModelAndView中
            modelAndView.setViewName("mengyangchen"); //: /jsp/mengyangchen.jsp 响应路径
            return modelAndView;
    
        }
    }

**配置本地tomcat**  
运行，在地址栏输入：  
![在这里插入图片描述][2021010919544658.png]

注意：在IDEA的项目发布中，需要添加lib依赖  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70 4]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70 5]

# 03.使用注解开发Spring MVC（重点） #

导入依赖

按上述步骤配置lib

**配置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">
    
        
        <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-servlet.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>
    </web-app>

**配置springmvc-servlet.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
           https://www.springframework.org/schema/context/spring-context.xsd
           http://www.springframework.org/schema/mvc
           https://www.springframework.org/schema/mvc/spring-mvc.xsd">
    
        
        <context:component-scan base-package="com.mengyangchen.controller"/>
        
        <mvc:default-servlet-handler />
        
    
        
        <mvc:annotation-driven />
    
        
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
              id="internalResourceViewResolver">
            
            <property name="prefix" value="/jsp/" />
            
            <property name="suffix" value=".jsp" />
        </bean>
    
    </beans>

**控制层：**

package com.mengyangchen.controller;
    
    import org.springframework.stereotype.Controller;
    import org.springframework.ui.Model;
    import org.springframework.web.bind.annotation.RequestMapping;
    
    @Controller//会被spring接管被这个注解的类，中的所有方法，如果返回值是String，并且有具体页面可以跳转，那么就会被视图解析器解析;
    
    public class FirstController { 
    
        /*真实访问地址：项目名/first * 如果类上面有@RequestMapping("/h1") * 则真实访问地址为：项目名/h1/first * 请求路径 * */
        @RequestMapping("/first")
        public String first(Model model){ 
            //业务层，调用service层得到数据
            String msg = "欢迎你，梦阳辰！";
            model.addAttribute("msg",msg);
            return "first";//交给视图解析器解析地址（相应路径）
        }
    
        /*可以配置多个访问路径请求 * 这就大大的减少了大量的servlet * 简化了开发*/
        @RequestMapping("/second")
        public String second(Model model){ 
            //业务层，调用service层得到数据
            String msg = "欢迎你！";
            model.addAttribute("msg",msg);
            return "second";//交给视图解析器解析地址（相应路径）
        }
    }

**视图层:**

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>你好！</title>
    </head>
    <body>
        <p>${ msg}</p>
    </body>
    </html>

**目录结构：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70 6]

EL表答式取出Model中存放的值，或者对象

@Controller是为了让Spring IOC容器初始化时自动扫描到

@RequestMapping是为了映射请求路径

方法中声明Model类型的参数是为了把Action中的数据带到视图中

方法返回的结果是视图的名称，加上配置文件中的前后缀变成真实路径。

注意：如果使用的是@RestController注解，就不会被试图解析器解析（用于json数据）  
![在这里插入图片描述][2021010921001440.png]  
![在这里插入图片描述][2021010921003921.png]

**使用springMVC必须配置的三大件：**

处理器映射器、处理器适配器、视图解析器

通常，我们只需要手动配置视图解析器，而处理器映射器和处理器适配器只需要开启注解驱动即可，而省去了大段的xml配置

# 04.控制器（Controller) #

控制器负责提供访问应用程序的行为，通常通过接口定义或注解定义两种方法实现。

控制器负责解析用户的请求并将其转换为一个模型。

在Spring MVC中一个**控制器类可以包含多个方法**

在Spring MVC中，对于Controller的配置方式有很多种

**实现Contorller接口：**

//实现该接口的类获得控制器功能
    public interface Controller { 
       //处理请求且返回一个模型与视图对象
       ModelAndView handleRequest(HttpServletRequest var1, HttpServletResponse var2) throws Exception;
    }

实现接口Controller定义控制器是较老的办法

缺点：一个控制器中只有一个方法，如果要多个方法则需要定义多个Controller；定义的方式比较麻烦。

**使用注解@Controller**

@Controller注解类型用于声明Spring类的实例是一个控制器（在讲IOC时还提到了另外3个注解）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70 7]  
Spring可以使用扫描机制来找到应用程序中所有基于注解的控制器类，为了保证Spring能找到你的控制器，需要在配置文件中声明组件扫描

<context:component-scan base-package="com.kuang.controller"/>

使用注解实现：

//@Controller注解的类会自动添加到Spring上下文中
    @Controller
    public class FirstController{ 
    
       //映射访问路径
       @RequestMapping("/test")
       public String index(Model model){ 
           //Spring MVC会自动实例化一个Model对象用于向视图中传值
           model.addAttribute("msg", "你好，梦阳辰！");
           //返回视图位置
           return "first";
      }
    }

可以发现，我们的多个请求都可以指向一个视图，但是页面结果的结果是不一样的，从这里可以看出视图是被复用的，而控制器与视图之间是弱偶合关系。

**@RequestMapping**

@RequestMapping注解用于映射url到控制器类或一个特定的处理程序方法。可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。

# 05.RestFul风格 #

Restful就是一个**资源定位及资源操作**的风格。不是标准也不是协议，只是一种风格。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。

**资源**：互联网所有的事物都可以被抽象为资源

**资源操作**：使用POST、DELETE、PUT、GET，使用不同方法对资源进行操作。分别对应 添加、 删除、修改、查询。

**使用RESTful操作资源** ：可以通过不同的请求方式来实现不同的效果！如下：请求地址一样，但是功能可以不同！

http://127.0.0.1/item/1 查询,GET
    
    http://127.0.0.1/item 新增,POST
    
    http://127.0.0.1/item 更新,PUT
    
    http://127.0.0.1/item/1 删除,DELETE

紧接着上面的测试代码进行练习：

**使用method属性指定请求类型**

用于约束请求的类型，可以收窄请求范围。指定请求谓词的类型如GET, POST, HEAD, OPTIONS, PUT, PATCH, DELETE, TRACE等

**Get提交：**

![在这里插入图片描述][20210110144915351.png]  
**POST提交：**  
首页：

控制类：

@Controller
    public class RestFulController { 
    
        @RequestMapping(value = "/first/{a}/{b}",method = { RequestMethod.GET})
        public String test(@PathVariable int a , @PathVariable int b, Model model){ 
            int msg = a+b;
            model.addAttribute("msg",msg);
            return "first";
        }
    
        @RequestMapping(value = "/first/{a}/{b}",method = { RequestMethod.POST})
        public String test2(@PathVariable int a , @PathVariable int b, Model model){ 
            int msg = a*b;
            model.addAttribute("msg",msg);
            return "first";
        }
    }

![在这里插入图片描述][20210110145858130.png]

现在可以看出：虽然地址相同，但是因为提交的方式不同，执行的方法也不同，所以也会有不同的结果。  
**方法级别的注解变体有如下几个：组合注解**

@GetMapping
    @PostMapping
    @PutMapping
    @DeleteMapping
    @PatchMapping

@GetMapping 是一个组合注解，平时使用的会比较多！

它所扮演的是 @RequestMapping(method =RequestMethod.GET) 的一个快捷方式。  
例如：

@GetMapping("/first/{a}/{b}")
        public String test(@PathVariable int a , @PathVariable int b, Model model){ 
            int msg = a+b;
            model.addAttribute("msg",msg);
            return "first";
        }

**使用路径变量的好处？**  
使路径变得更加简洁；

获得参数更加方便，框架会自动进行类型转换。

通过路径变量的类型可以约束访问参数，如果类型不一样，则访问不到对应的请求方法。

# 06.跳转方式（转发和重定向） #

**前面我们：**  
设置ModelAndView对象 , 根据view的名称 , 和视图解析器跳到指定的页面 .

页面 : \{视图解析器前缀\} + viewName +\{视图解析器后缀\}

public class FirstController implements Controller { 
    
       public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception { 
           //返回一个模型视图对象
           ModelAndView mv = new ModelAndView();
           mv.addObject("msg","你好，梦阳辰！");
           mv.setViewName("first");
           return mv;
      }
    }

**用servlet原来的方式，进行跳转。不需要视图图解析器。**（不推荐使用）

通过HttpServletRequest实现转发

通过HttpServletResponse实现重定向

@Controller
    public class ServletController { 
    
        @GetMapping("/first11/{a}/{b}")//请求路径
        public void forwardTest(@PathVariable int a, @PathVariable int b , HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { 
            int msg = a+b;
            //转发
            request.setAttribute("msg",msg);
            request.getRequestDispatcher("/jsp/first.jsp").forward(request,response);
        }
    
        @GetMapping("/first12/{a}/{b}")//请求路径
        public void sendRedirectTest(@PathVariable int a, @PathVariable int b , HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { 
            int msg = a*b;
            HttpSession session = request.getSession();
            session.setAttribute("msg",msg);
            //重定向
            response.sendRedirect("/chapter02_springMVC/jsp/second.jsp");
        }
    }

转发结果：  
![在这里插入图片描述][20210110153949706.png]  
重定向结果：  
![在这里插入图片描述][20210110154020523.png]  
**使用SpringMVC来实现转发和重定向：（有视图解析器）**  
重定向 , 不需要视图解析器 , 本质就是重新请求一个新地方。

@Controller
    public class SpringMVC_controller { 
    
        @GetMapping("/springMVC-have/{a}/{b}")//请求路径
        public String test(@PathVariable int a, @PathVariable int b, Model model){ 
            int msg = a +b;
            model.addAttribute("msg",msg);
            return "first";//转发
        }
    
        @GetMapping("/springMVC-have1/{a}/{b}")//请求路径
        public String test1(@PathVariable int a, @PathVariable int b, Model model){ 
            int msg = a +b;
            model.addAttribute("msg",msg);
            return "redirect:/jsp/second.jsp";//重定向
        }
    
    }

转发：  
![在这里插入图片描述][20210110155604960.png]  
重定向：  
![在这里插入图片描述][20210110155525514.png]  
**使用SpringMVC来实现转发和重定向：（没有视图解析器）**  
1.删除配置的视图解析器

@GetMapping("/springMVC-no/{a}/{b}")//请求路径
        public String test2(@PathVariable int a, @PathVariable int b, Model model){ 
            int msg = a +b;
            model.addAttribute("msg",msg);
            return "/jsp/first.jsp";//转发
        }
    
        @GetMapping("/springMVC-no1/{a}/{b}")//请求路径
        public String test3(@PathVariable int a, @PathVariable int b, Model model){ 
            int msg = a +b;
            model.addAttribute("msg",msg);
            return "forward:/jsp/first.jsp";//转发
        }
    
        @GetMapping("/springMVC-no2/{a}/{b}")//请求路径
        public String test4(@PathVariable int a, @PathVariable int b, Model model){ 
            int msg = a +b;
            model.addAttribute("msg",msg);
            return "redirect:/jsp/second.jsp";//重定向
        }

删除视图解析器，运行结果都没有问题。

但是  
**如果没有删除视图解析器**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70 8]  
第二种转发：  
![在这里插入图片描述][20210110160914426.png]

重定向：  
![在这里插入图片描述][20210110160816564.png]

总结：用springMVC写重定向路径时，可以不需要项目目录。

# 07.获取前端请求参数&数据回显 #

http://localhost/chapter02\_springMVC/test?name=mengyangchen  
1、提交的域名称和处理方法的参数名一致

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

http://localhost/chapter02\_springMVC/test1?username=mengyangchen  
2、提交的域名称和处理方法的参数名不一致

@RequestMapping("/test1")
    public String hello1(@RequestParam("username") String name){ 
       System.out.println(name);
       return "first";
    }

3、提交的是一个对象  
**实体类:**

public class User { 
       private int id;
       private String name;
       private int age;
       //构造
       //get/set
       //tostring()
    }

http://localhost/chapter02\_springMVC/test2?username=mengyangchen&id=1&age=17

@RequestMapping("/test2")
    public String user(User user){ 
       System.out.println(user);
       return "first";
    }

如果使用对象的话，前端传递的参数名和对象名必须一致，否则就是null。  
**数据显示到前端**  
第一种 : 通过ModelAndView

第二种 : 通过Model

第三种 : 通过ModelMap

ModelMap 继承了 LinkedMap ，除了实现了自身的一些方法，同样的继承 LinkedMap 的方法和特性。

# 08.解决乱码问题 #

前端是提交的参数是中文数据，出现乱码。

第一种：前端序列化参数乱码。  
可以在前端对序列化后的参数进行URL编码处理。

**springMVC解决乱码问题：**

SpringMVC给我们提供了一个过滤器  
在web.xml中配置 ：

<filter>
       <filter-name>encoding</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>
    </filter>
    <filter-mapping>
       <filter-name>encoding</filter-name>
       <url-pattern>/*</url-pattern> </filter-mapping>

**通用乱码问题解决方案：**

自定义过滤器：

package com.mengyangchen.filter;
    
    import javax.servlet.*;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletRequestWrapper;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    import java.io.UnsupportedEncodingException;
    import java.util.Map;
    
    /** * 解决get和post请求 全部乱码的过滤器 */
    public class GenericEncodingFilter implements Filter { 
    
       @Override
       public void destroy() { 
      }
    
       @Override
       public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { 
           //处理response的字符编码
           HttpServletResponse myResponse=(HttpServletResponse) response;
           myResponse.setContentType("text/html;charset=UTF-8");
    
           // 转型为与协议相关对象
           HttpServletRequest httpServletRequest = (HttpServletRequest) request;
           // 对request包装增强
           HttpServletRequest myrequest = new MyRequest(httpServletRequest);
           chain.doFilter(myrequest, response);
      }
    
       @Override
       public void init(FilterConfig filterConfig) throws ServletException { 
      }
    
    }
    
    //自定义request对象，HttpServletRequest的包装类
    class MyRequest extends HttpServletRequestWrapper { 
    
       private HttpServletRequest request;
       //是否编码的标记
       private boolean hasEncode;
       //定义一个可以传入HttpServletRequest对象的构造函数，以便对其进行装饰
       public MyRequest(HttpServletRequest request) { 
           super(request);// super必须写
           this.request = request;
      }
    
       // 对需要增强方法 进行覆盖
       @Override
       public Map getParameterMap() { 
           // 先获得请求方式
           String method = request.getMethod();
           if (method.equalsIgnoreCase("post")) { 
               // post请求
               try { 
                   // 处理post乱码
                   request.setCharacterEncoding("utf-8");
                   return request.getParameterMap();
              } catch (UnsupportedEncodingException e) { 
                   e.printStackTrace();
              }
          } else if (method.equalsIgnoreCase("get")) { 
               // get请求
               Map<String, String[]> parameterMap = request.getParameterMap();
               if (!hasEncode) {  // 确保get手动编码逻辑只运行一次
                   for (String parameterName : parameterMap.keySet()) { 
                       String[] values = parameterMap.get(parameterName);
                       if (values != null) { 
                           for (int i = 0; i < values.length; i++) { 
                               try { 
                                   // 处理get乱码
                                   values[i] = new String(values[i]
                                          .getBytes("ISO-8859-1"), "utf-8");
                              } catch (UnsupportedEncodingException e) { 
                                   e.printStackTrace();
                              }
                          }
                      }
                  }
                   hasEncode = true;
              }
               return parameterMap;
          }
           return super.getParameterMap();
      }
    
       //取一个值
       @Override
       public String getParameter(String name) { 
           Map<String, String[]> parameterMap = getParameterMap();
           String[] values = parameterMap.get(name);
           if (values == null) { 
               return null;
          }
           return values[0]; // 取回参数的第一个值
      }
    
       //取所有值
       @Override
       public String[] getParameterValues(String name) { 
           Map<String, String[]> parameterMap = getParameterMap();
           String[] values = parameterMap.get(name);
           return values;
      }
    }

1、修改tomcat配置文件 ：设置编码！

# JSON数据 #

JSON 是 JavaScript 对象的字符串表示法，它使用文本表示一个 JS 对象的信息，本质是一个字符串。

var obj = {a: 'Hello', b: 'World'}; //这是一个对象，注意键名也是可以使用引号包裹的
    var json = '{"a": "Hello", "b": "World"}'; //这是一个 JSON 字符串，本质是一个字符串

**JSON 和 JavaScript 对象互转**

要实现从JSON字符串转换为JavaScript 对象，使用 JSON.parse() 方法：

var obj = JSON.parse('{"a": "Hello", "b": "World"}');
    //结果是 {a: 'Hello', b: 'World'}

要实现从JavaScript 对象转换为JSON字符串，使用 JSON.stringify() 方法：

var json = JSON.stringify({a: 'Hello', b: 'World'});
    //结果是 '{"a": "Hello", "b": "World"}'

## Controller返回json数据（Jackson) ##

Jackson应该是目前比较好的json解析工具了,当然工具不止这一个，比如还有阿里巴巴的 fastjson ，json-lib等等.

我们这里使用Jackson，使用它需要导入它的jar包；

<dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.12.1</version>
    </dependency>

练习：  
配置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">
    
        
        <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-servlet.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>encoding</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>
        </filter>
        <filter-mapping>
            <filter-name>encoding</filter-name>
            <url-pattern>/*</url-pattern> </filter-mapping> </web-app>

配置springmvc文件：

实体类：

package com.mengyangchen.pojo;
    
    import java.io.Serializable;
    
    public class User implements Serializable { 
        private String name;
        private int age;
        private String sex;
    
        public User() { 
        }
    
        public User(String name, int age, String sex) { 
            this.name = name;
            this.age = age;
            this.sex = sex;
        }
    
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        public int getAge() { 
            return age;
        }
    
        public void setAge(int age) { 
            this.age = age;
        }
    
        public String getSex() { 
            return sex;
        }
    
        public void setSex(String sex) { 
            this.sex = sex;
        }
    
        @Override
        public String toString() { 
            return "User{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", sex='" + sex + '\'' +
                    '}';
        }
    }

控制层：

@Controller
    public class FirstJsonController { 
        @RequestMapping("/json")
        @ResponseBody //不走视图解析器
        public String json1() throws JsonProcessingException { 
            //创建一个jackson的对象映射器，用来解析数据
            ObjectMapper mapper = new ObjectMapper();
            //创建一个对象
            User user = new User("梦阳辰", 20, "男");
            //将我们的对象解析成为json格式
            String str = mapper.writeValueAsString(user);
            //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
            return str;
        }
    }

![在这里插入图片描述][20210110211120178.png]  
**可以看到出现乱码问题：**  
方法1：

通过@RequestMaping的produces属性来实现，修改下代码
    //produces:指定响应体返回类型和编码
    @RequestMapping(value = "/json",produces = "application/json;charset=utf-8")

方法2 ：  
上一种方法比较麻烦，如果项目中有许多请求则每一个都要添加，可以通过Spring配置统一指定，这样就不用每次都去处理了！

springmvc的配置文件上添加一段消息StringHttpMessageConverter转换配置

<mvc:annotation-driven>
       <mvc:message-converters register-defaults="true">
           <bean class="org.springframework.http.converter.StringHttpMessageConverter">
               <constructor-arg value="UTF-8"/>
           </bean>
           <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
               <property name="objectMapper">
                   <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                       <property name="failOnEmptyBeans" value="false"/>
                   </bean>
               </property>
           </bean>
       </mvc:message-converters>
    </mvc:annotation-driven>

![在这里插入图片描述][20210110211946587.png]  
**集合输出**

@Controller
    public class FirstJsonController { 
        @RequestMapping("/json")
        @ResponseBody //不走视图解析器
        public String json1() throws JsonProcessingException { 
            //创建一个jackson的对象映射器，用来解析数据
            ObjectMapper mapper = new ObjectMapper();
            List<User> list = new LinkedList<>();
            //创建一个对象
            User user1 = new User("梦阳辰", 20, "男");
            User user2 = new User("梦", 20, "男");
            User user3 = new User("阳辰", 20, "男");
            list.add(user1);
            list.add(user2);
            list.add(user3);
    
            //将我们的对象解析成为json格式
            String str = mapper.writeValueAsString(list);
            //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
            return str;
        }
    }

![在这里插入图片描述][202101102122462.png]

**处理时间数据：**  
抽取转换为json的代理作为工具类：

public class JsonUtils { 
       
       public static String getJson(Object object) { 
           return getJson(object,"yyyy-MM-dd HH:mm:ss");
      }
    
       public static String getJson(Object object,String dateFormat) { 
           ObjectMapper mapper = new ObjectMapper();
           //不使用时间差的方式
           mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
           //自定义日期格式对象
           SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
           //指定日期格式
           mapper.setDateFormat(sdf);
           try { 
               return mapper.writeValueAsString(object);
          } catch (JsonProcessingException e) { 
               e.printStackTrace();
          }
           return null;
      }
    }

控制层：

@Controller
    public class FirstJsonController { 
        @RequestMapping("/json")
        @ResponseBody //不走视图解析器
        public String json1() throws JsonProcessingException { 
            //创建一个jackson的对象映射器，用来解析数据
            ObjectMapper mapper = new ObjectMapper();
    
            List<User> list = new LinkedList<>();
            //创建一个对象
            User user1 = new User("梦阳辰", 20, "男",new Date());
            User user2 = new User("梦", 20, "男",new Date());
            User user3 = new User("阳辰", 20, "男",new Date());
            list.add(user1);
            list.add(user2);
            list.add(user3);
    
            //将我们的对象解析成为json格式
            String str = JsonUtils.getJson(list);
            //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
            return str;
        }
    }

结果：  
![在这里插入图片描述][20210110213104843.png]

**实体类中包含集合数据：**

package com.mengyangchen.pojo;
    
    import java.util.List;
    
    public class State { 
        private String status;//操作是否成功
        private List<User> users;
    
        public State() { 
        }
    
        public State(String status, List<User> users) { 
            this.status = status;
            this.users = users;
        }
    
        public String getStatus() { 
            return status;
        }
    
        public void setStatus(String status) { 
            this.status = status;
        }
    
        public List<User> getUsers() { 
            return users;
        }
    
        public void setUsers(List<User> users) { 
            this.users = users;
        }
    
        @Override
        public String toString() { 
            return "State{" +
                    "status='" + status + '\'' +
                    ", users=" + users +
                    '}';
        }
    }

控制层：

package com.mengyangchen.controller;
    
    import com.fasterxml.jackson.core.JsonProcessingException;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.mengyangchen.pojo.State;
    import com.mengyangchen.pojo.User;
    import com.mengyangchen.util.JsonUtils;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    import java.util.Date;
    import java.util.LinkedList;
    import java.util.List;
    
    @Controller
    public class FirstJsonController { 
        @RequestMapping("/json")
        @ResponseBody //不走视图解析器
        public String json1() throws JsonProcessingException { 
            //创建一个jackson的对象映射器，用来解析数据
            ObjectMapper mapper = new ObjectMapper();
    
            List<User> list = new LinkedList<>();
            //创建一个对象
            User user1 = new User("梦阳辰", 20, "男",new Date());
            User user2 = new User("梦", 20, "男",new Date());
            User user3 = new User("阳辰", 20, "男",new Date());
            list.add(user1);
            list.add(user2);
            list.add(user3);
    
            //将我们的对象解析成为json格式
            String str = JsonUtils.getJson(list);
            //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
            return str;
        }
    
        @RequestMapping("/json2")
        @ResponseBody //不走视图解析器
        public String json2() throws JsonProcessingException { 
            //创建一个jackson的对象映射器，用来解析数据
            ObjectMapper mapper = new ObjectMapper();
    
            List<User> list = new LinkedList<>();
            //创建一个对象
            User user1 = new User("梦阳辰", 20, "男",new Date());
            User user2 = new User("梦", 20, "男",new Date());
            User user3 = new User("阳辰", 20, "男",new Date());
            list.add(user1);
            list.add(user2);
            list.add(user3);
    
            State state = new State();
            state.setUsers(list);
            state.setStatus("操作成功！");
    
    
            //将我们的对象解析成为json格式
            String str = JsonUtils.getJson(state);
            //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
            return str;
        }
    
    }

结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70 9]

**不在地址栏访问改为表单提交：**

![在这里插入图片描述][20210110213735619.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70 10]  
**总结：**  
采用这种json数据的格式，后台数据直接返回给当前页面，不会进行页面的跳转。（之前的采用视图解析器的适用于转发和重定向）。

在类上直接使用 @RestController ，这样子，里面所有的方法都只会返回 json 字符串了，不用再每一个都添加@ResponseBody ！我们在前后端分离开发中，一般都使用 @RestController ，十分便捷！

## FastJson ##

fastjson.jar是阿里开发的一款专门用于Java开发的包，可以方便的实现json对象与JavaBean对象的转换，实现JavaBean对象与json字符串的转换，实现json对象与json字符串的转换。

**它可以已经将其封装成json工具类了，直接使用即可，它支持对时间数据的支持：**

导入依赖：

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

**fastjson 三个主要的类：**

**JSONObject 代表 json 对象**  
JSONObject对应json对象，通过各种形式的get()方法可以获取json对象中的数据，也可利用诸如size()，isEmpty()等方法获取"键：值"对的个数和判断是否为空。其本质是通过实现Map接口并调用接口中的方法完成的。

**JSONObject实现了Map接口**  
内部是有List接口中的方法来完成操作的。

**JSON代表 JSONObject和JSONArray的转化**  
仔细观察这些方法，主要是实现json对象，json对象数组，javabean对象，json字符串之间的相互转化.

@RequestMapping("/json")
        @ResponseBody //不走视图解析器
        public String json1() throws JsonProcessingException { 
    
            List<User> list = new LinkedList<>();
            //创建一个对象
            User user1 = new User("梦阳辰", 20, "男",new Date());
            User user2 = new User("梦", 20, "男",new Date());
            User user3 = new User("阳辰", 20, "男",new Date());
            list.add(user1);
            list.add(user2);
            list.add(user3);
    
            System.out.println("*******Java对象 转 JSON字符串(包括时间格式）*******");
            String str = JSON.toJSONStringWithDateFormat(list,JSON.DEFFAULT_DATE_FORMAT);
            String st = JSON.toJSONStringWithDateFormat(list,"yyyy-MM-dd");
    
            System.out.println("*******Java对象 转 JSON字符串*******");
            String str1 = JSON.toJSONString(list);
            System.out.println("JSON.toJSONString(list)==>"+str1);
            String str2 = JSON.toJSONString(user1);
            System.out.println("JSON.toJSONString(user1)==>"+str2);
    
            System.out.println("\n****** JSON字符串 转 Java对象*******");
            User jp_user1=JSON.parseObject(str2,User.class);
            System.out.println("JSON.parseObject(str2,User.class)==>"+jp_user1);
    
            System.out.println("\n****** Java对象 转 JSON对象 ******");
            JSONObject jsonObject1 = (JSONObject) JSON.toJSON(user2);
            System.out.println("(JSONObject) JSON.toJSON(user2)==>"+jsonObject1.getString("name"));
    
            System.out.println("\n****** JSON对象 转 Java对象 ******");
            User to_java_user = JSON.toJavaObject(jsonObject1, User.class);
            System.out.println("JSON.toJavaObject(jsonObject1, User.class)==>"+to_java_user);
            return st;
        }

![在这里插入图片描述][20210110221829655.png]

## json-lib的用法 ##

导入依赖或jar包

<dependency>
        <groupId>net.sf.json-lib</groupId>
        <artifactId>json-lib</artifactId>
        <version>2.4</version>
        <classifier>jdk15</classifier>
    </dependency>

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70 11]

> There is no elevator to success.You have to take the stairs.

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70_pic_center]

[https_docs.spring.io_spring-framework_docs_current_reference_html_web.html]: https://docs.spring.io/spring-framework/docs/current/reference/html/web.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70]: /images/20221119/3f8a1c7ad5c04afc933133745e97c87c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70 1]: /images/20221119/be4f3d653576466fbc03a1eeb9e8f492.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70 2]: /images/20221119/dc16d498b030428292b881c71586cec4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70 3]: /images/20221119/454004589f6346f9932d3cf3e5c28812.png
[2021010919544658.png]: /images/20221119/4c857de75b834da988e202e363fbf7f1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70 4]: /images/20221119/2d41a54f8fe847c98c7fb4004cd0f759.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20210109195615373.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20210109210310678.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f,size_16,color_FFFFFF,t_70
[2021010921001440.png]: https://img-blog.csdnimg.cn/2021010921001440.png
[2021010921003921.png]: https://img-blog.csdnimg.cn/2021010921003921.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/2021010921225959.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f,size_16,color_FFFFFF,t_70
[20210110144915351.png]: https://img-blog.csdnimg.cn/20210110144915351.png
[20210110145858130.png]: https://img-blog.csdnimg.cn/20210110145858130.png
[20210110153949706.png]: https://img-blog.csdnimg.cn/20210110153949706.png
[20210110154020523.png]: https://img-blog.csdnimg.cn/20210110154020523.png
[20210110155604960.png]: https://img-blog.csdnimg.cn/20210110155604960.png
[20210110155525514.png]: https://img-blog.csdnimg.cn/20210110155525514.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20210110160442596.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f,size_16,color_FFFFFF,t_70
[20210110160914426.png]: https://img-blog.csdnimg.cn/20210110160914426.png
[20210110160816564.png]: https://img-blog.csdnimg.cn/20210110160816564.png
[20210110211120178.png]: https://img-blog.csdnimg.cn/20210110211120178.png
[20210110211946587.png]: https://img-blog.csdnimg.cn/20210110211946587.png
[202101102122462.png]: https://img-blog.csdnimg.cn/202101102122462.png
[20210110213104843.png]: https://img-blog.csdnimg.cn/20210110213104843.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20210110214706934.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f,size_16,color_FFFFFF,t_70
[20210110213735619.png]: https://img-blog.csdnimg.cn/20210110213735619.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/20210110213745231.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f,size_16,color_FFFFFF,t_70
[20210110221829655.png]: https://img-blog.csdnimg.cn/20210110221829655.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70 11]: https://img-blog.csdnimg.cn/20210110172119673.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20210110222009148.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYWh1YW5f,size_16,color_FFFFFF,t_70#pic_center