JSON小记

1什么是JSON

JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式。它采用完全独立于编程语言的文本格式来存储和表示数据。简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。 易于阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。

Js中任何支持的类型都可以通过 JSON 来表示，例如字符串、数字、对象、数组等。其中：

1）对象表示为键值对
2）数据由逗号分隔
3）花括号{}保存对象
4）方括号[]保存数组

注意：JSON 是 JS 对象的字符串表示法，它使用文本表示一个 JS 对象的信息，本质是一个字符串。

一些常见的处理json的第三方类库主要有：fastjson/jackson/gson/json-lib等

2 fastjson

Fastjson是alibaba提供的第三方组件，用来处理json格式数据

本例导入jar包：fastjson-1.2.2.jar

测试代码如下：

ArrayList<Student> list=new ArrayList<>();
for(int i=1;i<3;i++){
    list.add(new Student(101+i, "hoho", 20+i));
}
//对象转为json格式字符串
String json = JSON.toJSONString(list);
System.out.println(json);

Student s = new Student(1, "haha", 3);
String json2 = JSON.toJSONString(s);
System.out.println(json2);

String json3 = "{\"name\":\"张三\",\"age\":24}";
//json格式字符串转为对象
UserInfo userInfo=JSON.parseObject(json3, UserInfo.class);
System.out.println("name:" + userInfo.getName()+ ", age:"+userInfo.getAge());

String json6="[{\"name\":\"zhangsan\",\"age\":25}]";
// 转为数组
List<UserInfo> ll2 = JSON.parseArray(json6, UserInfo.class);
System.out.println(ll2.get(0).getName());

String json4="{\"name\":\"zhangsan\",\"age\":25}";
Map<String, Object> map = JSON.parseObject(json4, new TypeReference<Map<String, Object>>(){});
System.out.println(map.get("name"));

String json5="[{\"name\":\"zhangsan\",\"age\":25}]";
List<UserInfo> ll = JSON.parseObject(json5, new TypeReference<List<UserInfo>>(){});
System.out.println(ll.get(0).getName());


Person p = new Person();
p.setId(1);
p.setName("haha");
p.setDate(new Date());

// 日期处理
// 时间戳
String info = JSON.toJSONString(p);
System.out.println(info);

//默认格式为yyyy-MM-dd HH:mm:ss
String info2 = JSON.toJSONString(p, SerializerFeature.WriteDateUseDateFormat);
System.out.println(info2);

// 根据自定义格式输出日期 
System.out.println(JSON.toJSONStringWithDateFormat(p, "yyyy-MM-dd", SerializerFeature.WriteDateUseDateFormat));

3 jackson

jackson是Spring MVC默认使用的json解析器

ArrayList<Student> list=new ArrayList<>();
for(int i=1;i<3;i++){
    list.add(new Student(101+i, "码子", 20+i));
}
//ObjectMapper对象，用于序列化和反序列化
ObjectMapper mapper=new ObjectMapper();
String json = null;
try {
    //将对象转换为JSON格式字符串
    json = mapper.writeValueAsString(list);
} catch (JsonProcessingException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}
System.out.println(json);

Student s = new Student(1, "haha", 3);
String json2 = null;
try {
    json2 = mapper.writeValueAsString(s);
} catch (JsonProcessingException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}
System.out.println(json2);

String json3 = "{\"name\":\"张三\",\"age\":24}";
//json格式字符串转为对象
UserInfo userInfo = null;
try {
    userInfo = mapper.readValue(json3, UserInfo.class);
} catch (Exception e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
} 
System.out.println("name:" + userInfo.getName()+ ", age:"+userInfo.getAge());

String json6="[{\"name\":\"zhangsan\",\"age\":25}]";
// 转为数组
List<UserInfo> ll2 = null;
try {
    ll2 = mapper.readValue(json6, new TypeReference<List<UserInfo>>() {
    });
} catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}
System.out.println(ll2.get(0).getName());

Person p = new Person();
p.setId(1);
p.setName("haha");
p.setDate(new Date());

// 设置日期格式
mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
// 不设置格式，时间戳
String info = mapper.writeValueAsString(p);
System.out.println(info);

4、Java

下面是JSON和Java对象等的转换方法。准备工作，创建Emp实体类：

public class Emp implements Serializable {
    private String name;
    private Integer age;
    
    public Emp() {
    	
    }
    public Emp(String name, Integer age) {
        super();
        this.name = name;
        this.age = age;
    }
    //get,set略
}

java对象→json字符串

@Test
public void test1() {
    //1.获取Java对象
    Emp e = new Emp("mrbird",24);
    //2.先将其转换成json对象(Map)
    JSONObject obj = JSONObject.fromObject(e);
    //3.在将json对象转成字符串
    System.out.println(obj.toString());
}

输出：

{"age":24,"name":"mrbird"}

集合/数组→json字符串

@Test
public void test2() {
    //1.获取集合/数组
    List<Emp> list = new ArrayList<Emp>();
    list.add(new Emp("mrbird",24));
    list.add(new Emp("leanote",33));
    //2.先把集合转成json数组(List)
    JSONArray ary = JSONArray.fromObject(list);
    //3.把整个数组转成字符串
    System.out.println(ary.toString());
}

输出：

[{"age":24,"name":"mrbird"},{"age":33,"name":"leanote"}]

json字符串→java对象

@Test
public void test3() {
    //1.获取json字符串
    String str = "{\"name\":\"mrbird\",\"age\":24}";
    //2.将此字符串转成json对象(Map)
    JSONObject obj = JSONObject.fromObject(str);
    //3.将json对象转换成Java对象(bean)
    Emp e = (Emp)JSONObject.toBean(obj, Emp.class);
    System.out.println(e.getName());
}

输出：

mrbird

json字符串转→List

@Test
public void test4() {
    //1.获取json字符串
    String str = 
    	"[{\"name\":\"mrbird\",\"age\":24}," +
    	"{\"name\":\"leanote\",\"age\":33}]";
    //2.先将此字符串转成json数组(List)
    //当前List中存的是Map。
    JSONArray ary = JSONArray.fromObject(str);
    //3.将List
    //JSONArray会自动实例化一个集合，然后将ary中的每一个Map转成Emp，
    //增加到这个新建的集合中
    List<Emp> list = (List<Emp>)JSONArray.toCollection(ary, Emp.class);
    for(Emp e : list) {
        System.out.println(e.getName());
    }
}

5、JavaScript

js对象→json字符串

转换函数JSON.stringify，函数签名如下所示：

JSON.stringify(value[, replacer [, space]])

下面将分别展开带1~3个参数的用法：

基本使用——仅需一个参数

//创建js对象
var obj = {"name":"mrbird","age":24};
//将此对象转成json字符串
var str = JSON.stringify(obj);
// "{"name":"mrbird","age":24}"

第二个参数可以是函数，也可以是一个数组

如果第二个参数是一个函数，那么序列化过程中的每个属性都会被这个函数转化和处理.

如果第二个参数是一个数组，那么只有包含在这个数组中的属性才会被序列化到最终的JSON字符串中。

如果第二个参数是null，那作用上和空着没啥区别，但是不想设置第二个参数，只是想设置第三个参数的时候，就可以设置第二个参数为null。

这第二个参数若是函数：

var friend={  
    "firstName": "Good",
    "lastName": "Man",
    "phone":"1234567",
    "age":18
};
 
var friendAfter=JSON.stringify(friend,function(key,value){  
    if(key==="phone")
        return "(000)"+value;
    else if(typeof value === "number")
        return value + 10;
    else
        return value; //如果你把这个else分句删除，那么结果会是undefined
});
 
console.log(friendAfter);  
//输出：{"firstName":"Good","lastName":"Man","phone":"(000)1234567","age":28}

第二个参数若是数组：

var friend={  
    "firstName": "Good",
    "lastName": "Man",
    "phone":"1234567",
    "age":18
};
 
//注意下面的数组有一个值并不是上面对象的任何一个属性名
var friendAfter=JSON.stringify(friend,["firstName","address","phone"]);
 
console.log(friendAfter);  
//{"firstName":"Good","phone":"1234567"}
//指定的“address”由于没有在原来的对象中找到而被忽略

如果第二个参数是一个数组，那么只有在数组中出现的属性才会被序列化进结果字符串，只要在这个提供的数组中找不到的属性就不会被包含进去，而这个数组中存在但是源JS对象中不存在的属性会被忽略，不会报错。

第三个参数用于美化输出

指定缩进用的空白字符，可以取以下几个值：

· 是1-10的某个数字，代表用几个空白字符

· 是字符串的话，就用该字符串代替空格，最多取这个字符串的前10个字符

· 没有提供该参数等于设置成null，也等于设置一个小于1的数

var friend={  
    "firstName": "Good",
    "lastName": "Man",
    "phone":{"home":"1234567","work":"7654321"}
};
 
//直接转化是这样的：
//{"firstName":"Good","lastName":"Man","phone":{"home":"1234567","work":"7654321"}}
 
var friendAfter=JSON.stringify(friend,null,4);  
console.log(friendAfter);  
/*
{
    "firstName": "Good",
    "lastName": "Man",
    "phone": {
        "home": "1234567",
        "work": "7654321"
    }
}
*/
 
var friendAfter=JSON.stringify(friend,null,"HAHAHAHA");  
console.log(friendAfter);  
/*
{
HAHAHAHA"firstName": "Good",  
HAHAHAHA"lastName": "Man",  
HAHAHAHA"phone": {  
HAHAHAHAHAHAHAHA"home": "1234567",  
HAHAHAHAHAHAHAHA"work": "7654321"  
HAHAHAHA}  
}
*/
 
var friendAfter=JSON.stringify(friend,null,"WhatAreYouDoingNow");  
console.log(friendAfter);  
/* 最多只取10个字符
{
WhatAreYou"firstName": "Good",  
WhatAreYou"lastName": "Man",  
WhatAreYou"phone": {  
WhatAreYouWhatAreYou"home": "1234567",  
WhatAreYouWhatAreYou"work": "7654321"  
WhatAreYou}  
}
*/

JSON.stringify函数有几个需要注意的地方：

1.键名不是双引号的（包括没有引号或者是单引号），会自动变成双引号；字符串是单引号的，会自动变成双引号。

2.最后一个属性后面有逗号的，会被自动去掉。

3.非数组对象的属性不能保证以特定的顺序出现在序列化后的字符串中 这个好理解，也就是对非数组对象在最终字符串中不保证属性顺序和原来一致。

4.布尔值、数字、字符串的包装对象在序列化过程中会自动转换成对应的原始值 也就是你的什么new String(“bala”)会变成”bala”，new Number(2017)会变成2017。

5.undefined、任意的函数（其实有个函数会发生神奇的事，后面会说）以及 symbol值。

• 出现在非数组对象的属性值中：在序列化过程中会被忽略。
• 出现在数组中时：被转换成 null。

JSON.stringify({x: undefined, y: function(){return 1;}, z: Symbol("")});  
//出现在非数组对象的属性值中被忽略："{}"
JSON.stringify([undefined, Object, Symbol("")]);  
//出现在数组对象的属性值中，变成null："[null,null,null]"

将JSON字符串解析为JS数据结构

函数JSON.parse的签名如下：

JSON.parse(text[, reviver])

如果第一个参数，即JSON字符串不是合法的字符串的话，那么这个函数会抛出错误。值得注意的是这里有一个可选的第二个参数，这个参数必须是一个函数，这个函数作用在属性已经被解析但是还没返回前，将属性处理后再返回。

var friend={  
    "firstName": "Good",
    "lastName": "Man",
    "phone":{"home":"1234567","work":["7654321","999000"]}
};
 
//我们先将其序列化
var friendAfter=JSON.stringify(friend);  
//'{"firstName":"Good","lastName":"Man","phone":{"home":"1234567","work":["7654321","999000"]}}'
 
//再将其解析出来，在第二个参数的函数中打印出key和value
JSON.parse(friendAfter,function(k,v){  
    console.log(k);
    console.log(v);
    console.log("----");
});
/*
firstName  
Good  
----
lastName  
Man  
----
home  
1234567  
----
0  
7654321  
----
1  
999000  
----
work  
[]
----
phone  
Object  
----
 
Object  
----
*/

仔细看一下这些输出，可以发现这个遍历是由内而外的，可能由内而外这个词大家会误解，最里层是内部数组里的两个值啊，但是输出是从第一个属性开始的，怎么就是由内而外的呢？

这个由内而外指的是对于复合属性来说的，通俗地讲，遍历的时候，从头到尾进行遍历，如果是简单属性值（数值、字符串、布尔值和null），那么直接遍历完成，如果是遇到属性值是对象或者数组形式的，那么暂停，先遍历这个子JSON，而遍历的原则也是一样的，等这个复合属性遍历完成，那么再完成对这个属性的遍历返回。

本质上，这就是一个深度优先的遍历。

影响 JSON.stringify 的神奇函数——object.toJSON

如果你在一个JS对象上实现了toJSON方法，那么调用JSON.stringify去序列化这个JS对象时，JSON.stringify会把这个对象的toJSON方法返回的值作为参数去进行序列化。

var info={  
    "msg":"I Love You",
    "toJSON":function(){
        var replaceMsg=new Object();
        replaceMsg["msg"]="Go Die";
        return replaceMsg;
    }
};
 
JSON.stringify(info);  
//出si了，返回的是：'"{"msg":"Go Die"}"',说好的忽略函数呢

这个函数就是这样子的。

其实Date类型可以直接传给JSON.stringify做参数，其中的道理就是，Date类型内置了toJSON方法。