JSON格式及FastJson使用详解

最新推荐文章于 2024-07-26 12:11:18 发布

cjy8866

最新推荐文章于 2024-07-26 12:11:18 发布

阅读量1.7k

点赞数 1

文章标签： json 前端 java

原文链接：https://juejin.cn/post/6844904176003072007

版权

一
1.1 json对象
{“ID”: 1001,“name”: “张三”,“age”: 24}

这个数据就是一个Json对象，Json对象的特点如下：
1数据在花括号中
2数据以"键：值"对的形式出现（其中键多以字符串形式出现，值可取字符串，数值，甚至其他json对象）
3每两个"键：值"对以逗号分隔（最后一个"键：值"对省略逗号）

1.2 json对象数组
[
{“ID”: 1001, “name”: “张三”, “age”: 24},
{“ID”: 1002, “name”: “李四”, “age”: 25},
{“ID”: 1003, “name”: “王五”, “age”: 22}
]
这个数据就是一个Json对象数组，Json对象数组的特点如下：

数据在方括号中（可理解为数组）方括号中每个数据以json对象形式出现每两个数据以逗号分隔（最后一个无需逗号）

1.3 json字符串
“{“ID”: 1001,“name”: “张三”,“age”: 24}”

它必须是一个字符串，支持字符串的各种操作里面的数据格式应该要满足其中一个格式，可以是json对象，也可以是json对象数组或者是两种基本形式的组合变形。

二 Fastjson简介
在fastjson包中主要有3个类，JSON,JSONArray，JSONObject
三者之间的关系如下，JSONObject和JSONArray继承JSON
在这里插入图片描述
联系上面讲到的json基础知识并对应这三个类，可以发现，JSONObject代表json对象，JSONArray代表json对象数组，JSON代表JSONObject和JSONArray的转化。

JSON案列:
3.1 json字符串—》JSONObject
用JSON.parseObject()方法即可将JSon字符串转化为JSON对象，利用JSONObject中的get()方法来获取JSONObject中的相对应的键对应的值

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.jiyong.config.Student;
import com.jiyong.config.Teacher;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**

Fastjson用法
*/

public class FastJsonOper {
//json字符串-简单对象型,加\转义
private static final String JSON_OBJ_STR = “{“studentName”:“lily”,“studentAge”:12}”;
//json字符串-数组类型
private static final String JSON_ARRAY_STR = " [{“studentName”:“lily”,“studentAge”:12}," +
“{“studentName”:“lucy”,“studentAge”:15}]”;
//复杂格式json字符串
private static final String COMPLEX_JSON_STR = “{“teacherName”:“crystall”,” +
““teacherAge”:27,“course”:{“courseName”:“english”,“code”:1270},“students”:[{“studentName”:“lily”,“studentAge”:12},{“studentName”:“lucy”,“studentAge”:15}]}”;
// json字符串与JSONObject之间的转换
@Test
public void JsonStrToJSONObject(){

    JSONObject jsonObject = JSON.parseObject(JSON_OBJ_STR);
    System.out.println("StudentName: " + jsonObject.getString("studentName") + "," + "StudentAge: " + jsonObject.getInteger("studentAge"));
}

}

3.2 JSONObject—》json字符串
用JSON.toJSONString()方法即可将JSON对象转化为JSON字符串
/**
* 将JSONObject转换为JSON字符串,用JSON.toJSONString()方法即可将JSON字符串转化为JSON对象
*/
@Test
public void JSONObjectToJSONString(){
JSONObject jsonObject = JSON.parseObject(JSON_OBJ_STR);
String s = JSON.toJSONString(jsonObject);
System.out.println(s);
}

3.3 JSON字符串数组—》JSONArray
将JSON字符串数组转化为JSONArray，通过JSON的parseArray()方法。JSONArray本质上还是一个数组，对其进行遍历取得其中的JSONObject，然后再利用JSONObject的get()方法取得其中的值。有两种方式进行遍历

方式一：通过jsonArray.size()获取JSONArray中元素的个数，再通过getJSONObject(index)获取相应位置的JSONObject，循环变量取得JSONArray中的JSONObject,再利用JSONObject的get()进行取值。方式二：通过jsonArray.iterator()获取迭代器

/**
* 将JSON字符串数组转化为JSONArray，通过JSON的parseArray()方法
/
@Test
public void JSONArrayToJSONStr(){
JSONArray jsonArray = JSON.parseArray(JSON_ARRAY_STR);
/*
* JSONArray本质上还是一个数组，对其进行遍历取得其中的JSONObject，然后再利用JSONObject的get()方法取得其中的值
* 方式一是通过jsonArray.size()获取JSONArray中元素的个数，
* 再通过getJSONObject(index)获取相应位置的JSONObject，在利用JSONObject的get()进行取值
* 方式二是通过jsonArray.iterator()获取迭代器
*
*/
// 遍历方式一
// int size = jsonArray.size();
// for(int i = 0;i < size;i++){
// JSONObject jsonObject = jsonArray.getJSONObject(i);
// System.out.println("studentName: " + jsonObject.getString(“studentName”) + ",StudentAge: " + jsonObject.getInteger(“studentAge”));
// }
// 遍历方式二
Iterator iterator = jsonArray.iterator();
while (iterator.hasNext()){
JSONObject jsonObject = (JSONObject) iterator.next();
System.out.println("studentName: " + jsonObject.getString(“studentName”) + ",StudentAge: " + jsonObject.getInteger(“studentAge”));
}
}

3.4 JSONArray—》json字符串
用JSON.toJSONString()方法即可将JSONArray转化为JSON字符串
/**
* JSONArray到json字符串-数组类型的转换
*/
@Test
public void JSONArrayToJSONString(){
JSONArray jsonArray = JSON.parseArray(JSON_ARRAY_STR);
String s = JSON.toJSONString(jsonArray);
System.out.println(s);
}

3.5 复杂JSON格式字符串—》JSONObject
将复杂JSON格式字符串转换为JSONObject,也是通过JSON.parseObject()
/**
* 将复杂JSON格式字符串转换为JSONObject,也是通过JSON.parseObject()，可以取其中的部分
*/
@Test
public void JSONStringTOJSONObject(){
JSONObject jsonObject = JSON.parseObject(COMPLEX_JSON_STR);
// 获取简单对象
String teacherName = jsonObject.getString(“teacherName”);
Integer teacherAge = jsonObject.getInteger(“teacherAge”);
System.out.println("teacherName: " + teacherName + ",teacherAge " + teacherAge);
// 获取JSONObject对象
JSONObject course = jsonObject.getJSONObject(“course”);
// 获取JSONObject中的数据
String courseName = course.getString(“courseName”);
Integer code = course.getInteger(“code”);
System.out.println("courseName: " + courseName + " code: " + code);
// 获取JSONArray对象
JSONArray students = jsonObject.getJSONArray(“students”);
// 获取JSONArray的中的数据
Iterator iterator = students.iterator();
while (iterator.hasNext()){
JSONObject jsonObject1 = (JSONObject) iterator.next();
System.out.println("studentName: " + jsonObject1.getString(“studentName”) + ",StudentAge: "
+ jsonObject1.getInteger(“studentAge”));
}
}

3.6 复杂JSONObject—》json字符串
用JSON.toJSONString()方法即可将复杂JSONObject转化为JSON字符串
/**
* 复杂JSONObject到json字符串的转换
*/
@Test
public void JSONObjectTOJSON(){
JSONObject jsonObject = JSON.parseObject(COMPLEX_JSON_STR);
String s = JSON.toJSONString(jsonObject);
System.out.println(s);
}

3.7 json字符串—》JavaBean
定义JavaBean类
package com.fastjson;
public class Student {
private String studentName;
private int studentAge;
public Student() {
}

public Student(String studentName, int studentAge) {
    this.studentName = studentName;
    this.studentAge = studentAge;
}

public String getStudentName() {
    return studentName;
}

public void setStudentName(String studentName) {
    this.studentName = studentName;
}

public int getStudentAge() {
    return studentAge;
}

public void setStudentAge(int studentAge) {
    this.studentAge = studentAge;
}

@Override
public String toString() {
    return "Student{" +
            "studentName='" + studentName + '\'' +
            ", studentAge=" + studentAge +
            '}';
}

}

package com.jiyong.config;

/**

对于复杂嵌套的JSON格式，利用JavaBean进行转换的时候要注意
1、有几个JSONObject就定义几个JavaBean
2、内层的JSONObject对应的JavaBean作为外层JSONObject对应的JavaBean的一个属性
3、解析方法有两种
第一种方式,使用TypeReference类
Teacher teacher = JSONObject.parseObject(COMPLEX_JSON_STR, new TypeReference() {})
第二种方式,使用Gson思想
Teacher teacher = JSONObject.parseObject(COMPLEX_JSON_STR, Teacher.class);
*/

import java.util.List;

public class Teacher {
private String teacherName;
private int teacherAge;
private Course course;
private List students;

public Teacher() {
}

public Teacher(String teacherName, int teacherAge, Course course, List<Student> students) {
    this.teacherName = teacherName;
    this.teacherAge = teacherAge;
    this.course = course;
    this.students = students;
}

public String getTeacherName() {
    return teacherName;
}

public void setTeacherName(String teacherName) {
    this.teacherName = teacherName;
}

public int getTeacherAge() {
    return teacherAge;
}

public void setTeacherAge(int teacherAge) {
    this.teacherAge = teacherAge;
}

public Course getCourse() {
    return course;
}

public void setCourse(Course course) {
    this.course = course;
}

public List<Student> getStudents() {
    return students;
}

public void setStudents(List<Student> students) {
    this.students = students;
}

@Override
public String toString() {
    return "Teacher{" +
            "teacherName='" + teacherName + '\'' +
            ", teacherAge=" + teacherAge +
            ", course=" + course +
            ", students=" + students +
            '}';
}

}

package com.jiyong.config;

public class Course {
private String courseName;
private int code;

public Course() {
}

public Course(String courseName, int code) {
    this.courseName = courseName;
    this.code = code;
}

public String getCourseName() {
    return courseName;
}

public void setCourseName(String courseName) {
    this.courseName = courseName;
}

public int getCode() {
    return code;
}

public void setCode(int code) {
    this.code = code;
}

@Override
public String toString() {
    return "Course{" +
            "courseName='" + courseName + '\'' +
            ", code=" + code +
            '}';
}

}

Jason字符串转换为JavaBean有三种方式，推荐通过反射的方式。
/**
* json字符串-简单对象到JavaBean之间的转换
* 1、定义JavaBean对象
* 2、Jason字符串转换为JavaBean有三种方式，推荐通过反射的方式
*/
@Test
public void JSONStringToJavaBeanObj(){
// 第一种方式
JSONObject jsonObject = JSON.parseObject(JSON_OBJ_STR);
String studentName = jsonObject.getString(“studentName”);
Integer studentAge = jsonObject.getInteger(“studentAge”);
Student student = new Student(studentName, studentAge);
//第二种方式,使用TypeReference类,由于其构造方法使用protected进行修饰,故创建其子类
Student student1 = JSON.parseObject(JSON_OBJ_STR, new TypeReference() {});
// 第三种方式，通过反射，建议这种方式
Student student2 = JSON.parseObject(JSON_OBJ_STR, Student.class);

3.8 JavaBean —》json字符串
也是通过JSON的toJSONString，不管是JSONObject、JSONArray还是JavaBean转为为JSON字符串都是通过JSON的toJSONString方法。
/**
* JavaBean转换为Json字符串,也是通过JSON的toJSONString，不管是JSONObject、JSONArray还是JavaBean转为为JSON字符串都是通过JSON的toJSONString方法
*/
@Test
public void JavaBeanToJsonString(){
Student lily = new Student(“lily”, 12);
String s = JSON.toJSONString(lily);
System.out.println(s);
}

3.8 json字符串数组—》JavaBean-List
/**
* json字符串-数组类型到JavaBean_List的转换
*/
@Test
public void JSONStrToJavaBeanList(){
// 方式一：
JSONArray jsonArray = JSON.parseArray(JSON_ARRAY_STR);
//遍历JSONArray
List students = new ArrayList();
Iterator iterator = jsonArray.iterator();
while (iterator.hasNext()){
JSONObject next = (JSONObject) iterator.next();
String studentName = next.getString(“studentName”);
Integer studentAge = next.getInteger(“studentAge”);
Student student = new Student(studentName, studentAge);
students.add(student);
}
// 方式二,使用TypeReference类,由于其构造方法使用protected进行修饰,故创建其子类
List studentList = JSON.parseObject(JSON_ARRAY_STR,new TypeReference<ArrayList>() {});
// 方式三，使用反射
List students1 = JSON.parseArray(JSON_ARRAY_STR, Student.class);
System.out.println(students1);

3.10 JavaBean-List —》json字符串数组
/**

 * JavaBean_List到json字符串-数组类型的转换,直接调用JSON.toJSONString()方法即可

 */

@Test

public void JavaBeanListToJSONStr(){

    Student student = new Student("lily", 12);

    Student student1 = new Student("lucy", 13);

    List<Student> students = new ArrayList<Student>();

    students.add(student);

    students.add(student1);

    String s = JSON.toJSONString(student);

    System.out.println(s);

}

3.11 复杂嵌套json格式字符串—》JavaBean_obj
对于复杂嵌套的JSON格式，利用JavaBean进行转换的时候要注意：

有几个JSONObject就定义几个JavaBean内层的JSONObject对应的JavaBean作为外层JSONObject对应的JavaBean的一个属性
/**

复杂json格式字符串到JavaBean_obj的转换
*/
@Test
public void ComplexJsonStrToJavaBean(){
//第一种方式,使用TypeReference类,由于其构造方法使用protected进行修饰,故创建其子类
Teacher teacher = JSON.parseObject(COMPLEX_JSON_STR, new TypeReference() {});
// 第二种方式，使用反射
Teacher teacher1 = JSON.parseObject(COMPLEX_JSON_STR, Teacher.class);
}

3.12 JavaBean_obj —》复杂json格式字符串
/**

复杂JavaBean_obj到json格式字符串的转换
*/
@Test
public void JavaBeanToComplexJSONStr(){
Teacher teacher = JSON.parseObject(COMPLEX_JSON_STR, Teacher.class);
String s = JSON.toJSONString(teacher);
System.out.println(s);
}