阅读完需:约 13 分钟
我们在日常开发中少不了和JSON
数据打交道,下面总结了用到的框架来解析JSON
数据:
作为SpringBoot 技术栈 开发的话, 用默认的Jackson是最好的
1、JSON
官方
2、GSON
3、FastJSON
4、jackson
JSON操作涉及到的类
public class Student {
private int id;
private String name;
private int age;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Student(int id, String name, int age) {
super();
this.id = id;
this.name = name;
this.age = age;
}
public Student() {
super();
}
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
}
}
public class Grade {
private int id;
private String name;
private ArrayList<Student> stus;
public Grade(int id, String name, ArrayList<Student> stus) {
super();
this.id = id;
this.name = name;
this.stus = stus;
}
public Grade() {
super();
}
@Override
public String toString() {
return "Grade [id=" + id + ", name=" + name + ", stus=" + stus + "]";
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public ArrayList<Student> getStus() {
return stus;
}
public void setStus(ArrayList<Student> stus) {
this.stus = stus;
}
}
JSON官方的解析最具有通用性
public class JSONTest {
//解析JSON
@Test
public void test1() throws JSONException{
//对象嵌套数组嵌套对象
String json1="{'id':1,'name':'JAVAEE-1703','stus':[{'id':101,'name':'刘一','age':16}]}";
//数组
String json2="['北京','天津','杭州']";
//1、
//解析第一层---对象
JSONObject jObject1=new JSONObject(json1);
Grade grade=new Grade();
grade.setId(jObject1.getInt("id"));
grade.setName(jObject1.getString("name"));
ArrayList<Student> stus=new ArrayList<>();
grade.setStus(stus);
//解析第二层----数组
JSONArray jsonArray2=jObject1.getJSONArray("stus");
//遍历数组获取元素----对象
for(int i=0;i<jsonArray2.length();i++){
//解析第三层----对象
JSONObject jObject3=jsonArray2.getJSONObject(i);
Student student=new Student(jObject3.getInt("id"), jObject3.getString("name"), jObject3.getInt("age"));
grade.getStus().add(student);
}
System.out.println(grade);
//获取当前对象的所有属性的迭代器对象
// Iterator<String> iterator=jObject1.keys();
// while (iterator.hasNext()) {
// String key = iterator.next();
// System.out.println("属性:"+key);
// }
//2、
//获取数组对象
JSONArray jArray=new JSONArray(json2);
ArrayList<String> list=new ArrayList<>();
//遍历获取元素
for(int i=0;i<jArray.length();i++){
//jArray.optString(i);//等价于getXXX
list.add(jArray.getString(i));
}
System.out.println("解析结果:"+list);
}
//生成JSON
@Test
public void test2() throws JSONException{
JSONObject jo1=new JSONObject();
jo1.put("id", 1001);
jo1.put("name", "范老");
jo1.put("age", 20);
JSONObject jo2=new JSONObject();
jo2.put("id", 1002);
jo2.put("name", "平平");
jo2.put("age", 19);
JSONArray ja2=new JSONArray();
ja2.put(jo1);
ja2.put(jo2);
JSONObject jo3=new JSONObject();
jo3.put("id", 11);
jo3.put("name", "JAVAEE-1704");
jo3.put("stus",ja2);
String json=jo3.toString();
System.out.println(json);
}
}
Gson
Google提供的用来java对象和JSON数据之间进行映射的JAVA类库,可以将一个JSON字符转成一个java对象,反过来也OK。
public class GSONTest {
//解析
@Test
public void test1() {
// 对象嵌套数组嵌套对象
String json1 = "{'id':1,'name':'JAVAEE-1703','stus':[{'id':101,'name':'刘一','age':16}]}";
// 数组
String json2 = "['北京','天津','杭州']";
Gson gson=new Gson();
//1、
//解析对象:第一个参数:待解析的字符串 第二个参数结果数据类型的Class对象
Grade grade=gson.fromJson(json1, Grade.class);
System.out.println(grade);
//2、
//解析数组要求使用Type
ArrayList<String> list=gson.fromJson(json2,
new TypeToken<ArrayList<String>>(){}.getType());
System.out.println(list);
}
//生成
@Test
public void test2(){
ArrayList<Student> list=new ArrayList<>();
for(int i=1;i<3;i++){
list.add(new Student(101+i, "码子", 20+i));
}
Grade grade=new Grade(100001,"张三", list);
Gson gson=new Gson();
//将对象转换为诶JSON格式字符串
String json=gson.toJson(grade);
System.out.println(json);
}
}
FastJSON
阿里巴巴的产品,效率最高
Fastjson支持java bean的直接序列化,同时也支持集合、Map、日期、Enum和泛型等的序列化。你可以使用com.alibaba.fastjson.JSON这个类进行序列化和反序列化,常用的序列化操作都可以在JSON类上的静态方法直接完成。Fastjson采用独创的算法,将parse的速度提升到极致,号称超过所有Json库。而且,使用Fastjson解析时,除了需要使用Fastjson所提供的jar包外,再不需要额外的jar包,就能够直接跑在JDK上。
解析原理:
基于事件驱动,与GSON相同,先创建一个对应于JSON数据的JavaBean类就可以通过简单的操作解析出所需JSON数据。但和Gson解析不同的是,GSON可按需解析,即创建的JavaBean类不一定完全涵盖所要解析的JSON数据,按需创建属性,但Jackson解析对应的JavaBean必须把Json数据里面的所有key都有所对应,即必须把JSON内的数据所有解析出来,无法按需解析。但Jackson的解析速度和效率都要比GSON高
public class FASTJson {
//解析
@Test
public void test1() {
// 对象嵌套数组嵌套对象
String json1 = "{'id':1,'name':'JAVAEE-1703','stus':[{'id':101,'name':'刘铭','age':16}]}";
// 数组
String json2 = "['北京','天津','杭州']";
//1、
//静态方法
Grade grade=JSON.parseObject(json1, Grade.class);
System.out.println(grade);
//2、
List<String> list=JSON.parseArray(json2, String.class);
System.out.println(list);
}
//生成
@Test
public void test2(){
ArrayList<Student> list=new ArrayList<>();
for(int i=1;i<3;i++){
list.add(new Student(101+i, "码子", 20+i));
}
Grade grade=new Grade(100001,"张三", list);
String json=JSON.toJSONString(grade);
System.out.println(json);
}
}
FASTJSON常用方法:
public static final Object parse(String text); // 把JSON文本parse为JSONObject或者JSONArray
public static final JSONObject parseObject(String text); // 把JSON文本parse成JSONObject
public static final T parseObject(String text, Class clazz); // 把JSON文本parse为JavaBean
public static final JSONArray parseArray(String text); // 把JSON文本parse成JSONArray
public static final List parseArray(String text, Class clazz); //把JSON文本parse成JavaBean集合
public static final String toJSONString(Object object); // 将JavaBean序列化为JSON文本
public static final String toJSONString(Object object, boolean prettyFormat); // 将JavaBean序列化为带格式的JSON文本
public static final Object toJSON(Object javaObject); //将JavaBean转换为JSONObject或者JSONArray。
一:解析json字符串并获取数据
1.把json字符串转换为实体类
1.1、直接解析为对象(支持深度解析)
T t = JSON.parseObject(jsonstr, T.class); // 解析{...}为对象
List<t> list = JSON.parseArray(jsonstr, T.class); // 解析[{},{}...]为集合
1.2、解析为JSON对象
1.2.1、如果不知道json字符串具体是JSONObject还是JSONArray可以使用
Object obj = JSON.parse(jsonstr); // obj可能为String、JSONArray、JSONObject
1.2.2、如果确定字符串为JSONObject类型
JSONObject parseObject = JSON.parseObject(jsonstr);
1.2.3、如果确定字符串为JSONArray类型
JSONArray jsonarry = JSON.parseArray(jsonstr);
2.获取JSONArray对象中的数据
2.1、获取JSONArray中的单个元素作为JSONObject
JSONObject jsonobject = JSONArray.get(i);
2.2、获取JSONArray中的单个元素作为解析后的实体类(直接封装为实体类)
T t = JSONArray.getObject(i, T.class);
2.3、遍历JSONArray
JSONArray jsonarray = JSON.parseArray(jsonstr);
for(int i=0;i<jsonarray.size();i++){
JSONObject jsonobject = JSONArray.get(i);
T t = JSONArray.getObject(i, T.class);
}
3.获取JSONObject对象中的数据
3.1、获取JSONObject中的数据
Byte byte1 = parseObject.getByte(key);
byte byteValue = parseObject.getByteValue(key);
Short short1 = parseObject.getShort(key);
short shortValue = parseObject.getShortValue(key);
Integer integer = parseObject.getInteger(key);
int intValue = parseObject.getIntValue(key);
Long long1 = parseObject.getLong(key);
long longValue = parseObject.getLongValue(key);
Float float1 = parseObject.getFloat(key);
float floatValue = parseObject.getFloatValue(key);
Double double1 = parseObject.getDouble(key);
double doubleValue = parseObject.getDoubleValue(key);
// 以下四个最常用..
String string = parseObject.getString(key);
JSONArray jsonArray = parseObject.getJSONArray(key);
JSONObject jsonObject = parseObject.getJSONObject(key);
Object object = parseObject.get(key); // object类型为JSONArray或JSONObject或String
3.2、遍历JSONObject
Set<String> keySet = JSONObject.keySet();
for(String key : keySet){
Object value = keySet.get(key); // value类型为JSONArray或JSONObject或String
}
二、格式化对象为json字符串
1.默认对象转为json字符串的方法
JSON.toJSONString(Object);
2.上诉方法可以把对象转为JSON格式的字符串,但是存在部分缺陷.推荐使用以下转换方式 SerializerFeature
Fastjson的SerializerFeature序列化属性
QuoteFieldNames———-输出key时是否使用双引号,默认为true
WriteMapNullValue——–是否输出值为null的字段,默认为false
WriteNullNumberAsZero—-数值字段如果为null,输出为0,而非null
WriteNullListAsEmpty—–List字段如果为null,输出为[],而非null
WriteNullStringAsEmpty—字符类型字段如果为null,输出为”“,而非null
WriteNullBooleanAsFalse–Boolean字段如果为null,输出为false,而非null
例如:JSON.toJSONString(resultMap, SerializerFeature.WriteMapNullValue);
日期格式化
public void test5(){
Date date=new Date();
//输出毫秒值
System.out.println(JSON.toJSONString(date));
//默认格式为yyyy-MM-dd HH:mm:ss
System.out.println(JSON.toJSONString(date, SerializerFeature.WriteDateUseDateFormat));
//根据自定义格式输出日期
System.out.println(JSON.toJSONStringWithDateFormat(date, "yyyy-MM-dd", SerializerFeature.WriteDateUseDateFormat));
}
JSON类中的方法也讲解的差不多了,下面给出Java实例来实现以上的各种转换
package jsonTest;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
public class MyJson {
public static void main(String[] args) {
List<Student> list=new ArrayList<>();
Student student=new Student("bob",24);
Student student12=new Student("lily", 23);
list.add(student);
list.add(student12);
System.out.println("*******javaBean to jsonString*******");
String str1=JSON.toJSONString(student);
System.out.println(str1);
System.out.println(JSON.toJSONString(list));
System.out.println();
System.out.println("******jsonString to javaBean*******");
//Student stu1=JSON.parseObject(str1,new TypeReference<Student>(){});
Student stu1=JSON.parseObject(str1,Student.class);
System.out.println(stu1);
System.out.println();
System.out.println("******javaBean to jsonObject******");
JSONObject jsonObject1=(JSONObject)JSON.toJSON(student);
System.out.println(jsonObject1.getString("name"));
System.out.println();
System.out.println("******jsonObject to javaBean******");
Student student2=JSON.toJavaObject(jsonObject1, Student.class);
System.out.println(student2);
System.out.println();
System.out.println("*******javaBean to jsonArray******");
List<Student> stulist=new ArrayList<>();
for(int i=0;i<5;i++){
stulist.add(new Student("student"+i, i));
}
JSONArray jsonArrays=(JSONArray)JSON.toJSON(stulist);
for(int i=0;i<jsonArrays.size();i++){
System.out.println(jsonArrays.getJSONObject(i));
}
System.out.println();
System.out.println("*****jsonArry to javalist******");
List<Student> myList=new ArrayList<>();
for(int i=0;i<jsonArrays.size();i++){
Student student3=JSON.toJavaObject(jsonArrays.getJSONObject(i), Student.class);
myList.add(student3);
}
for(Student stu:myList){
System.out.println(stu);
}
System.out.println();
System.out.println("*****jsonObject to jsonString*****");
String str4=JSON.toJSONString(jsonObject1);
System.out.println(str4);
System.out.println();
System.out.println("*******jsonString to jsonObject*****");
JSONObject jso1=JSON.parseObject(str1);
System.out.println(jso1.getString("name"));
System.out.println();
System.out.println("*****jsonString to jsonArray*****");
JSONArray jArray=JSON.parseArray(JSON.toJSONString(stulist));
for(int i=0;i<jArray.size();i++){
System.out.println(jArray.getJSONObject(i));
}
System.out.println();
}
}
对应的javabean类 :
package jsonTest;
public class Student {
private String name;
private int age;
public Student() {
// TODO Auto-generated constructor stub
}
public Student(String name,int age){
this.name=name;
this.age=age;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return "student [name="+name+" , "+"age="+age+"]";
}
}
Jackson
jackSon解析JSON,SpringMVC内置的解析器就是这个
public class JackSonTest {
//解析
@Test
public void test1() throws Exception{
// 对象嵌套数组嵌套对象
String json1 = "{\"id\":1,\"name\":\"JAVAEE-1703\",\"stus\":[{\"id\":101,\"name\":\"刘一\",\"age\":16}]}";
// 数组
String json2 = "[\"北京\",\"天津\",\"杭州\"]";
//1、
ObjectMapper mapper=new ObjectMapper();
Grade grade=mapper.readValue(json1, Grade.class);
System.out.println(grade);
//2、
ArrayList<String> list=mapper.readValue(json2,
new TypeReference<ArrayList<String>>() {
});
System.out.println(list);
}
//生成
@Test
public void test2() throws JsonProcessingException{
ArrayList<Student> list=new ArrayList<>();
for(int i=1;i<3;i++){
list.add(new Student(101+i, "码子", 20+i));
}
Grade grade=new Grade(100001,"张三", list);
ObjectMapper mapper=new ObjectMapper();
//将对象转换为JSON格式字符串
String json=mapper.writeValueAsString(grade);
System.out.println(json);
}
}
Jackson objectMapper.readValue
方法
public class TestMain2 {
public static void main(String[] args) throws JsonProcessingException {
/*
首先说明 readValue 针对String 一共有3个重载,如下:
public <T> T readValue(String content, Class<T> valueType);简单型,就是 直接 UserBase.class 就可。
public <T> T readValue(String content, TypeReference<T> valueTypeRef);复杂的可以 用这个
public <T> T readValue(String content, JavaType valueType);这个书写起来比较麻烦,就不说明了,不常用,前2个已经彻底满足了。
*/
ObjectMapper objectMapper = new ObjectMapper();
String json1 = "{\"userName\":\"小李飞刀\",\"age\":18,\"addTime\":1591851786568}";
String json2 = "[{\"userName\":\"小李飞刀\",\"age\":18,\"addTime\":123}, {\"userName\":\"小李飞刀2\",\"age\":182,\"addTime\":1234}]";
//1.最简单的常用方法,直接将一个json转换成实体类
UserBase userBase1 = objectMapper.readValue(json1, UserBase.class); //简单类型的时候,这样最方便
System.out.println("简单: " + userBase1.getUserName());
//用 TypeReference 也可以,但是麻烦 不如第一种直接 TypeReference 主要针对繁杂类型
//UserBase userBase2 = objectMapper.readValue(json1, new TypeReference<UserBase>() {});
//2.把Json转换成map,必须使用 TypeReference , map的类型定义 可以根据实际情况来定,比如若值都是String那么就可以 Map<String, String>
Map<String, Object> userBaseMap = objectMapper.readValue(json1, new TypeReference<Map<String, Object>>() {});
System.out.println("map: " + userBaseMap.get("userName"));
//3.list<Bean>模式,必须用 TypeReference
List<UserBase> userBaseList = objectMapper.readValue(json2, new TypeReference<List<UserBase>>() {});
System.out.println("list: " + userBaseList.get(0).getUserName());
//4.Bean[] 数组,必须用 TypeReference
UserBase[] userBaseAry = objectMapper.readValue(json2, new TypeReference<UserBase[]>() {});
System.out.println("ary: " + userBaseAry[0].getUserName());
}
}