1、什么是JSON？
- JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式，目前使用特别广泛。
- 采用完全独立于编程语言的文本格式来存储和表示数据。
- 简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。
- 易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。
在JavaScript语言中，一切都是对象。因此，任何JavaScript支持的类型都可以通过JSON来表示，例如字符串、数字、对象、数组等。
语法格式
（1）对象表示键值对，由逗号隔开
（2）花括号保存对象
（3）方括号保存数组
例子：{“键” : “值”}
{
"name": "QinJiang"}
{
"age": "3"}
{
"sex": "男"}
很多人搞不清楚JSON和JavaScript的关系，其实可以这么理解：JSON是JavaScript的字符串表示法，它使用文本表示一个JS对象的信息，本质是一个字符串。
var obj = {
a: 'Hello', b: 'World'}; //这是一个对象，注意键名也是可以使用引号包裹的
var json = '{"a": "Hello", "b": "World"}'; //这是一个 JSON 字符串，本质是一个字符串
JSON和JavaScript对象互转
（1）从JSON字符串转换为JavaScript对象，使用JSON.parse（）方法；
var obj = JSON.parse('{"a": "Hello", "b": "World"}');
//结果是 {a: 'Hello', b: 'World'}
（2）从JavaScript对象转换为JSON字符串，使用JSON.stringify（）方法
var json = JSON.stringify({
a: 'Hello', b: 'World'});
//结果是 '{"a": "Hello", "b": "World"}'
代码测试
1、新建一个Module，srpingmvc05-json，添加web支持
2、在web目录下新建一个json-01.html，编写测试内容
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<script type="text/javascript">
// 编写一个js的对象
let user ={
name:"陈志辉",
age:18,
sex:"男"
}
// 将js对象转换为JSON字符串
let str = JSON.stringify(user);
console.log(str);
// 将JSON字符串转化为js对象
let user2 = JSON.parse(str);
console.log(user2.age,user2.name,user2.sex);
</script>
</body>
</html>
3、直接用浏览器打开，按F12查看控制台输出
2、Controller返回JSON数据
Jackson是目前比较交的json解析工具，还有阿里巴巴的fastjson等，这里我们使用jackson，首先导入它的jar包
<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.10.3</version>
</dependency>
1、配置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">
<!--1.注册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>
<!--所有请求都会被springmvc拦截 -->
<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>
2、配置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="chen.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>
3、编写一个User实体类
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<script type="text/javascript">
// 编写一个js的对象
let user ={
name:"陈志辉",
age:18,
sex:"男"
}
// 将js对象转换为JSON字符串
let str = JSON.stringify(user);
console.log(str);
// 将JSON字符串转化为js对象
let user2 = JSON.parse(str);
console.log(user2.age,user2.name,user2.sex);
</script>
</body>
</html>
4、编写Controller
@Controller
public class UserController {
@RequestMapping("/json1")
@ResponseBody
public String json1() throws JsonProcessingException {
ObjectMapper objectMapper = new ObjectMapper();
User user = new User("陈志辉2",20,"男");
String str = objectMapper.writeValueAsString(user);
return str;
}
}
5、配置Tomcat，启动测试！
所以我们设置
//produces:指定响应体返回类型和编码
@RequestMapping(value = "/json1",produces = "application/json;charset=utf-8")
3、代码优化
乱码统一解决
前面的那一种代码解决办法比较麻烦，如果有多个请求需要添加，那么我们可以通过Spring配置统一指定，这样就不用每次都去处理！
在springmvc的配置文件中，添加上：
<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>
接着我们可以直接在类上使用@RestController，这样的话所有的方法都只会返回json字符串，不用每个都添加@ResponseBody，我们在前后端开发中，一般都用@RestController，十分便捷！！
@RestController
public class UserController {
@RequestMapping(value = "/json1")
public String json1() throws JsonProcessingException {
//创建一个jackson的对象映射器，用来解析数据
ObjectMapper mapper = new ObjectMapper();
//创建一个对象
User user = new User("陈志辉2", 3, "男");
//将我们的对象解析成为json格式
String str = mapper.writeValueAsString(user);
//由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
return str;
}
}
成功！！
4、测试集合输出
增加一个新的方法
@RequestMapping("/json2")
public String json2() throws JsonProcessingException {
//创建一个jackson的对象映射器，用来解析数据
ObjectMapper mapper = new ObjectMapper();
//创建一个对象
User user1 = new User("志辉1号", 3, "男");
User user2 = new User("志辉2号", 3, "男");
User user3 = new User("志辉3号", 3, "男");
User user4 = new User("志辉4号", 3, "男");
List<User> list = new ArrayList<User>();
list.add(user1);
list.add(user2);
list.add(user3);
list.add(user4);
//将我们的对象解析成为json格式
String str = mapper.writeValueAsString(list);
return str;
}
运行结果：十分完美，没有任何问题！
5、输出时间对象
新增一个方法
@RequestMapping("/json3")
public String json3() throws JsonProcessingException {
ObjectMapper mapper = new ObjectMapper();
//创建时间一个对象，java.util.Date
Date date = new Date();
//将我们的对象解析成为json格式
String str = mapper.writeValueAsString(date);
return str;
}
- 默认的日期格式会是一个数字，是
1970年1月1日到当前日期的毫秒数 - Jackson默认是会把时间转成timestamps形式
解决方案：取消timestamps形式，自定义时间格式！！！
@RequestMapping("/json4")
public String json4() throws JsonProcessingException {
ObjectMapper mapper = new ObjectMapper();
//不使用时间戳的方式
mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
//自定义日期格式对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//指定日期格式
mapper.setDateFormat(sdf);
Date date = new Date();
String str = mapper.writeValueAsString(date);
return str;
}
6、抽取为工具类
如果遇到经常要使用到的代码，我们可以将其封装到一个工具人中
编写JsonUtils.java类
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 {
ObjectMapper mapper = new ObjectMapper();
//不使用时间差的方式
mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
//自定义日期格式对象
SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
//指定日期格式
mapper.setDateFormat(sdf);
return mapper.writeValueAsString(object);
}
}
这样我们使用工具类，就可以使得代码更加简洁啦
@RequestMapping(value = "/j2")
// @ResponseBody//添加之后就不会走试图解析器，会直接返回一个字符串
public String test2() throws JsonProcessingException {
ObjectMapper mapper = new ObjectMapper();
ArrayList<User> users = new ArrayList<>();
User user1 = new User("Tom1",13,"男");
User user2 = new User("Tom2",13,"男");
User user3 = new User("Tom3",13,"男");
User user4 = new User("Tom4",13,"男");
User user5 = new User("Tom5",13,"男");
users.add(user);
users.add(user2);
users.add(user3);
users.add(user4);
users.add(user5);
return JsonUtils.getJson(users);
}
@RequestMapping("/json5")
public String json5() throws JsonProcessingException {
Date date = new Date();
String json = JsonUtils.getJson(date);
return json;
}
都能完美运行！！！
7、FastJson
fastjson.jar是阿里开发的一款专门用于Java开发的包，可以方便的实现json对象与JavaBean对象的转换，实现JavaBean对象与json字符串的转换，实现json对象与json字符串的转换。实现json转换的方法有很多，最后的实现结果都是一样的！
fastjson的pom依赖
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.60</version>
</dependency>
FastJson三个主要的类：
1、JSONObject代表json对象
（1）JSONObject实现了Map接口, 猜想 JSONObject底层操作是由Map实现的。
（2）JSONObject对应json对象，通过各种形式的get()方法可以获取json对象中的数据，也可利用诸如size()，isEmpty()等方法获取"键：值"对的个数和判断是否为空。其本质是通过实现Map接口并调用接口中的方法完成的。
2、JSONArray代表json对象数组
（1）内部是有lIst接口的方法来完成操作的。
3、JSON代表JSONObject和JSONArray的转化
（1）JSON类源码分析使用
（2）仔细观察这些方法，主要是实现json对象，json对象数组，javabean对象，json字符串之间的转化。
代码测试，新建一个FastJsonDemo类
public class FastJsonDemo {
public static void main(String[] args) {
//创建一个对象
User user1 = new User("志辉1号", 3, "男");
User user2 = new User("志辉2号", 3, "男");
User user3 = new User("志辉3号", 3, "男");
User user4 = new User("志辉4号", 3, "男");
List<User> list = new ArrayList<User>();
list.add(user1);
list.add(user2);
list.add(user3);
list.add(user4);
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);
}
}
这种工具类，我们只需要掌握使用就好啦，在使用的时候再根据具体的业务去找对应的实现。和以前的commons-io那种工具包一样拿来用就行！