JSON详解

1. 什么是JSON

​ JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。JSON 采用完全独立于语言的文本格式，而且很多语言都提供了对 json 的支持（包括 C, C++, C#, Java, JavaScript, Perl, Python 等）。 这样就使得 JSON 成为理想的数据交换格式。

• json 是一种轻量级的数据交换格式。
• 轻量级指的是跟 xml 做比较。
• 数据交换指的是客户端和服务器之间业务数据的传递格式。

2. JSON 在 JavaScript 中的使用

​ 我们要使用json 和java中使用，我们需要使用到一个第三方的包。它就是gson.jar。

​ Gson是Google提供的用来在 Java 对象和 JSON 数据之间进行映射的 Java 类库。可以将一个JSON字符串转成一个 Java 对象，或者反过来。

json在 java中的操作。常见的有三种情况。

1. java 对象和 json 的转换
2. java 对象 list 集合和 json 的转换
3. map 对象和 json 的转换

2.1. json的定义

​ json 是由键值对组成，并且由花括号（大括号）包围。每个键由引号引起来，键和值之间使用冒号进行分隔， 多组键值对之间进行逗号进行分隔。

json 定义示例：

var jsonObj = { 
    "key1":12, 
    "key2":"abc", 
    "key3":true, 
    "key4":[11,"arr",false], 
    "key5":{ 
        "key5_1" : 551, 
        "key5_2" : "key5_2_value" 
    }, 
    "key6":[{ 
        "key6_1_1":6611, 
        "key6_1_2":"key6_1_2_value"
	},{ 
        "key6_2_1":6621, 
        "key6_2_2":"key6_2_2_value" 
    }]
};

json 访问示例：

alert(typeof(jsonObj));// object json 就 是 一 个 对 象
alert(jsonObj.key1); //12 
alert(jsonObj.key2); // abc 
alert(jsonObj.key3); // true 
alert(jsonObj.key4);// 得 到 数 组 [11,"arr",false] 
// json 中 数 组 值 的 遍 历 
for(var i = 0; i < jsonObj.key4.length; i++) { 
    alert(jsonObj.key4[i]); 
} 
alert(jsonObj.key5.key5_1);//551 
alert(jsonObj.key5.key5_2);//key5_2_value 
alert( jsonObj.key6 );// 得 到 json 数 组

//取 出 来 每 一 个 元 素 都 是 json对 象 
var jsonItem = jsonObj.key6[0]; 
// alert( jsonItem.key6_1_1 ); //6611 
alert( jsonItem.key6_1_2 ); //key6_1_2_value

2.2. json 的两个常用方法

​ json 的存在有两种形式。

• 一种是：对象的形式存在，我们叫它 json 对象。

• 一种是：字符串的形式存在，我们叫它 json 字符串。

  一般我们要操作 json 中的数据的时候，需要 json 对象的格式。

  一般我们要在客户端和服务器之间进行数据交换的时候，使用 json 字符串。

  JSON.stringify() // 把 json 对象转换成为 json 字符串
  JSON.parse() 	// 把 json 字符串转换成为 json 对象
  

  示例代码：

  //把json对象转换成为json字符串 
  var jsonObjString = JSON.stringify(jsonObj); //特别像Java中对象的toString
  alert(jsonObjString) 
  
  //把json字符串。转换成为json对象 
  var jsonObj2 = JSON.parse(jsonObjString); 
  alert(jsonObj2.key1);// 12 
  alert(jsonObj2.key2);// abc
  

3. JSON在Java中的使用

3.1. javaBean 和 json 的互转

@Test 
public void test1(){ 
    Person person = new Person(1,"张三"); 
    // 创建Gson对象实例 
    Gson gson = new Gson(); 
    
    // toJson方法可以把java对象转换成为json字符串 
    String personJsonString = gson.toJson(person); 
    System.out.println(personJsonString); 
    
    //fromJson把json字符串转换回Java对象
    //第一个参数是json字符串
    //第二个参数是转换回去的Java对象类型
    Person person1 = gson.fromJson(personJsonString, Person.class); 
    System.out.println(person1); 
}

3.2. List 和 json 的互转

@Test 
public void test2() {
	List<Person> personList = new ArrayList<>();
	personList.add(new Person(1, "张三")); 
	personList.add(new Person(2, "李四"));
    
    // 首先new一个Gson对象
	Gson gson = new Gson();
    
	//把List转换为json字符串 
	String personListJsonString = gson.toJson(personList); 
    System.out.println(personListJsonString);
    
    // 要把复杂的 json 字符串转换成为 java 的List对象。需要继承 TypeToken 类。 
    // 并把返回的类型当成 TypeToken 的泛型注入 
    // 继承的TypeToken中传入要转换的类型
    // static class PersonListType extends TypeToken<List<Person>> { }
    // List<Person> list = gson.fromJson(personListJsonString, new PersonListType().getType()); 

    // 我们也可以使用匿名内部类将要转换的类型存放到参数列表中
    List<Person> list = gson.fromJson(personListJsonString, new TypeToken<List<Person>>() { }.getType()); 
    System.out.println(list); 
    Person person = list.get(0); 
    System.out.println(person);
}

3.3. Map和json的互转

@Test 
public void test3(){ 
    Map<Integer,Person> personMap = new HashMap<>();
    personMap.put(1, new Person(1, "张三")); 
    personMap.put(2, new Person(2, "李四"));

    Gson gson = new Gson(); 
    
    // 把map集合转换成为json字符串 
    String personMapJsonString = gson.toJson(personMap); 
    System.out.println(personMapJsonString);
    
    // 要把复杂的 json 字符串转换成为 java 的Map对象。需要继承 TypeToken 类。 
    // 并把返回的类型当成 TypeToken 的泛型注入 
    // 继承的TypeToken中传入要转换的类型
    // static class PersonType extends TypeToken<Map<Integer,Person>> { }
	// Map<Integer,Person> personMap2 = gson.fromJson(personMapJsonString, new PersonMapType().getType()); 	
    
    // 我们也可以使用匿名内部类将要转换的类型存放到参数列表中
    Map<Integer,Person> personMap2 = gson.fromJson(personMapJsonString, new 	
                                                   TypeToken<HashMap<Integer,Person>>(){}.getType());
    System.out.println(personMap2); 
    Person p = personMap2.get(1); 
    System.out.println(p);
}