JSON（初识一）
JSON（初识一）
- 1.简介
-
- 1.1概念
- 1.2对象格式
- 1.3语法
-
- 1.3.1基本规则
- 1.3.2获取数据
- 2.JSON数据和Java对象的相互转换
-
- 2.1Gson
-
- 2.1.1将对象转换为JSON字符串
- 2.1.2将JSON字符串转换为对象
- 2.2FastJson
-
- 2.2.1将对象转换为JSON字符串
- 2.2.2将JSON字符串转换为对象
- 2.3JackSon
-
- 2.3.1 JSON转为Java对象
- 2.3.2Java对象转换JSON
1.简介
JSON: JavaScript Object Notation JS对象简谱 , 是一种轻量级的数据交换格式.
1.1概念
- 概念： JavaScript Object Notation JavaScript对象表示法
Person p = new Person();
p.setName("张三");
p.setAge(23);
p.setGender("男");
var p = {
"name":"张三","age":23,"gender":"男"};
* json现在多用于存储和交换文本信息的语法
* 进行数据的传输
* JSON 比 XML 更小、更快，更易解析。
1.2对象格式
一本书
书名
简介
- Java形式
class Book{
private String name;
private String info;
get/set...
}
Book b = new Book();
b.setName(“金苹果”);
b.setInfo(“种苹果”);
2.js形式
var b = new Object();
b.name = "金苹果";
b.info = "种苹果";
3.XML形式
<book>
<name>金苹果</name>
<info>种苹果</info>
</book>
4.JSON形式
{
"name":"金苹果",
"info":"种苹果"
}
1.3语法
一个对象, 由一个大括号表示. 括号中 描述对象的属性 . 通过键值对来描述对象的属性 (可以理解为, 大括号中,包含的是一个个的键值对.) 格式: 键与值之间使用冒号连接, 多个键值对之间使用逗号分隔. 键值对的键 应使用引号引住(通常Java解析时, 键不使用引号会报错. 而JS能正确解 析.) 键值对的值, 可以是JS中的任意类型的数据
1.3.1基本规则
- 数据在名称/值对中：json数据是由键值对构成的
* 键用引号(单双都行)引起来，也可以不使用引号
值得取值类型:
- 数字（整数或浮点数）
- 字符串（在双引号中）
- 逻辑值（true 或 false）
- 数组（在方括号中） {“persons”:[{},{}]}
- 对象（在花括号中） {“address”:{“province”：“陕西”…}}
- null
* 数据由逗号分隔：多个键值对由逗号分隔
* 花括号保存对象：使用{}定义json 格式
* 方括号保存数组：[]
1.3.2获取数据
- json对象.键名
- json对象[“键名”]
- 数组对象[索引]
- 遍历
//1.定义基本格式
//1.定义基本格式
var person = {
"name": "张三", age: 23, 'gender': true};
var ps = [{
"name": "张三", "age": 23, "gender": true},
{
"name": "李四", "age": 24, "gender": true},
{
"name": "王五", "age": 25, "gender": false}];
//获取person对象中所有的键和值
//for in 循环
/* for(var key in person){
//这样的方式获取不行。因为相当于 person."name"
//alert(key + ":" + person.key);
alert(key+":"+person[key]);
}*/
//获取ps中的所有值
for (var i = 0; i < ps.length; i++) {
var p = ps[i];
for(var key in p){
alert(key+":"+p[key]);
}
}
案例：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<script>
//1.定义基本格式
/* var person={"name":"张三",age:23,'gender':true};
for(var i in person){
alert(person[i])
}*/
//获取name值
//var name=person.name;
/* var name=person["name"];
alert(name);*/
//嵌套格式{}-->[]
var persons1={
"persons":[{
"name":"张三",age:23,gender:"true"},
{
"name":"李四",age:23,gender:"true"},
{
"name":"王五",age:23,gender:"false"}
],
"personsq":[{
"name":"张三",age:23,gender:"true"},
{
"name":"李四",age:23,gender:"true"},
{
"name":"王五",age:23,gender:"false"}
]
};
for(var i in persons1){
//获取键
var p=persons1[i];//获取值数组
alert("gg"+p);
for(var j=0;j<p.length;j++){
//遍历数组
var o=p[j];//获取数组中的对象
for(var s in o) {
//获取数组中的对象的键
alert(o[s]);
}
}
}
/* //拿李四值
var name1=persons.persons[1].name;
alert(name1);*/
//嵌套格式[]-->{}
/*var ps=[{"name":"张三",age:23,gender:"true"},
{"name":"李四",age:23,gender:"true"},
{"name":"王五",age:23,gender:"false"}];
//遍历
for(var i=0;i
/*//拿王五值
var name3=ps[2].name;
alert(name3);*/
</script>
</head>
<body>
</body>
</html>
2.JSON数据和Java对象的相互转换
可以做什么?
- 将Java中的对象 快速的转换为 JSON格式的字符串.
- 将JSON格式的字符串, 转换为Java的对象.
- JSON解析器： * 常见的解析器：Jsonlib，Gson，fastjson，jackson
下面简单介绍三种实现解析方式
2.1Gson
2.1.1将对象转换为JSON字符串
转换JSON字符串的步骤:
- 引入Gson相关JAR包
- 创建 Gson 的核心对象
Gson gson=new Gson();- 调用Gson的相关方法进行转换
String json = new Gson().toJSON(要转换的对象);
案例：
(1.创建实体类)
import java.util.Objects;
public class Book {
private String id;
private String name;
private String info;
public Book(){
}
public Book(String id, String name, String info) {
this.id = id;
this.name = name;
this.info = info;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
@Override
public String toString() {
return "Book{" +
"id='" + id + '\'' +
", name='" + name + '\'' +
", info='" + info + '\'' +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Book)) return false;
Book book = (Book) o;
return Objects.equals(id, book.id) &&
Objects.equals(name, book.name) &&
Objects.equals(info, book.info);
}
@Override
public int hashCode() {
return Objects.hash(id, name, info);
}
}
（2.实现）
import com.alibaba.fastjson.JSON;
import com.google.gson.Gson;
import java.util.List;
public class Demo {
public static void main(String[] args) {
//Gson 将对象转换为字符窜 new Gson().toJson(要转换的对象)
Book book=new Book("1008","金苹果","一个女孩种植了一棵金苹果树");
Gson gson=new Gson();
String s = gson.toJson(book);
System.out.println(s);
System.out.println("======================");
}
}
结果如下：
{
"id":"1008","name":"金苹果","info":"一个女孩种植了一棵金苹果树"}
======================
2.1.2将JSON字符串转换为对象
将JSON字符串转换为对象:
- 引入Gson相关JAR包
- 创建 Gson 的核心对象
Gson gson=new Gson();- 调用Gson的相关方法进行转换
对象 = new Gson().fromJson(JSON字符串,对象类型.class);
案例：
import com.alibaba.fastjson.JSON;
import com.google.gson.Gson;
import java.util.List;
public class Demo {
public static void main(String[] args) {
// Gson 将Json字符窜 转换为 对象
Book book1 = gson.fromJson("{\"id\":\"1008\",\"name\":\"金苹果\",\"info\":\"一个女孩种植了一个金苹果树\"}", Book.class);
System.out.println(book1);
}
}
测试结果如下：
Book{
id='1008', name='金苹果', info='一个女孩种植了一个金苹果树'}
2.2FastJson
2.2.1将对象转换为JSON字符串
转换JSON字符串的步骤:
- 引入FastJson相关JAR包
- 在需要转换JSON字符串的位置编写如下代码即可:
- String json=JSON.toJSONString(要转换的对象);
案例：
(1.创建实体类)
import java.util.Objects;
public class Book {
private String id;
private String name;
private String info;
public Book(){
}
public Book(String id, String name, String info) {
this.id = id;
this.name = name;
this.info = info;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
@Override
public String toString() {
return "Book{" +
"id='" + id + '\'' +
", name='" + name + '\'' +
", info='" + info + '\'' +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Book)) return false;
Book book = (Book) o;
return Objects.equals(id, book.id) &&
Objects.equals(name, book.name) &&
Objects.equals(info, book.info);
}
@Override
public int hashCode() {
return Objects.hash(id, name, info);
}
}
（2.实现）
import com.alibaba.fastjson.JSON;
import com.google.gson.Gson;
import java.util.List;
public class Demo {
public static void main(String[] args) {
//JSon.toJsonString(要转换的对象)
Book book=new Book("1008","金苹果","一个女孩种植了一棵金苹果树");
String s1 = JSON.toJSONString(book);
System.out.println(s1);
}
}
结果如下：
{
"id":"1008","name":"金苹果","info":"一个女孩种植了一棵金苹果树"}
======================
2.2.2将JSON字符串转换为对象
将JSON字符串转换为对象:
- 引入FastJson相关JAR包
- 在需要转换JSON字符串的位置编写如下代码即可:
- 类型 对象名=JSON.parseObject(JSON字符串, 类型.class);
或
List<类型> list=JSON.parseArray(JSON字符串,类型.class);
案例：
import com.alibaba.fastjson.JSON;
import com.google.gson.Gson;
import java.util.List;
public class Demo {
public static void main(String[] args) {
//FastJson 将Json字符转换为对象 parseObject()
Book book2 = JSON.parseObject("{\"id\":\"1008\",\"info\":\"一个女孩种植了一棵金苹果树\",\"name\":\"金苹果\"}", Book.class);
System.out.println(book2);
List<String> strings = JSON.parseArray("[\"123\",\"456\",\"789\"]", String.class);
System.out.println(strings);
}
}
测试结果如下：
Book{
id='1008', name='金苹果', info='一个女孩种植了一棵金苹果树'}
[123, 456, 789]
2.3JackSon
2.3.1 JSON转为Java对象
1. 导入jackson的相关jar包
2. 创建Jackson核心对象 ObjectMapper
3. 调用ObjectMapper的相关方法进行转换
readValue(json字符串数据,Class)
案例：
(1.实体类)
注解：
1. @JsonIgnore：排除属性。
2. @JsonFormat：属性值得格式化
* @JsonFormat(pattern = “yyyy-MM-dd”)
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonIgnore;
import java.util.Date;
import java.util.Objects;
public class Person {
private String name;
private int age;
private String gender;
//@JsonIgnore//忽略该属性
@JsonFormat(pattern="yyyy-MM-dd")
private Date birthday;
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", gender='" + gender + '\'' +
", birthday=" + birthday +
'}';
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Person)) return false;
Person person = (Person) o;
return getAge() == person.getAge() &&
Objects.equals(getName(), person.getName()) &&
Objects.equals(getGender(), person.getGender()) &&
Objects.equals(getBirthday(), person.getBirthday());
}
@Override
public int hashCode() {
return Objects.hash(getName(), getAge(), getGender(), getBirthday());
}
}
@Test
public void Test5() throws IOException {
//1.初始化JSON字符串
String json="{\"name\":\"张三\",\"age\":23,\"gender\":\"男\"}";
String s= "{\"gender\":\"男\",\"name\":\"张三\",\"age\":23}";
//2.创建ObjectMapper对象
ObjectMapper mapper=new ObjectMapper();
//转换为java对象 Person对象
Person person = mapper.readValue(json,Person.class);
System.out.println(person);
}
测试结果如下：
Person{
name='张三', age=23, gender='男', birthday=null}
2.3.2Java对象转换JSON
- 导入jackson的相关jar包
- 创建Jackson核心对象 ObjectMapper
- 调用ObjectMapper的相关方法进行转换
- 转换方法：
- writeValue(参数1，obj):
参数1：
File：将obj对象转换为JSON字符串，并保存到指定的文件中
Writer：将obj对象转换为JSON字符串，并将json数据填充到字符输出流中
OutputStream：将obj对象转换为JSON字符串，并将json数据填充到字节输出流中- writeValueAsString(obj):将对象转为json字符串
** writeValue(参数1，obj):案例一：**
@Test
public void Test1() throws IOException {
//1.创建Person对象
Person p=new Person();
p.setAge(18);
p.setGender("男");
p.setName("张三");
//2.创建Jackson核心对象 ObjectMapper
ObjectMapper mapper=new ObjectMapper();
//3.转换
//转换方法
/*mapper.writeValue(参数1,obj);
参数1:
File:将obj对象转换为JSON字符串，并保存到指定的文件中
Writer:将obj对象转换为JSON字符串，并将JSON数据填充到字符输出流中
OutputStream:将obj对象转换位JSON字符串，并将JSON数据填充到字符输出流中
writeValueAsString():将对象转换为JSON字符串
* */
String json = mapper.writeValueAsString(p);
// System.out.println(json);//{"name":"张三","age":18,"gender":"男"}
//将数据写到e://jon.txt文件中
mapper.writeValue(new File("e://jon.txt"),p);
//将数据关联到e://jon1.txt文件中
mapper.writeValue(new FileWriter("E://jons1.txt"),p);
}
测试结果如下：
writeValueAsString(obj)案例二：
@Test
public void Test2() throws JsonProcessingException {
//1.创建Person对象
Person p=new Person();
p.setAge(18);
p.setGender("男");
p.setName("张三");
p.setBirthday(new Date());
//2.创建Jackson核心对象 ObjectMapper
ObjectMapper mapper=new ObjectMapper();
//3.转换
//转换方法
/*mapper.writeValue(参数1,obj);
参数1:
File:将obj对象转换为JSON字符串，并保存到指定的文件中
Writer:将obj对象转换为JSON字符串，并将JSON数据填充到字符输出流中
OutputStream:将obj对象转换位JSON字符串，并将JSON数据填充到字符输出流中
writeValueAsString():将对象转换为JSON字符串
* */
String json = mapper.writeValueAsString(p);
System.out.println(json);//{"name":"张三","age":18,"gender":"男","birthday":"2020-06-10"}
}
测试结果如下：
{
"name":"张三","age":18,"gender":"男","birthday":"2021-03-07"}
集合转换案例三(List)：
@Test
public void Test3() throws JsonProcessingException {
//1.创建Person对象
Person p=new Person();
p.setAge(18);
p.setGender("男");
p.setName("张三");
p.setBirthday(new Date());
Person p2=new Person();
p2.setAge(18);
p2.setGender("男");
p2.setName("张三");
p2.setBirthday(new Date());
Person p3=new Person();
p3.setAge(18);
p3.setGender("男");
p3.setName("张三");
p3.setBirthday(new Date());
List<Person>list=new ArrayList<Person>();
list.add(p);
list.add(p2);
list.add(p3);
//2.创建Jackson核心对象 ObjectMapper
ObjectMapper mapper=new ObjectMapper();
//3.转换
//转换方法
/*mapper.writeValue(参数1,obj);
参数1:
File:将obj对象转换为JSON字符串，并保存到指定的文件中
Writer:将obj对象转换为JSON字符串，并将JSON数据填充到字符输出流中
OutputStream:将obj对象转换位JSON字符串，并将JSON数据填充到字符输出流中
writeValueAsString():将对象转换为JSON字符串
* */
String json = mapper.writeValueAsString(list);
System.out.println(json);
// [{"name":"张三","age":18,"gender":"男","birthday":"2020-06-10"},
// {"name":"张三","age":18,"gender":"男","birthday":"2020-06-10"},
// {"name":"张三","age":18,"gender":"男","birthday":"2020-06-10"}]
}
测试结果如下：
[{
"name":"张三","age":18,"gender":"男","birthday":"2021-03-07"},{
"name":"张三","age":18,"gender":"男","birthday":"2021-03-07"},{
"name":"张三","age":18,"gender":"男","birthday":"2021-03-07"}]
集合转换案例三(Map)：
@Test
public void Test4() throws JsonProcessingException {
Map<String,Object> map=new HashMap<String,Object>();
map.put("name","张三");
map.put("age",23);
map.put("gender","男");
ObjectMapper mapper=new ObjectMapper();
String s = mapper.writeValueAsString(map);
System.out.println(s);//{"gender":"男","name":"张三","age":23}
}
测试结果如下：
{
"gender":"男","name":"张三","age":23}