SpringMVC原理分析 | JSON、Jackson、FastJson

简介: SpringMVC原理分析 | JSON、Jackson、FastJson


JSON

JSON(JavaScriptObject Notation,JS对象简谱)是一种轻量级的数据交换格式。它基于 ECMAScript(European Computer Manufacturers Association,欧洲计算机协会制定的js规范)的一个子集,采用完全独立于编程语言的文本格式来存储和表示数据。简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。 易于人阅读和编写,同时也易于机器解析和生成,并有效地提升网络传输效率

特点:

  • 对象表示键值对,数据由逗号分隔
  • 花括号保存对象{}
  • 方括号保存数据[]

语法格式:

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

JSON & JavaScript对象相互转换

JavaScript对象 ——> JSON对象
<script type="text/javascript">
        //编写一个JavaScript对象
        var user = {
            name: "wei_shuo",
            age: 18,
            sex: "男"
        };
        //将JavaScript对象转换为JSON对象
        let json = JSON.stringify(user);
        console.log(json);
    </script>
JSON对象 ——> JavaScript对象
<script type="text/javascript">
        //编写一个JavaScript对象
        var user = {
            name: "wei_shuo",
            age: 18,
            sex: "男"
        };
        //将JSON对象对象转换为JavaScript对象
        let obj = JSON.parse(json);
        console.log(obj)
    </script>

var、let、const | 全局、函数、块级作用域

函数作用域:var

块级作用域:let、const

  • 全局作用域:函数之外,使用var进行定义,在全局中都能使用的变量,称为全局变量,全局变量对应的作用域就是全局作用域
  • 函数作用域:函数之内,使用var进行定义,只能在该函数中使用的变量,称为函数变量(局部变量),局部变量对应的作用域就是函数作用域(局部作用域)
  • 块级作用域:ES6中,可以通过关键词let来定义变量,通过let定义的变量,只能在当前代码块(以 { } 为界限)中使用,对应的作用域为块级作用域

Jackson

Jackson 是用来解析 JSON 的框架是一种数据格式,用来在客户端和服务器之间,或系统组件之间交换数据

环境搭建

  • pom.xml中导包:导入Jackson和lambok的jar包
<dependencies>
  <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.14.0-rc3</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
   </dependency>
</dependencies>
  • 配置核心配置文件: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>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--通过初始化参数指定SpringMVC配置文件的位置,进行关联-->
        <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-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">
    <!--自动扫描指定的包,下面所有的注解交给IOC容器管理-->
    <context:component-scan base-package="com.wei.controller"/>
    <!--配置annotation-driven使:处理器映射器 和 处理器适配器 自动完成实例的注入-->
    <mvc:annotation-driven/>
    <!--视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>
  • User类
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private String name;
    private int age;
    private String sex;
}
  • UserController类
@Controller
public class UserController {
    //produces = "application/json;charset=utf-8" : 解决JSON对象乱码问题
    @RequestMapping(value = "/j1",produces = "application/json;charset=utf-8")
    @ResponseBody   //@ResponseBody不会通过视图解析器,会直接返回一个字符串
    public String json1() throws JsonProcessingException {
        //使用jackson包,创建ObjectMapper对象
        ObjectMapper mapper = new ObjectMapper();
        //创建对象
        User user = new User("wei_shuo",18,"男");
        String str = mapper.writeValueAsString(user);
        return str;
    }
}

JSON乱码解决

注解方式
//produces = "application/json;charset=utf-8" : 解决JSON对象乱码问题
    @RequestMapping(value = "/j1",produces = "application/json;charset=utf-8")
Spring配置方式
<!--JSON乱码解决-->
    <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>

返回JSON对象

  • @Controller:代码通过视图解析器
  • @RequestMapping:处理请求地址映射
  • @ResponseBody:@ResponseBody不会通过视图解析器,会直接返回一个字符串,同@Controller注解同时使用
  • @RestController:直接返回一个字符串
  • JSON返回普通对象
//代码通过视图解析器
@Controller
public class UserController {
    //produces = "application/json;charset=utf-8" : 解决JSON对象乱码问题
    @RequestMapping(value = "/j1")
    @ResponseBody   //@ResponseBody不会通过视图解析器,会直接返回一个字符串
    public String json1() throws JsonProcessingException {
        //使用jackson包,创建ObjectMapper对象
        ObjectMapper mapper = new ObjectMapper();
        //创建对象
        User user = new User("wei_shuo",18,"男");
        String str = mapper.writeValueAsString(user);
        return str;
    }
}
  • JSON返回集合对象
//直接返回一个字符串
@RestController
public class UserController {
    @RequestMapping("/j2")
    public String json2() throws JsonProcessingException {
        //使用jackson包,创建ObjectMapper对象
        ObjectMapper mapper = new ObjectMapper();
        //创建集合对象
        ArrayList<User> userList = new ArrayList<>();
        //创建对象
        User user1 = new User("wei_shuo",18,"男");
        User user2 = new User("tian_tain",19,"男");
        User user3 = new User("wu_wu",14,"男");
        User user4 = new User("qi_qi",25,"男");
        userList.add(user1);
        userList.add(user2);
        userList.add(user3);
        userList.add(user4);
        String str = mapper.writeValueAsString(userList);
        return str;
    }
}
  • JSON返回时间对象
@RestController
public class UserController {
    @RequestMapping("/j3")
    public String json3() throws JsonProcessingException {
        //使用jackson包,创建ObjectMapper对象
        ObjectMapper mapper = new ObjectMapper();
        //创建时间对象
        Date date = new Date();
        //自定义日期格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = sdf.format(date);
        String str = mapper.writeValueAsString(format);
        return str;         // "2022-11-19 18:08:43"
    }
}
  • 编写utils工具类返回时间对象(JsonUtils类)
package com.wei.utils;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import java.text.SimpleDateFormat;
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){
        //使用jackson包,创建ObjectMapper对象
        ObjectMapper mapper = new ObjectMapper();
        //不使用时间戳的方式
        mapper.configure(SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS,false);
        //自定义日期的格式
        SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
        mapper.setDateFormat(sdf);
        try {
            return mapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;
    }
}
  • UserController类
//直接返回一个字符串
@RestController
public class UserController {
    @RequestMapping("/j1")
    public String json2() throws JsonProcessingException {
        //创建集合对象
        ArrayList<User> userList = new ArrayList<>();
        //创建对象
        User user1 = new User("wei_shuo",18,"男");
        User user2 = new User("tian_tain",19,"男");
        User user3 = new User("wu_wu",14,"男");
        User user4 = new User("qi_qi",25,"男");
        userList.add(user1);
        userList.add(user2);
        userList.add(user3);
        userList.add(user4);
        return JsonUtils.getJson(userList);
    }
    @RequestMapping("/j2")
    public String json3() throws JsonProcessingException {
        //创建时间对象
        Date date = new Date();
        return JsonUtils.getJson(date,"yyyy-MM-dd HH:mm:ss");
    }
}

FastJson

Fastjson是一个Java语言编写的高性能功能完善的JSON库。它采用一种“假定有序快速匹配”的算法,把JSON Parse的性能提升到极致,是目前Java语言中最快的JSON库。Fastjson接口简单易用,已经被广泛使用在缓存序列化、协议交互、Web输出、Android客户端等多种应用场景

环境搭建

  • 导入pom.xml依赖
<dependencies>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>2.0.18</version>
    </dependency>
</dependencies>
  • 使用FastJson
@RestController
public class UserController {
    @RequestMapping("/j1")
    public String json1() throws JsonProcessingException {
        //创建集合对象
        ArrayList<User> userList = new ArrayList<>();
        //创建对象
        User user1 = new User("wei_shuo",18,"男");
        User user2 = new User("tian_tain",19,"男");
        User user3 = new User("wu_wu",14,"男");
        User user4 = new User("qi_qi",25,"男");
        userList.add(user1);
        userList.add(user2);
        userList.add(user3);
        userList.add(user4);
        String s = JSON.toJSONString(userList);
        return s;
    }
}

Java <——> Json相互转换

Java对象——>Json字符串 JSON.toJSONString(Object,object);
Json字符串——>Java对象 JSON.parseObject(String str, Class objectClass);
Java对象——>Json对象 JSON.parseObject(String str, Class objectClass);
Java对象——>Json对象 JSON.toJSON(Object javaObject);
Json对象——>Java对象 JSON.toJavaObject(JSON json, Class clazz);
@RestController
public class UserController {
    @RequestMapping("/j1")
    public String json1() throws JsonProcessingException {
        //创建集合对象
        ArrayList<User> userList = new ArrayList<>();
        //创建对象
        User user1 = new User("wei_shuo", 18, "男");
        User user2 = new User("tian_tain", 19, "男");
        User user3 = new User("wu_wu", 14, "男");
        User user4 = new User("qi_qi", 25, "男");
        userList.add(user1);
        userList.add(user2);
        userList.add(user3);
        userList.add(user4);
        System.out.println("Java对象——>Json字符串");
        String str1 = JSON.toJSONString(userList);
        System.out.println("JSON字符串:" + str1);
        System.out.println("=================");
        String str2 = JSON.toJSONString(user1);
        System.out.println("JSON字符串:" + str2);
        System.out.println("=================");
        System.out.println("Json字符串——>Java对象");
        User Json_TO_Java1 = JSON.parseObject(str2, User.class);
        System.out.println("Java对象:" + Json_TO_Java1);
        System.out.println("Java对象——>Json对象");
        JSONObject jsonObject = (JSONObject) JSON.toJSON(user1);
        System.out.println("Json对象:" + jsonObject.getString("name"));
        System.out.println("Json对象——>Java对象");
        User Json_TO_Java2 = JSON.toJavaObject(jsonObject, User.class);
        System.out.println("Java对象:" + Json_TO_Java2);
        return "Hello";
    }
}
/*
输出结果:
Java对象——>Json字符串
JSON字符串:[{"age":18,"name":"wei_shuo","sex":"男"},{"age":19,"name":"tian_tain","sex":"男"},{"age":14,"name":"wu_wu","sex":"男"},{"age":25,"name":"qi_qi","sex":"男"}]
=================
JSON字符串:{"age":18,"name":"wei_shuo","sex":"男"}
=================
Json字符串——>Java对象
Java对象:User(name=wei_shuo, age=18, sex=男)
Java对象——>Json对象
Json对象:wei_shuo
Json对象——>Java对象
Java对象:User(name=wei_shuo, age=18, sex=男)
*/

🌼 结语:创作不易,如果觉得博主的文章赏心悦目,还请——点赞👍收藏⭐️评论📝


目录
相关文章
|
3月前
|
XML JSON JavaScript
javaweb实训第六天上午——JSON&SpringMVC进阶(1)
1.课程介绍 JSON; (了解) SpringMVC返回JSON; (掌握) SpringMVC文件上传、下载; (掌握) SpringMVC拦截器; (掌握) SpringMVC执行流程; (掌握) 2.JSON 2.1.JSON概述
55 0
|
4月前
|
JSON 数据格式
SpringMVC-接收请求中的json数据及日期类型参数传递
SpringMVC-接收请求中的json数据及日期类型参数传递
50 0
|
3月前
|
XML JSON 前端开发
Ajax技术【Ajax技术详解、 Ajax 的使用、Ajax请求、 JSON详解、JACKSON 的使用 】(一)-全面详解(学习总结---从入门到深化)
Ajax技术【Ajax技术详解、 Ajax 的使用、Ajax请求、 JSON详解、JACKSON 的使用 】(一)-全面详解(学习总结---从入门到深化)
58 1
|
1月前
|
JSON Java API
最流行的JSON库---Jackson,详细使用教程,手把手写代码
最流行的JSON库---Jackson,详细使用教程,手把手写代码。我将从“ 是什么?为什么?怎么用?”三个角度入手,一文搞懂Jackson!
34 0
最流行的JSON库---Jackson,详细使用教程,手把手写代码
|
1月前
|
JSON Java Maven
使用Jackson进行 JSON 序列化和反序列化
使用Jackson进行 JSON 序列化和反序列化
23 0
|
2月前
|
JSON fastjson Java
FastJSON操作各种格式的JSON数据
FastJSON处理各种格式的JSON数据
|
3月前
|
JSON fastjson 数据库
字符编码导致Rapidjson(腾讯开源的json解析库)到Fastjson(阿里开发的Java json解析库)转换失败的原因分析
最近在客户端的开发的过程中,使用到了RapidJson,公司的开发是客户端和数据库端都由不同的人进行开发,我负责的客户端的逻辑开发(使用c++),开发工具同时使用了VS2017和QT的编译环境,使用QT主要是为了客户端界面开发方便,而使用了VS环境主要是维护公司开发的数据库接口库,这个库的唯一作用就是作为一个中间桥梁,使用Rapidjson将数据库接口的json数据格式解析为结构体数据,从而在客户端界面进行展示,或者接收客户端的数据,使用Rapidjson将其转换为json数据,发送给数据库接口以保存数据使用 。不太明白的可以参考我上一篇文章说明Rapidjson的使用过程-Parse解析数组
48 0
|
3月前
|
JSON 前端开发 Java
javaweb实训第六天上午——JSON&SpringMVC进阶(2)
5.SpringMVC拦截器 5.1.创建拦截器
53 0
|
4月前
|
JSON 数据格式
SpringMVC JSON数据交互 数据不回显问题
SpringMVC JSON数据交互 数据不回显问题
26 1
|
4月前
|
JSON fastjson Java
(fastjson)java 如何将String(字符串)与JSON互转
(fastjson)java 如何将String(字符串)与JSON互转
73 1