1. FastJSON
阿里巴巴开源框架,效率最高
1.1 maven依赖
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.4</version>
</dependency>
1.2 fastJSON的@JSONField 注解
package com.alibaba.fastjson.annotation;
public @interface JSONField {
// 配置序列化和反序列化的顺序,1.1.42版本之后才⽀持
int ordinal() default 0;
// 指定字段的名称
String name() default "";
// 指定字段的格式,对⽇期格式有⽤
String format() default "";
// 是否序列化
boolean serialize() default true;
// 是否反序列化
boolean deserialize() default true;
}
可以在属性上或者get/set方法上添加注解
1.2.1 serialize
表示 是否序列化 ,我们可以让某个字段的serialize=false,表示不将该字段转换为json字符串
public class Dep {
// 表示不将该字段转换为json字符串
@JSONField(serialize=false)
private Long uuid;
private String name;
private String tele;
}
1.2.2 ordinal
指定序列化和反序列化的顺序
public static class VO {
@JSONField(ordinal = 3)
private int f0;
@JSONField(ordinal = 2)
private int f1;
@JSONField(ordinal = 1)
private int f2;
}
1.2.3 name
指定字段的名称
@JSONField(name="ID")
private int id;
1.2.4 format
指定字段的格式
@JSONField(format="yyyyMMdd")
public Date date;
1.2.5 deserialize
是否反序列化
注意:若属性是私有的,必须有set*方法。否则无法反序列化
1.3 JSON的相关操作
String转对象
Student stu = JSON.parseObject(json,Student.class);
List<String> list=JSON.parseArray(json2, String.class);
对象转String
JSON.toJSONString(stu);
//or String json = JSON.toJSON(stu).toString();
1.4 复杂的JSON操作
1.4.1 JSON字符串是简单对象类型,被大括号包围
当待解析的JSON字符串是简单对象类型的,即用大括号包围,此时采用JSONObject对象来处理
public void test3() {
//简单对象类型
String jsonStr = "{'name':'Misaya','position':'Mid','hero':':Twisted Fate'}";
JSONObject json = JSON.parseObject(jsonStr);
String name = json.getString("name");
System.out.println(name);
System.out.println(json);
}
1.4.2 JSON字符串是数组类型,被中括号包围
当待解析的JSON字符串是简单数组类型的,即用中括号包围,此时采用JSONArray对象来处理
public void test4(){
//数组类型
String jsonStr = "['元旦','五一','国庆','春节']";
JSONArray json = JSON.parseArray(jsonStr);
String first = (String) json.get(0);
System.out.println(first);
System.out.println(json);
}
1.4.3 JSON字符串为混合类型,既有简单对象,又有数组,逐层解析
public void test5() {
//混合类型
String jsonStr = "[{'name':'元旦','vacation':'3'},{'name':'五一','vacation':'7'},{'name':'国庆','vacation':'7'}]";
JSONArray jsonArr = JSON.parseArray(jsonStr);
JSONObject jsonObj1 = jsonArr.getJSONObject(0);
System.out.println(jsonObj1);
}
1.4.4 JSON字符串有对应的类时,对象的解析
public void Json2Obj() {
//待解析的json字符串
String jsonString = "{'name':'卢本伟','age':24,'Hero':{'name':'Fizz','Position':'Mid','charactor':'killer'},'nickNames':['五五开','芦苇','white'],'Honors':[{'year':2011,'name':'TGA总决赛冠军'},{'year':2013,'name':'S3全球总决赛中国区冠军'},{'year':2013,'name':'S3全球总决赛亚军'}]}";
Player p = JSON.parseObject(jsonString, Player.class);
System.out.println(p);
}
1.5 复杂数据类型的解析——TypeReference
利用fastJSON提供的typeReference可以传入复杂的类型
例如:
public <T> T getData(TypeReference<T> typeReference){
Object obj = get("data");
String jsonStr = JSON.toJSONString(obj);
T t = JSON.parseObject(jsonStr,typeReference);
return t;
}
调用
// 这里因为TypeReference的构造器是protected,所以,需要使用内部内对象,因此加了{}
TypeReference<List<SkuHasStockTo>> typeReference = new TypeReference<List<SkuHasStockTo>>() {};
List<SkuHasStockTo> datas = skusHasStock.getData(typeReference);
注意:当要转换的是复杂的数据类型的时候,可以利用TypeReference,只需要给其指定泛型类型即可自动转换了。
2. GSON
谷歌产品
2.1 maven依赖
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.1</version>
</dependency>
2.2 String与Object互转
2.2.1 String转对象
Gson gson = new Gson();
Grade grade = gson.fromJson(json1,Grade.class);
ArrayList<String> list=gson.fromJson(json2,new TypeToken<ArrayList<String>>(){}.getType());
2.2.2 Object转String
String json=gson.toJson(grade);
3. jackSon
springMVC内置解析器就是jackson
3.1 maven依赖
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.0</version>
</dependency>
3.2 JSON操作
3.2.1 对象和String之间的转换
ObjectMapper mapper=new ObjectMapper();
Grade grade=mapper.readValue(json1, Grade.class);
mapper.writeValueAsString(grade);
3.2.2 对JsonNode的遍历
JsonNode jsonNode = mapper.readTree(jsonStr);
Iterator<String> keys = jsonNode.fieldNames();
while(keys.hasNext()){
String fieldName = keys.next();
System.out.println(fieldName + " : " + jsonNode.path(fieldName).toString());
}
3.2.3 json解析普通属性
public void getCustomProp(){
String jsonStr = "{\"price\":5000,\"count\":100,\"function\":[{\"name\":\"camera\",\"config\":1500},{\"name\":\"music\",\"config\":2000}]}";
try{
ObjectMapper objMap = new ObjectMapper();
JsonNode root = objMap.readTree(jsonStr);
//在根节点上的属性
int price = root.path("price").asInt();
int count = root.path("count").asInt();
System.out.println("price"+":"+price);
System.out.println("count"+":"+count);
//在叶子节点上的属性
JsonNode node = root.path("function");
String fun1_name = node.path(0).path("name").asText();
int fun1_config = node.path(0).path("config").asInt();
System.out.println("function1:"+fun1_name+":"+fun1_config);
String fun2_name = node.path(1).path("name").asText();
int fun2_config = node.path(1).path("config").asInt();
System.out.println("function2:"+fun2_name+":"+fun2_config);
}catch(Exception ex){
System.out.println(ex.getMessage());
}
}
3.2.4 解析对象字符串
public void json2obj(){
String jsonStr = "{\"name\":\"二狗\",\"age\":15,\"idCard\":\"42125\"}";
try{
ObjectMapper objMapper = new ObjectMapper();
//当反序列化json时,未知属性会引起的反序列化被打断,这里我们禁用未知属性打断反序列化功能
objMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
Person p = objMapper.readValue(jsonStr, Person.class);
System.out.println(p);
}catch(Exception e){
System.out.println(e.getMessage());
}
}
3.2.5 解析对象数组构成的字符串
public void jackSonTest(){
String jsonStr = "[{\"name\":\"二狗\",\"age\":15,\"idCard\":\"42125\"}, {\"name\":\"铁柱\",\"age\":12,\"idCard\":\"46521\"}]";
try{
ObjectMapper mapper = new ObjectMapper();
TreeNode treeNode = mapper.readTree(jsonStr);
List<Person> persons = mapper.readValue(jsonStr, new TypeReference<List<Person>>(){});
for (Person person : persons){
System.out.println(person);
}
}catch(Exception e){
System.out.println(e.getMessage());
}
}
4. json-lib
json-lib具有通用性,但是比较麻烦,且时间有些久远,jar包只更新到2010年
4.1 maven依赖
<dependency>
<groupId>net.sf.json-lib</groupId>
<artifactId>json-lib</artifactId>
<version>2.4</version>
<classifier>jdk15</classifier>//jar包区分jdk1.3和jdk1.5版本
</dependency>
4.2 json操作
4.2.1 String与Object互转
JSONObject jsonobject= JSONObject.fromObject(str);
String str = JSONObject.toString
4.2.2 获取JSONObject数据
String str = JSONObject.getInt("keys")
String str = JSONObject.getString("keys")
JSONArray = JSONObject.getJSONArray(String);
4.2.3 遍历JSONArray
for(i<JSONArray.size()){
JSONObject = JSONArray.getJSONObject(i);
JSONObject.getInt()...
}
Iterator<String> iterator = JSONObject.keys();
while(iterator.hasNext()){
String keys = iterator.next();
}
4.2.4 JSONObject转对象
Grade grade = (Grade)JSONObject.toBean(jsonObject,Grade.class);
5. org.json
与json-lib相类似,主要有三点区别
5.1 maven依赖
<dependency>
<groupId>org.json</groupId>
<artifactId>json</artifactId>
<version>20170516</version>
</dependency>
5.2 创建JSON
JSONObject = new JSONObject(str);
注意:
1. net.sf.json.JSONObject: 没有严格要求获取字段的类型跟getXXX()的类型一样
2. org.json.JSONObject:获取的字段类型必须跟getXXX()的类型一样
5.3 JSON操作
5.3.1 简单对象类型
待解析的字符串是简单对象类型,被大括号 { }包围时
public void test6() {
//待解析的json字符串
String jsonString = "{'name':'卢本伟','age':24,'Position':'Mid'}";
//因为json字符串是大括号包围,所以用JSONObject解析
JSONObject json = new JSONObject(jsonString);
String name = json.getString("name");
int age = json.getInt("age");
String position = json.getString("Position");
System.out.println("姓名:"+name);
System.out.println("年龄:"+age);
System.out.println("位置"+position);
}
5.3.2 数组类型
待解析的字符串是数组类型,被中括号 [ ] 包围时
public void test7() {
//待解析的json字符串
String jsonString = "['卢本伟','white','卢伟','五五开']";
//因为json字符串是大括号包围,所以用JSONArray解析
JSONArray jsonArray = new JSONArray(jsonString);
//遍历即可,foreach或for循环
for (Object name : jsonArray) {
System.out.println(name);
}
}
5.3.3 逐层解析
待解析的字符串既有中括号 [ ]、又有大括号[ ] 包围时,逐层解析
public void test5() {
//待解析的json字符串
String jsonString = "{'name':'卢本伟','age':24,'Hero':{'name':'Fizz','Position':'Mid','charactor':'killer'},'nickNames':['五五开','芦苇','white'],'Honors':[{'year':2011,'name':'TGA总决赛冠军'},{'year':2013,'name':'S3全球总决赛中国区冠军'},{'year':2013,'name':'S3全球总决赛亚军'}]}";
try {
//因为json字符串是大括号包围,所以用JSONObject解析
JSONObject json = new JSONObject(jsonString);
/*
* 普通元素,根据类型直接获取
*/
String name = json.getString("name");
int age = json.getInt("age");
System.out.println("姓名:"+name);
System.out.println("年龄:"+age);
System.out.println("————————————————————————————————");
/*
* 属性大括号包括,先获取JSONObject对象
*/
JSONObject hero = json.getJSONObject("Hero");
String hero_name = hero.getString("name");
String hero_position = hero.getString("Position");
String hero_charactor = hero.getString("charactor");
System.out.println("擅长英雄:");
System.out.println("英雄名:"+hero_name);
System.out.println("位置:"+hero_position);
System.out.println("英雄定位:"+hero_charactor);
System.out.println("————————————————————————————————");
/*
* 属性被中括号包括,获取JSONArray对象,遍历即可
*/
System.out.println("外号:");
JSONArray nickNames = json.getJSONArray("nickNames");
for (Object nickName : nickNames) {
System.out.println(nickName);
}
System.out.println("————————————————————————————————");
/*
* 属性中既有中括号包括,又嵌套了大括号,一层层获取即可
*/
JSONArray Honors = json.getJSONArray("Honors");
System.out.println("所获荣誉:");
for(int i=0;i<Honors.length();i++){
JSONObject honor = Honors.getJSONObject(i);
int honor_year = honor.getInt("year");
String honor_name = honor.getString("name");
System.out.println(honor_year+" : "+ honor_name);
}
}catch(Exception e){
System.out.println(e.getMessage());
}
}