JSON数据格式

JSON数据格式

　　JSON(JavaScript Object Notation)是一种轻量级的数据交换格式.JSON采用完全独立于语言的文本格式,就是说不同的编程语言JSON数据都是一致的.JS支持原生JSON.

JSON的两种数据格式

　　数组格式:[obj,obj,obj]

　　对象格式:{"key1":obj,"key2",obj,"key3":obj...}

　　两种数据格式可以任意进行嵌套.

JSON数据解析

<script type="text/javascript">
/**
* 案例一
* {key:value,key:value}
* 
* class Person{
* String firstname = "李";
*  String lastname = "青木";
*  Integer age = 18;
* }
*
* Person p = new Person();
* System.out.println(p.firstname);
*/
var json = {
"firstname":"李",
"lastname":"青木",
"age":18
};
alert(json.firstname+":::"+json.age);
 </script>

<script  type="text/javascript">
/**
* 案例二
* [{key:value,key:value},{key:value,key:value}]
*/
var json = [
    {"lastname":"李","firstname":"青木","age":18},
    {"lastname":"张","firstname":"青木","age":19},
    {"lastname":"张","firstname":"翠山","age":98}    
   ];

for(var i=0;i<json.length;i++){
alert(json[i].firstname+":::"+json[i].age);
}
alert(json[1].age);
 </script>

<script  type="text/javascript">
 /**
* 案例三
* {
*  "param":[{key:value,key:value},{key:value,key:value}]
* }
*/
var json = {
"baba":[
     {"name":"wusan",age:15},
     {"name":"liusi",age:20}
    ]
};
for(var i = 0 ; i <json.baobao.length;i++){
alert(json.baobao[i].name+"...."+json.baobao[i].age);
}
</script>

<script  type="text/javascript">
  /**
* 案例四
* {
*  "param1":[{key:value,key:value},{key:value,key:value}],
*  "param2":[{key:value,key:value},{key:value,key:value}],
*  "param3":[{key:value,key:value},{key:value,key:value}]
* }
*/
var json = {
 "baobao":[
     {"name":"zhangsan","age":20},
     {"name":"lisi","age":25}
     ],
 "haohao":[
      {"name":"wangwu","age":30},
      {"name":"zhaoliu","age":10}
     ]
};
alert(json.haohao[0].name);
</script>

转换josn数据格式的工具有:

1.json-lib     用的人最多,但是引入依赖较为复杂,还容易在转换时
json-lib最开始的也是应用最广泛的json解析工具，json-lib 不好的地方确实是依赖于很多第三方包，
包括commons-beanutils.jar，commons-collections-3.2.jar，commons-lang-2.6.jar，commons-logging-1.1.1.jar，ezmorph-1.0.6.jar，
对于复杂类型的转换，json-lib对于json转换成bean还有缺陷，比如一个类里面会出现另一个类的list或者map集合，json-lib从json到bean的转换就会出现问题。
json-lib在功能和性能上面都不能满足现在互联网化的需求。

方法:

2.开源的Jackson   依赖少,但是转换复杂类型的时候,容易出错.
相比json-lib框架，Jackson所依赖的jar包较少，简单易用并且性能也要相对高些。
而且Jackson社区相对比较活跃，更新速度也比较快。
Jackson对于复杂类型的json转换bean会出现问题，一些集合Map，List的转换出现问题。
Jackson对于复杂类型的bean转换Json，转换的json格式不是标准的Json格式

依赖

<dependency>

    <groupId>com.fasterxml.jackson.core</groupId>

    <artifactId>jackson-core</artifactId>

    <version>2.9.2</version>

</dependency>

<dependency>

    <groupId>com.fasterxml.jackson.core</groupId>

    <artifactId>jackson-databind</artifactId>

    <version>2.9.2</version>

</dependency>

<dependency>

    <groupId>com.fasterxml.jackson.core</groupId>

    <artifactId>jackson-annotations</artifactId>

    <version>2.9.2</version>

</dependency>

代码:

import com.fasterxml.jackson.databind.ObjectMapper;

import com.zzs.json.bean.Person;

 

public class JacksonTest {

    @Test

    public void test1() throws IOException {

       Person person = new Person();

       person.setName("zhangsan");

       person.setAge(20);

 

       /**

        * ObjectMapper是JSON操作的核心，Jackson的所有JSON操作都是在ObjectMapper中实现。

        * ObjectMapper有多个JSON序列化的方法，可以把JSON字符串保存File、OutputStream等不同的介质中。

        * writeValue(File arg0, Object arg1)把arg1转成json序列，并保存到arg0文件中。

        * writeValue(OutputStream arg0, Object arg1)把arg1转成json序列，并保存到arg0输出流中。

        * writeValueAsBytes(Object arg0)把arg0转成json序列，并把结果输出成字节数组。

        * writeValueAsString(Object arg0)把arg0转成json序列，并把结果输出成字符串。

        */

       ObjectMapper mapper = new ObjectMapper();

 

       // User类转JSON

       String json = mapper.writeValueAsString(person);

       // 输出结果：{"name":"zhangsan","age":20}

       System.out.println(json);

 

       // JSON解析

       Person readValue = mapper.readValue(json, Person.class);

       // 输出结果：Person [name=zhangsan, age=20]

       System.out.println(readValue);

    }

}

3.Google的Gson  功能强大,但是性能比fastJson低
Gson是目前功能最全的Json解析神器，Gson当初是为因应Google公司内部需求而由Google自行研发而来，
但自从在2008年五月公开发布第一版后已被许多公司或用户应用。
Gson的应用主要为toJson与fromJson两个转换函数，无依赖，不需要例外额外的jar，能够直接跑在JDK上。
而在使用这种对象转换之前需先创建好对象的类型以及其成员才能成功的将JSON字符串成功转换成相对应的对象。
类里面只要有get和set方法，Gson完全可以将复杂类型的json到bean或bean到json的转换，是JSON解析的神器。
Gson在功能上面无可挑剔，但是性能上面比FastJson有所差距。

依赖

<dependency>

    <groupId>com.google.code.gson</groupId>

    <artifactId>gson</artifactId>

    <version>最新</version>

</dependency>

javaBean

public class Person {

    private String name;

    private int age;

}

import org.junit.Test;

import com.google.gson.Gson;

 

public class GSONTest {

    @Test

    public void test() {

       Gson gson = new Gson();


       Person person = new Person();

       person.setName("zhangsan");

       person.setAge(20);

 
       String json = gson.toJson(person);

       // {"name":"zhangsan","age":20}

       System.out.println(json);

       Person fromJson = gson.fromJson(json, Person.class);

       // Person [name=zhangsan, age=20]

       System.out.println(fromJson);

    }

}

4.阿里巴巴的FastJson
Fastjson是一个Java语言编写的高性能的JSON处理器,由阿里巴巴公司开发。
无依赖，不需要例外额外的jar，能够直接跑在JDK上。
FastJson在复杂类型的Bean转换Json上会出现一些问题，可能会出现引用的类型，导致Json转换出错，需要制定引用。
FastJson采用独创的算法，将parse的速度提升到极致，超过所有json库。

综上所述,在做项目的时候,如果没有性能要求,可以使用Gson.如果有性能要求的时候,可以将Bean使用Gson进行转换,保证数据的准确性,

取出来数据的时候,可以使用fstJson将json转为Bean

依赖

<dependency>

    <groupId>com.alibaba</groupId>

    <artifactId>fastjson</artifactId>

    <version>1.2.42</version>

</dependency>

代码

方法入口：

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> T parseObject(String text, Class<T> clazz); // 把JSON文本parse为JavaBean

    public static final JSONArray parseArray(String text); // 把JSON文本parse成JSONArray

    public static final <T> List<T> parseArray(String text, Class<T> 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。

import com.alibaba.fastjson.JSON;

import com.alibaba.fastjson.JSONArray;

import com.alibaba.fastjson.JSONObject;

 

public class FastjsonTest {

    /**

     * 创建JSON

     */

    @Test

    public void test1() {

       // 创建一个 Person 对象

       Person person = new Person();

       person.setName("zhangsan");

       person.setAge(20);

       // 将 Person 对象转为 json 字符串

       String json = JSON.toJSONString(person);

       // 输出结果：{"age":20,"name":"zhangsan"}

       System.out.println(json);

 

       // 将 Person 对象转为 json 字符串, 这个字符串是经过格式化的

       String format_json = JSON.toJSONString(person, true);

       System.out.println(format_json);

    }

 

    @Test

    public void test2() {

       String json_array = "[{"age":20,"name":"zhangsan"},{"age":22,"name":"lisi"}]";

       // 将 json 字符串转为 JSONArray 对象

       JSONArray array = JSON.parseArray(json_array);

       System.out.println(array);

 

       // 将 json 字符串转为 List 集合

       List<Person> list = JSON.parseArray(json_array, Person.class);

       for (Person person : list) {

           System.out.println(person);

       }

    }

 

    /**

     * JSON解析

     */

    @Test

    public void test3() {

       String json = "{"age":20,"name":"zhangsan"}";

       // 将 json 字符串转为 JSONObject 对象

       JSONObject object = JSON.parseObject(json);

       System.out.println(object);

 

       // 将 json 字符串转为 Student 对象

       Person person = JSON.parseObject(json, Person.class);

       System.out.println(person);

    }

}

总结一下各个转换工具的优劣:

调用方便性而言：
 
FastJSON提供了大量静态方法，调用简洁方便
Jackson须实例化类，调用相对繁琐，可通过封装成JSON工具类简化调用
 
 
性能而言：
 
FastJSON反序列化的性能略差，对于256k的json字符串，平均700ms
Jackson 的 data binding反序列化的性能稍好，对于256k的json字符串，平均600ms
两者的序列化性能基本相同，对于256k的json字符串，平均140ms
相对data binding方式（ObjectMapper.writeValueAsString()），Jackson的流输出方式（JsonGenerator.writeObject()）性能稍好，平均130ms