• 八、SpringMVC（2）

    文章目录

    一、RestFul 风格

    1.1 RestFul的概述

    1.1.1 什么是 RestFul ？

    在这里插入图片描述

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

    1.1.2 为什么要学习 RestFul ？

    因为基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。

    1.1.3 RestFul 的 功能

    • 资源：互联网所有的事物都可以被抽象为资源
    • 资源操作：使用POST、DELETE、PUT、GET，使用不同方法对资源进行操作。
      分别对应 添加、 删除、修改、查询。

    （1）传统方式操作资源 ：

    通过不同的参数来实现不同的效果！方法单一，post 和 get

    http://127.0.0.1/item/queryItem.action?id=1 查询,GET

http://127.0.0.1/item/saveItem.action 新增,POST

http://127.0.0.1/item/updateItem.action 更新,POST

http://127.0.0.1/item/deleteItem.action?id=1 删除,GET或POST

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    （2）使用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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    1.2 测试案例

    1. 在上一节 的工程下创建一个子工程 springmvc-05-restfulController

    在这里插入图片描述
    2. Web.xml

    
<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>springmvcservlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
        <init-param>
            <param-name>contextConfigLocationparam-name>
            <param-value>classpath:springmvc-servlet.xmlparam-value>
        init-param>
    servlet>

    <servlet-mapping>
        <servlet-name>springmvcservlet-name>
        <url-pattern>/url-pattern>
    servlet-mapping>
web-app>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    1. springmvc-servlet.xml
    
<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.zql.controller"/>

    
    <mvc:annotation-driven/>
    
    <mvc:default-servlet-handler/>
    
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    bean>
beans>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    1. RestfulController.java
    package com.zql.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

/**
 * @Author:Daniel
 * @Version 1.0
 */

@Controller
public class RestfulController  {

    @RequestMapping(value = "/hollow/{a}/{b}")

    //@PathVariable 注解，让方法参数的值对应绑定到一个URI模板变量上。PathVariable:路径变量
    public String  restful(@PathVariable int a, @PathVariable int b, Model model){

        int result = a+b;

        //Spring MVC会自动实例化一个Model对象用于向视图中传值
        model.addAttribute("msg","result = "+result);
        //返回视图位置
        return "hollow";
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    1. WEB-INF/jsp/hollow.jsp
    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>

    ${msg}

</body>
</html>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    1. 测试请求查看 http://localhost:8080/hollow/2/3

    在这里插入图片描述
    思考：使用路径变量的好处？

    1. 使路径变得更加简洁；
    2. 获得参数更加方便，框架会自动进行类型转换。
    3. 通过路径变量的类型可以约束访问参数，如果类型不一样，则访问不到对应的请求方法，如这里访问是的路径是/hollow/1/a，则路径与方法不匹配，而不会是参数转换失败。👇🏾👇🏾

    在这里插入图片描述
    7. 修改下对应的参数类型，再次测试 http://localhost:8080/hollow/1/sara

        @RequestMapping(value = "/hollow/{a}/{b}")

    //@PathVariable 注解，让方法参数的值对应绑定到一个URI模板变量上。PathVariable:路径变量
    public String  restful(@PathVariable int a, @PathVariable String b, Model model){

        String result = a+b;

        //Spring MVC会自动实例化一个Model对象用于向视图中传值
        model.addAttribute("msg","result = "+result);
        //返回视图位置
        return "hollow";
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    在这里插入图片描述
    使用method属性指定请求类型

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

        @RequestMapping(value = "/hollow/{a}/{b}",method = RequestMethod.POST)

    //@PathVariable 注解，让方法参数的值对应绑定到一个URI模板变量上。PathVariable:路径变量
    public String  restful(@PathVariable int a, @PathVariable String b, Model model){

        String result = a+b;

        //Spring MVC会自动实例化一个Model对象用于向视图中传值
        model.addAttribute("msg","result = "+result);
        //返回视图位置
        return "hollow";
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    我们使用浏览器地址栏进行访问默认是Get请求，会报错405： http://localhost:8080/hollow/1/sara

    在这里插入图片描述

    如果将POST修改为GET则正常了； http://localhost:8080/hollow/1/sara

        @RequestMapping(value = "/hollow/{a}/{b}",method = RequestMethod.GET)

    //@PathVariable 注解，让方法参数的值对应绑定到一个URI模板变量上。PathVariable:路径变量
    public String  restful(@PathVariable int a, @PathVariable String b, Model model){

        String result = a+b;

        //Spring MVC会自动实例化一个Model对象用于向视图中传值
        model.addAttribute("msg","result = "+result);
        //返回视图位置
        return "hollow";
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    在这里插入图片描述
    小结：

    Spring MVC 的 @RequestMapping 注解能够处理 HTTP 请求的方法, 比如 GET, PUT, POST, DELETE 以及 PATCH。

    所有的地址栏请求默认都会是 HTTP GET 类型的。

    方法级别的注解变体有如下几个：组合注解

    @GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping

    • 1
    • 2
    • 3
    • 4
    • 5
    • @GetMapping 是一个组合注解，平时使用的会比较多！
    • 它所扮演的是 @RequestMapping(method =RequestMethod.GET) 的一个快捷方式。

    二、结果跳转方式

    2.1 通过SpringMVC来实现转发和重定向 - 无需视图解析器

    测试前，需要将视图解析器注释掉

    package com.zql.controller;

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

/**
 * @Author:Daniel
 * @Version 1.0
 */

@Controller
public class ModelTest1 {

    @RequestMapping("a/hollow")
    public String test1(Model model){

        model.addAttribute("msg","ModelTest1");

        //return "hollow";

        //转发方式一
        return  "/WEB-INF/jsp/hollow.jsp";
        //转发方式二
        return "forward:/WEB-INF/jsp/hollow.jsp";
        //重定向
        return "redirect:/index.jsp";
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    测试访问入口：http://localhost:8080/a/hollow

    转发& 重定向 👇🏾👇🏾

    在这里插入图片描述

    在这里插入图片描述

    2.2 通过SpringMVC来实现转发和重定向 - 有视图解析器

    • 重定向 , 不需要视图解析器 , 本质就是重新请求一个新地方嘛 , 所以注意路径问题.
    • 可以重定向到另外一个请求实现 .
    package com.zql.controller;

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

/**
 * @Author:Daniel
 * @Version 1.0
 */

@Controller
public class ModelTest1 {

    @RequestMapping("a/hollow")
    public String test1(Model model){

        model.addAttribute("msg","ModelTest1");

        return "hollow";

        //重定向
        return "redirect:/index.jsp";
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    测试访问入口：http://localhost:8080/a/hollow
    在这里插入图片描述

    三、 数据处理

    3.1 处理提交数据

    1. 案例结构 ：

    在这里插入图片描述

    1. 创建 User.java
    package com.zql.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

/**
 * @Author:Daniel
 * @Version 1.0
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User implements Serializable {

    private int id;

    private String name;

    private String age;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    1. 创建UserController.java
    package com.zql.controller;

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

/**
 * @Author:Daniel
 * @Version 1.0
 */
@Controller
@RequestMapping("/user")
public class UserController {

    @RequestMapping("/t1")
    public String test1(Model model){
        //1.接收前端传过来的数据

        //2.将返回的结果传递给前端
        model.addAttribute("msg","");
        //3.视图跳转
        return "hollow";

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    1. http://localhost:8080/user/t1

    在这里插入图片描述

    3.1.1 提交的域名称和处理方法的参数名一致

    1. 提交数据：http://localhost:8080/user/t1?name=Daniel

    2. 处理方法：👇🏾👇🏾

    package com.zql.controller;

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

/**
 * @Author:Daniel
 * @Version 1.0
 */
@Controller
@RequestMapping("/user")
public class UserController {

    @RequestMapping("/t1")
    public String test1(String name, Model model){
        //1.接收前端传过来的数据
        System.out.println("前端传过来的数据"+name);
        //2.将返回的结果传递给前端
        model.addAttribute("msg",name);
        //3.视图跳转
        return "hollow";

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    1. 前后台输出：👇🏾👇🏾

    在这里插入图片描述

    3.1.2 提交的域名称和处理方法的参数名不一致

    1. 提交数据 ：http://localhost:8080/user/t1?username=Daniel

    2. 处理方法：👇🏾👇🏾

    package com.zql.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

/**
 * @Author:Daniel
 * @Version 1.0
 */
@Controller
@RequestMapping("/user")
public class UserController {

    @RequestMapping("/t1")
    
    public String test1(@RequestParam("username") String name, Model model){
        //@RequestParam("username") : username提交的域的名称 
        //1.接收前端传过来的数据
        System.out.println("传过来的数据是："+name);
        //2.将返回的结果传递给前端
        model.addAttribute("msg",name);
        //3.视图跳转
        return "hollow";

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    1. 前后台输出：👇🏾👇🏾

    在这里插入图片描述

    3.1.3 提交的是一个对象

    要求提交的表单域和对象的属性名一致 , 参数使用对象即可

    1. 提交数据 ：http://localhost:8080/user/t1?id=521&name=Daniel&age=18

    2. 处理方法：👇🏾👇🏾
      2.1 参考上述3.1>2 (User.java)
      2.2 👇🏾👇🏾

    package com.zql.controller;

import com.zql.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

/**
 * @Author:Daniel
 * @Version 1.0
 */
@Controller
@RequestMapping("/user")
public class UserController {

    @RequestMapping("/t1")

    public String test1(User user){

        //1.接收前端传过来的数据
        System.out.println("传过来的数据是："+user);
        //2.将返回的结果传递给前端

        //3.视图跳转
        return "hollow";

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    1. 前后台输出：👇🏾👇🏾

    在这里插入图片描述

    说明：如果使用对象的话，前端传递的参数名和对象名必须一致，否则就是null。

    3.2 数据显示到前端

    3.2.1 第一种 : 通过ModelAndView

    1. 创建 TestController.java
    package com.zql.controller;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

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

/**
 * @Author:Daniel
 * @Version 1.0
 */
public class TestController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {

        //返回一个模型视图对象
        ModelAndView mv = new ModelAndView();

        mv.addObject("msg","day day study,day day up!");

        mv.setViewName("hollow");

        return mv;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    1. 一定记得注入到spring容器中springmvc-servlet.xml
    <bean id="/hollow" class="com.zql.controller.TestController"/>

    • 1
    1. 访问：http://localhost:8080/hollow
      在这里插入图片描述

    3.2.2 第二种 : 通过ModelMap

    package com.zql.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * @Author:Daniel
 * @Version 1.0
 */
@Controller
@RequestMapping("/user")
public class ModelMapController {

    @RequestMapping("/t2")
    public String test(ModelMap map){

        //封装要显示到视图中的数据
        //相当于req.setAttribute("name",name);
        map.addAttribute("msg","Daniel521");

        return "hollow";
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    访问：http://localhost:8080/user/t2

    在这里插入图片描述

    3.2.3 第三种 : 通过Model

    package com.zql.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * @Author:Daniel
 * @Version 1.0
 */
@Controller
@RequestMapping("/user")
public class ModelMapController {

    @RequestMapping("/t2")
    public String test(Model model){

        //封装要显示到视图中的数据
        //相当于req.setAttribute("name",name);
        model.addAttribute("msg","Jenny311");

        return "hollow";
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    访问：http://localhost:8080/user/t2

    在这里插入图片描述
    总结对比：👇🏾👇🏾

    就对于新手而言简单来说使用区别就是：

    • Model 只有寥寥几个方法只适合用于储存数据，简化了新手对于Model对象的操作和理解；
    • ModelMap 继承了 LinkedMap ，除了实现了自身的一些方法，同样的继承 LinkedMap 的方法和特性；
    • ModelAndView 可以在储存数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转。

    在开发中考虑更多的是性能和优化，就不能单单仅限于此的了解。

    请使用80%的时间打好扎实的基础，剩下18%的时间研究框架，2%的时间学点英文，框架的官方文档永远是最好的教程。

    四、 乱码问题(四种方案)

    1. 案例结构

    在这里插入图片描述

    1. 创建 WEB-INF/form.jsp
    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <form action="/e/t" method="post">
        <input type="text" name="name">
        <input type="submit">
    </form>
</body>
</html>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    1. 创建 EncodingController.java
    package com.zql.controller;

import org.springframework.http.HttpRequest;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.context.support.HttpRequestHandlerServlet;

import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import java.io.UnsupportedEncodingException;

/**
 * @Author:Daniel
 * @Version 1.0
 */
@Controller
public class EncodingController {

   @RequestMapping(value = "/e/t",method = RequestMethod.POST)
    public String encoding(String name, Model model)  {

        model.addAttribute("msg",name); //获取表单提交的值

        return "hollow";//跳转到test页面显示输入的值
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    1. 运行：http://localhost:8080/form.jsp

    在这里插入图片描述

    1. 出现 乱码 👇🏾👇🏾（需求）：
      在这里插入图片描述

    解决办法一： 👇🏾👇🏾

    1. 创建 Encoding.java
    package com.zql.filter;

import javax.servlet.*;
import java.io.IOException;
import java.util.logging.LogRecord;

/**
 * @Author:Daniel
 * @Version 1.0
 */
public class Encoding implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException {
        //解决请求和响应乱码问题(可移动到过滤其中统一处理)
        request.setCharacterEncoding("UTF-8");
        response.setContentType("text/html;charset=utf-8");

        filterChain.doFilter(request,response);
    }

    @Override
    public void destroy() {

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    1. web.xml导入配置
    
<filter>
    <filter-name>encodingfilter-name>
    <filter-class>com.zql.filter.Encodingfilter-class>
filter>
<filter-mapping>
    <filter-name>encodingfilter-name>
    <url-pattern>/*url-pattern>
filter-mapping>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    测试：👉🏾👉🏾 http://localhost:8080/form.jsp

    解决办法二： 👇🏾👇🏾

    不得不说，乱码问题是在我们开发中十分常见的问题，也是让我们程序猿比较头大的问题！
    以前乱码问题通过过滤器解决(解决办法一) , 而SpringMVC给我们提供了一个过滤器 , 可以在web.xml中配置 .修改了xml 文件需要重启服务器！

    
<filter>
    <filter-name>encodingfilter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
    <init-param>
        <param-name>encodingparam-name>
        <param-value>utf-8param-value>
    init-param>
filter>
<filter-mapping>
    <filter-name>encodingfilter-name>
    <url-pattern>/*url-pattern>
filter-mapping>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    解决办法三： 👇🏾👇🏾

    但是我们发现 , 有些极端情况下.这个spring提供的对get的支持也不友好 .，看办法三 👇🏾👇🏾

    1、修改tomcat配置文件(\apache-tomcat-8.5.29\conf\server.xml) ：设置编码！

    <Connector URIEncoding="utf-8" port="8080" protocol="HTTP/1.1"
          connectionTimeout="20000"
          redirectPort="8443" />

    • 1
    • 2
    • 3

    解决办法四： 👇🏾👇🏾

    自定义过滤器

    1. 创建 GenericEncodingFilter.java
    package com.zql.filter;
/**
 * @Author:Daniel
 * @Version 1.0
 */
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
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    1. web.xml 配置引入
    
<filter>
    <filter-name>encodingfilter-name>
    <filter-class>com.zql.filter.GenericEncodingFilterfilter-class>
filter>
<filter-mapping>
    <filter-name>encodingfilter-name>
    <url-pattern>/*url-pattern>
filter-mapping>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    最终解决：👇🏾👇🏾 http://localhost:8080/form.jsp

    在这里插入图片描述

    总结：

    • 一般情况下，SpringMVC默认的乱码处理就已经能够很好的解决了！
    • 乱码问题，需要平时多注意，在尽可能能设置编码的地方，都设置为统一编码 UTF-8！

    五、JSON

    👉🏾👉🏾 之前都总结过

    前后端分离时代 ：

    在这里插入图片描述

    5.1 什么是JSON？

    在这里插入图片描述

    在 JavaScript 语言中，一切都是对象。因此，任何JavaScript 支持的类型都可以通过 JSON 来表示，例如字符串、数字、对象、数组等。看看他的要求和语法格式：

    对象表示为键值对，数据由逗号分隔

    花括号保存对象

    方括号保存数组

    JSON 键值对是用来保存 JavaScript 对象的一种方式，和 JavaScript 对象的写法也大同小异，键/值对组合中的键名写在前面并用双引号 “” 包裹，使用冒号 : 分隔，然后紧接着值：

    {"name": "Daniel"}
{"age": "3"}
{"sex": "男"}

    • 1
    • 2
    • 3

    很多人搞不清楚 JSON 和 JavaScript 对象的关系，甚至连谁是谁都不清楚。其实，可以这么理解：

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

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

    • 1
    • 2

    5.2 JSON 和 JavaScript 对象互转

    1. 创建一个html👉🏾👉🏾 web/jsonTest.html
    DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>

    <script type="text/javascript">

        var user = {

            name:"Daniel",
            age:11,
            sex:"男"
        };
        /*js*/
        console.log(user);
    script>
head>
<body>

body>
html>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    在这里插入图片描述

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

    var json = JSON.stringify(user)
console.log(json);//输出为：{"name":"Daniel","age":11,"sex":"男"}

    • 1
    • 2

    在这里插入图片描述

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

    前提是将js已经转成了json

    var js = JSON.parse(json) //输出看截图
console.log(js)

    • 1
    • 2

    在这里插入图片描述

    1. 上述完整代码(创建一个html👉🏾👉🏾 web/jsonTest.html)：👇🏾👇🏾
    DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>

    <script type="text/javascript">

        var user = {

            name:"Daniel",
            age:11,
            sex:"男"
        };
        /*js*/
        console.log(user);
        /*1. 要实现从JavaScript 对象转换为JSON字符串，使用 JSON.stringify() 方法*/
        var json = JSON.stringify(user)
        console.log(json);//输出为：{"name":"Daniel","age":11,"sex":"男"}
        /*2. 要实现从JSON字符串转换为JavaScript 对象，使用 JSON.parse() 方法：*/
        var js = JSON.parse(json) //输出看截图
        console.log(js)

    script>
head>
<body>

body>
html>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    1. 在IDEA中使用浏览器打开，查看控制台(F12)输出！

    在这里插入图片描述

    5.3 Controller返回JSON数据

    1. Jackson应该是目前比较好的json解析工具了
    2. 当然工具不止这一个，比如还有阿里巴巴的 fastjson 等等。
    3. 我们这里使用Jackson，使用它需要导入它的jar包；

    案例

    1. 创建一个子工程 springmvc-06-json
      在这里插入图片描述

    2. 引入json对应的依赖 pom.xml

    
<dependency>
    <groupId>com.fasterxml.jackson.coregroupId>
    <artifactId>jackson-databindartifactId>
    <version>2.13.3version>
dependency>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    1. web.xml
    
<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>SpringMVCservlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
        
        <init-param>
            <param-name>contextConfigLocationparam-name>
            <param-value>classpath:springmvc-servlet.xmlparam-value>
        init-param>
        
        <load-on-startup>1load-on-startup>
    servlet>

    
    <servlet-mapping>
        <servlet-name>SpringMVCservlet-name>
        <url-pattern>/url-pattern>
    servlet-mapping>

    <filter>
        <filter-name>encodingfilter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
        <init-param>
            <param-name>encodingparam-name>
            <param-value>utf-8param-value>
        init-param>
    filter>
    <filter-mapping>
        <filter-name>encodingfilter-name>
        <url-pattern>/url-pattern>
    filter-mapping>

web-app>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    1. 创建springmvc-servlet.xml
    <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.zql.controller"/>

    
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          id="internalResourceViewResolver">
        
        <property name="prefix" value="/WEB-INF/jsp/" />
        
        <property name="suffix" value=".jsp" />
    bean>

beans>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    1. User.java
    package com.zql.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

/**
 * @Author:Daniel
 * @Version 1.0
 */
//需要导入lombok
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {

        private String name;
        private int age;
        private String sex;

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    1. UserController.java
    package com.zql.controller;

import com.zql.pojo.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;

/**
 * @Author:Daniel
 * @Version 1.0
 */
@Controller
public class UserController {

        @ResponseBody //不走视图解析器，直接返回（字符串）
        @RequestMapping("/json1")
        public String json1(){

            User user = new User("安卓",12,"男");

            return user.toString();
        }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    在这里插入图片描述

    • 发现出现了乱码问题，我们需要设置一下他的编码格式为utf-8，以及它返回的类型；
    • 通过@RequestMaping的produces属性来实现，修改下代码
    //produces:指定响应体返回类型和编码
@RequestMapping(value = "/json1",produces = "application/json;charset=utf-8")

    • 1
    • 2

    再次测试， http://localhost:8080/json1 ， 乱码问题OK！

    在这里插入图片描述
    乱码统一解决 👇🏾👇🏾

    • 上一种方法比较麻烦，如果项目中有许多请求则每一个都要添加，可以通过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>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    (1) 返回json字符串统一解决

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

     @RequestMapping(value = "/json2")
 public String json2() throws JsonProcessingException {
     //创建一个jackson的对象映射器，用来解析数据
     ObjectMapper mapper = new ObjectMapper();
     //创建一个对象
     User user = new User("安卓",12,"男");
     //将我们的对象解析成为json格式
     String str = mapper.writeValueAsString(user);
     //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
     return str;
 }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    启动tomcat测试，结果都正常输出！http://localhost:8080/json2

    在这里插入图片描述

    (2)测试集合输出 http://localhost:8080/json3

     @RequestMapping(value = "/json3")
 public String json3() throws JsonProcessingException {
     //创建一个jackson的对象映射器，用来解析数据
     ObjectMapper mapper = new ObjectMapper();
     //创建对象
     User user1 = new User("安卓1",12,"男1");
     User user2 = new User("安卓2",12,"男2");
     User user3 = new User("安卓3",12,"男3");
     User user4 = new User("安卓4",12,"男4");
     List<User> list = new ArrayList<>();
     list.add(user1);
     list.add(user2);
     list.add(user3);
     list.add(user4);
     //将我们的对象解析成为json格式
     String str = mapper.writeValueAsString(list);
     //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
     return str;
 }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    在这里插入图片描述

    (3) 输出时间对象 http://localhost:8080/json4

    @RequestMapping(value = "/json4")
public String json4() throws JsonProcessingException {
    //创建一个jackson的对象映射器，用来解析数据
    ObjectMapper mapper = new ObjectMapper();
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    //创建时间一个对象，java.util.Date
    Date date = new Date();
    //将我们的对象解析成为json格式
    String str = mapper.writeValueAsString(date);
    //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
    return str;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    在这里插入图片描述

    • 默认日期格式会变成一个数字，是1970年1月1日到当前日期的毫秒数！
    • Jackson 默认是会把时间转成timestamps(时间戳)形式

    解决方案：取消timestamps(时间戳)形式 ， 自定义时间格式 👇🏾👇🏾 http://localhost:8080/json4

    @RequestMapping(value = "/json4")
public String json4() throws JsonProcessingException {
    //创建一个jackson的对象映射器，用来解析数据
    ObjectMapper mapper = new ObjectMapper();
    //不使用时间戳的方式
    mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
    //自定义日期格式对象
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    //创建时间一个对象，java.util.Date
    Date date = new Date();
    mapper.setDateFormat(sdf);
    //将我们的对象解析成为json格式
    String str = mapper.writeValueAsString(date);
    //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
    return str;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    在这里插入图片描述

    抽取为工具类

    如果要经常使用的话，这样是比较麻烦的，我们可以将这些代码封装到一个工具类中；我们去编写下

    创建JsonUtils.java

    package com.zql.utils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @Author:Daniel
 * @Version 1.0
 */
public class JsonUtils {

    public static String getJson(Object object) throws JsonProcessingException {
        return getJson(object,"yyyy-MM-dd HH:mm:ss");
    }

    public static String getJson(Object object,String dateFormat ) throws JsonProcessingException {

        //创建一个jackson的对象映射器，用来解析数据
        ObjectMapper mapper = new ObjectMapper();

        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);

        SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);

        Date date = new Date();

        mapper.setDateFormat(sdf);

        return mapper.writeValueAsString(object);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    优化：json4

    @RequestMapping(value = "/json5")
public String json5() throws JsonProcessingException {

    Date date = new Date();

    return JsonUtils.getJson(date);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    优化：json3

     @RequestMapping(value = "/json3")
 public String json3() throws JsonProcessingException {
     //创建对象
     User user1 = new User("安卓1",12,"男1");
     User user2 = new User("安卓2",12,"男2");
     User user3 = new User("安卓3",12,"男3");
     User user4 = new User("安卓4",12,"男4");
     List<User> list = new ArrayList<>();
     list.add(user1);
     list.add(user2);
     list.add(user3);
     list.add(user4);
     String json = JsonUtils.getJson(list);
     //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
     return json;
 }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    5.4 FastJson(阿里开发包)

    fastjson.jar是 阿里 开发的一款专门用于Java开发的包，可以方便的实现json对象与JavaBean对象的转换，实现JavaBean对象与json字符串的转换，实现json对象与json字符串的转换。实现json的转换方法很多，最后的实现结果都是一样的。

    fastjson 的 pom依赖！

    
<dependency>
    <groupId>com.alibabagroupId>
    <artifactId>fastjsonartifactId>
    <version>2.0.10version>
dependency>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    fastjson 三个主要的类：

    (1) JSONObject 代表 json 对象

    1. JSONObject实现了Map接口, 猜想 JSONObject底层操作是由Map实现的。
    2. JSONObject对应json对象，通过各种形式的get()方法可以获取json对象中的数据，也可利用诸如size()，isEmpty()等方法获取"键：值"对的个数和判断是否为空。其本质是通过实现Map接口并调用接口中的方法完成的。

    (2) JSONArray 代表 json 对象数组

    1. 内部是有List接口中的方法来完成操作的。
    2. JSON代表 JSONObject和JSONArray的转化

    (3) JSON类源码分析与使用

    仔细观察这些方法，主要是实现json对象，json对象数组，javabean对象，json字符串之间的相互转化。

    代码测试，创建一个FastJsonController.java

    (1) http://localhost:8080/fastJson

    package com.zql.controller;

import com.alibaba.fastjson2.JSON;
import com.zql.pojo.User;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author:Daniel
 * @Version 1.0
 */
@RestController
public class FastJsonController {

@RequestMapping("/fastJson")
public String fastJson(){
    //创建对象
    User user1 = new User("安卓1",12,"男1");
    User user2 = new User("安卓2",12,"男2");
    User user3 = new User("安卓3",12,"男3");
    User user4 = new User("安卓4",12,"男4");
    List<User> list = new ArrayList<>();
    list.add(user1);
    list.add(user2);
    list.add(user3);
    list.add(user4);

    String fast = JSON.toJSONString(list);

    return fast;
}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36

    在这里插入图片描述
    (2) http://localhost:8080/fastJson2

    @RequestMapping("/fastJson2")
public String fastJson2(){
//创建对象
User user1 = new User("安卓1",12,"男1");
User user2 = new User("安卓2",12,"男2");
User user3 = new User("安卓3",12,"男3");
User user4 = new User("安卓4",12,"男4");
List<User> list = new ArrayList<>();
list.add(user1);
list.add(user2);
list.add(user3);
list.add(user4);

String fast = JSON.toJSONString(list);

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  fast;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    在这里插入图片描述

    这种工具类，只需要大家掌握使用就好了，在使用的时候在根据具体的业务去找对应的实现。和以前的commons-io那种工具包一样，拿来用就好了！

  • 相关阅读:
    Docker容器端口暴露方式
    维也纳酒店抚州市政中心店以品牌之力创造非凡价值
    浅析 SplitChunksPlugin 及代码分割的意义
    正确理解c# default关键字
    29.添加录入注入信息界面
    花青素染料 Cy3NS 酸，Cy3NS acid，CAS：1032678-01-5物化性质解析
    python-opencv图像的高通滤波和低通滤波
    uniapp app一键登录
    clip算法的研究
    第09章 房地产行业案例实战
  • 原文地址：https://blog.csdn.net/weixin_42171159/article/details/125993812