json是什么，看了之后我才恍然大悟
小 木 来 了 \textcolor{Orange}{小木来了} 小木来了
使 用 J S O N 可 以 很 方 便 的 和 后 台 的 J a v a 对 象 进 行 数 据 传 递 \textcolor{green}{使用JSON可以很方便的和后台的Java对象进行数据传递} 使用JSON可以很方便的和后台的Java对象进行数据传递
J S O N 对 于 我 们 的 学 习 是 必 不 可 少 的 ， 要 学 会 怎 么 去 使 用 \textcolor{green}{JSON对于我们的学习是必不可少的，要学会怎么去使用} JSON对于我们的学习是必不可少的，要学会怎么去使用
博 主 也 在 学 习 阶 段 ， 如 若 发 现 问 题 ， 请 告 知 ， 非 常 感 谢 \textcolor{Orange}{博主也在学习阶段，如若发现问题，请告知，非常感谢} 博主也在学习阶段，如若发现问题，请告知，非常感谢
昨 天 看 到 消 息 ， 上 周 到 了 周 榜 54 ， 非 常 感 谢 大 家 ， 而 我 也 要 继 续 加 油 ， 冲 啊 ！ ！ ！ \textcolor{red}{昨天看到消息，上周到了周榜54，非常感谢大家，而我也要继续加油，冲啊！！！} 昨天看到消息，上周到了周榜54，非常感谢大家，而我也要继续加油，冲啊！！！
所用到的代码都可以在这里找到
十、JSON
-
-
- 前言
- 1.Controller返回json数据
- 2.上面的乱码问题
- 3. 返回一个List集合
- 4. 返回一个时间
- （重要）
- 5. FastJson
-
前言
前后端分离：后端提供接口，前端负责渲染后端的数据
中间建立的方式：1.传一个对象。2.约定一个格式json
json是一种轻量级的数据交换格式；是JS的对象标记
一 些 优 点 ： \textcolor{orange}{一些优点：} 一些优点：
- 采用完全独立于编程语言的文本格式来存储和表示数据；
- 简洁和清晰的层次结构使得json成为理想的数据交换语言；
- 易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。
在js中，一切都是对象，因此任何js支持的类型都可以通过json来表示，例如字符串、数组等。
-
json键值对用来保存js对象的一种方式，和js对象的写法也差不多，键/值对组合中的键名写在前面并用双引号包裹，使用冒号：分割，然后紧接着值
-
{ "name":"王木木"} { "age":"18"}
-
而关于json和js对象的关系可以理解为
-
json是js对象的字符串表示法，它使用文本表示一个js对象的信息，本质是一个字符串
let obj = { a:"Hello",b:"nihao"};//这是一个对象，键名也可以用双引号包裹 let json = '{"a":"Hello","b":"nihao"}';//这是一个json字符串，本质是一个字符串
json和js对象互转
-
要实现从json子符串转换为js对象，使用json.parse()方法
let obj = JSON.parse('{"a":"Hello","b":"nihao"}'); //结果是{a:"Hello",b:"nihao"} -
要实现从js对象转换为json字符串，使用JSON.stringify()方法；
let json = JSON.stringify({ a:"Hello",b:"nihao"}); //结果是'{"a":"Hello","b":"nihao"}'
仔细看区别，不仔细看还以为是一样的。
− − > 我 们 进 行 测 试 \textcolor{OrangeRed}{--> 我们进行测试} −−>我们进行测试
DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Titletitle>
<script>
//编写一个js对象
let user={
"name":"王木木",
"age":"18"
};
//将js对象转换为json对象
let json = JSON.stringify({
a:"Hello",b:"nihao"});
//将json对象转换为js对象
let obj = JSON.parse('{"a":"Hello","b":"nihao"}');
console.log(obj)
console.log(user);
console.log(json);
script>
head>
<body>
body>
html>
我们发现对象是可以展开的，但是json是一个字符串
1.Controller返回json数据
工具有Jackson和阿里巴巴的fastjson后面都会遇到。
− − > 导 入 j a c k s o n 的 依 赖 \textcolor{OrangeRed}{--> 导入jackson的依赖} −−>导入jackson的依赖
<dependency>
<groupId>com.fasterxml.jackson.coregroupId>
<artifactId>jackson-databindartifactId>
<version>2.13.0version>
dependency>
− − > w e b . x m l 固 定 的 \textcolor{OrangeRed}{-->web.xml固定的} −−>web.xml固定的
<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>
− − > s p r i n g m v c − s e r v l e t . x m l \textcolor{OrangeRed}{-->springmvc-servlet.xml} −−>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.hxl.controller"/>
<mvc:default-servlet-handler/>
<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>
− − > 建 立 一 个 实 体 类 \textcolor{OrangeRed}{-->建立一个实体类} −−>建立一个实体类
package com.hxl.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
//记得导入lombok
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
private String name;
private int age;
private String sex;
}
− − > 编 写 c o n t r o l l e r \textcolor{OrangeRed}{-->编写controller} −−>编写controller
@Controller
public class UserController {
@RequestMapping("/j1")
@ResponseBody //他不会去走视图解析器，会直接返回一个字符串
private String jso1(){
//创建一个对象
User user = new User("王木木", 18, "男");
return user.toString();
}
}
− − > 将 项 目 的 a r t i f a c t ， l i b j a r 包 导 入 ， 配 置 t o m c a t 运 行 。 \textcolor{OrangeRed}{-->将项目的artifact，libjar包导入，配置tomcat运行。} −−>将项目的artifact，libjar包导入，配置tomcat运行。
在这里我们看到了乱码，此时镇定一下不要慌。
来看一下json的字符串格式
@Controller
public class UserController {
@RequestMapping("/j1")
@ResponseBody //他不会去走视图解析器，会直接返回一个字符串
private String jso1() throws JsonProcessingException {
//jackson,ObjectMapper
ObjectMapper mapper = new ObjectMapper();
//创建一个对象
User user = new User("王木木", 18, "男");
String str = mapper.writeValueAsString(user);
return str;
}
}
2.上面的乱码问题
- 在@Requestmapping中有一个produces属性
//produces：指定响应体返回类型和编码
@RequestMapping(value="/j1",produces = "application/json;charset=utf-8")
-
上述的方法比较麻烦，通过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字符串
-
@Controller是会走视图解析器
-
@ResponseBody //他不会去走视图解析器，会直接返回一个字符串。和@Controller配合使用，如果是@RestController，那么就不需要这个了
3. 返回一个List集合
@RequestMapping("/j2")
@ResponseBody
private String jso2() throws JsonProcessingException {
ObjectMapper mapper = new ObjectMapper();
ArrayList<User> userList = new ArrayList<User>();
User user1 = new User("王木木1", 18, "男");
User user2 = new User("王木木2", 18, "男");
User user3 = new User("王木木3", 18, "男");
User user4 = new User("王木木4", 18, "男");
userList.add(user1);
userList.add(user2);
userList.add(user3);
userList.add(user4);
String str = mapper.writeValueAsString(userList);
return str;
}
他会通过一个[]把我们所有的对象包裹起来，是一个集合
4. 返回一个时间
@RequestMapping("/j3")
@ResponseBody
private String jso3() throws JsonProcessingException {
ObjectMapper mapper = new ObjectMapper();
Date date = new Date();
//ObjectMapper，时间解析后的默认格式为Timestamp，时间戳
return mapper.writeValueAsString(date);
}
上述出来是一串数字，那么如果我们想得到更理想的时间，可以使用一下集中方法格式化
4.1 自定义日期
@RequestMapping("/j3")
@ResponseBody
private String jso3() throws JsonProcessingException {
ObjectMapper mapper = new ObjectMapper();
Date date = new Date();
//自定义日期的格式
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
simpleDateFormat.format(date);
//ObjectMapper，时间解析后的默认格式为Timestamp，时间戳
return mapper.writeValueAsString(simpleDateFormat);
}
4.2 使用ObjectMapper 来改掉默认格式输出
@RequestMapping("/j4")
@ResponseBody
private String json4() throws JsonProcessingException {
ObjectMapper mapper = new ObjectMapper();
//不适用时间戳的方式
mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
//自定义日期的格式
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
mapper.setDateFormat(simpleDateFormat);
Date date = new Date();
//ObjectMapper，时间解析后的默认格式为Timestamp，时间戳
return mapper.writeValueAsString(date);
}
（重要）
上面的方式我们就可以打包称一个工具类。
public class JsonUtils {
public static String getJson(Object object,String simpleDateFormat){
ObjectMapper mapper = new ObjectMapper();
//不适用时间戳的方式
mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
//自定义日期的格式
SimpleDateFormat sdf = new SimpleDateFormat(simpleDateFormat);
mapper.setDateFormat(sdf);
try {
return mapper.writeValueAsString(object);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
return null;
}
}
我们的方法就变得简单了：
@RequestMapping("/j5")
@ResponseBody
private String json5() throws JsonProcessingException {
Date date = new Date();
return JsonUtils.getJson(date,"yyyy-MM-dd HH-mm-ss");
}
我们重载上面的方法，我们该怎么进行呢？
源码的思想
public static String getJson(Object object){
return getJson(object,"yyyy-MM-dd HH-mm-ss");
}
直接调用上面的方法即可，源码的好多方法都是这么来进行的。
后端转成json要注意几个点：
- 要导入jackson-databind的包
- 配置乱码问题
- 返回json要么用@Controller+@RequestMapping，要么使用@RestController
- 也可以构建个工具
5. FastJson
<dependency>
<groupId>com.alibabagroupId>
<artifactId>fastjsonartifactId>
<version>1.2.78version>
dependency>
主要的三个类：
- JSONObject代表json对象
- JSONObject实现了Map接口，猜想JSONObject底层操作是由Map实现的。
- JSONObject对应json对象，通过各种形式的get()方法可以获取json对象中的数据，也可利用size()。isEmpty()等方法获取“键：值”对的个数和判断是否为空，其本质是通过实现Map接口并调用接口中的方法完成的。
- JSONArray代表json对象数组
- 内部具有List接口中的方法来完成操作
- JSON代表JSONObject和JSONArray的转化
- JSON类源码分析与使用
- 观察这些方法，主要是实现json对象，json对象数组，javabean对象，jsoon字符串之间的相互转化。
@RequestMapping("/j6")
@ResponseBody
private String json6(){
ArrayList<User> userList = new ArrayList<User>();
User user1 = new User("王木木1", 18, "男");
User user2 = new User("王木木2", 18, "男");
User user3 = new User("王木木3", 18, "男");
User user4 = new User("王木木4", 18, "男");
userList.add(user1);
userList.add(user2);
userList.add(user3);
userList.add(user4);
//java对象转json字符串
String str = JSON.toJSONString(userList);
String str2 = JSON.toJSONString(user1);
System.out.println(str);
//json字符串转java对象
User u1 = JSON.parseObject(str2,User.class);
System.out.println(u1);
//java对象转json字对象
JSONObject jo1 = (JSONObject)JSON.toJSON(user2);
System.out.println(jo1);
//json对象转java对象
User to_java_user = JSON.toJavaObject(jo1,User.class);
System.out.println(to_java_user);
return "test";
}
