JavaWeb-JSON的使用

1. 什么是JSON

JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成。JSON 采用完全独立于语言的文本格式，而且受很多语言的支持。这样就使得JSON成为理想的数据交换格式。

JSON 是一种轻量级的数据交换格式（其轻量性是相较于XML的），数据交换指的是客户端和服务器之间的业务数据传递格式。

2. JSON在JavaScript中的使用

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,
		"key5_1_2" : "key5_1_2_value"
	}, {
		"key6_2_1" : 6621,
		"key5_2_2" : "key5_2_2_value"
	}]
};

2.2 JSON的访问

json 本身就是一个Objet 对象，json中的key我们可以理解为是对象中的一个属性。访问json 中的key 就可以跟访问对象中的属性一样：jsonObject.key

访问示例：

alert(jsonObj.key1);
alert(jsonObj.key6[0].key6_1_1);

2.3 JSON的两个常用方法

JSON 的存在有两种形式：

1. 对象的存在形式，我们叫它JSON对象。在我们操作JSON中的数据的时候，需要使用JSON对象形式。
2. 字符串的存在形式，我们叫它JSON字符串。在客户端和服务器端进行数据交换的时候，使用JSON字符串形式。

JSON.stringify(jsonObject) ：把 JSON对象转换成伟 JSON字符串。
JSON.parse(jsonString) ：把 JSON字符串转换成 JSON对象。

转换示例：

// 把 json对象转换成为 json字符串
var jsonObjString = JSON.stringify(jsonObj);
alert(jsonObjString);
// 把 json字符串，转换成为 json对象
var jsonObj2 = JSON.parse(jsonObjString);
alert(jsonObj2.key1);

3. JSON在Java中的使用

在java 中，如果想要操作 json，需要先导入 json的 jar 包，这里我们使用的是谷歌提供的 gson-2.2.4.jar

首先，我们创建一个 JavaBean：Person 类

package com.zju.pojo;

/**
 * @author guosongyuan
 * @version 1.0
 */
public class Person {
    private Integer id;
    private String name;
    public Person() {
    }
    public Person(Integer id, String name) {
        this.id = id;
        this.name = name;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

2.1 JavaBean和Json的转换

public class JSONTest {

    // JavaBean 和 json 的互转
    @Test
    public void test() {
        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 person2 = gson.fromJson(personJsonString, Person.class);
        System.out.println(person2);
    }
}

2.2 List和Json的转换

这里需要写一个类去继承com.google.gson.reflect.TypeToken，然后再调用gson.fromJson

package com.zju.json;

import com.google.gson.reflect.TypeToken;
import com.zju.pojo.Person;

import java.util.ArrayList;

/**
 * @author guosongyuan
 * @version 1.0
 */
public class PersonListType extends TypeToken<ArrayList<Person>> {
}

注意，除了这种硬编码的继承方式，也可以使用匿名类【推荐】。

// List 和 json 的互转
@Test
public void test2() {
    List<Person> personList = new ArrayList<>();
    personList.add(new Person(1, "小红"));
    personList.add(new Person(2, "小明"));

    Gson gson = new Gson();

    // 把List 转换为 json字符串
    String personListJsonString = gson.toJson(personList);
    // 输出：[{"id":1,"name":"小红"},{"id":2,"name":"小明"}]
    System.out.println(personListJsonString);

    // 方法1：定义一个类去继承 com.google.gson.reflect.TypeToken
    List<Person> list = gson.fromJson(personListJsonString, new PersonListType().getType());

    /**
     * Person{id=1, name='小红'}
     * Person{id=2, name='小明'}
     */
    list.forEach(System.out :: println);

    // 方法二：直接使用匿名类实现继承【推荐】
    List<Person> list2 = gson.fromJson(personListJsonString, new TypeToken<ArrayList<Person>>() {
    }.getType());

    /**
     * Person{id=1, name='小红'}
     * Person{id=2, name='小明'}
     */
    list2.forEach(System.out :: println);
}

2.3 Map和Json的转换

这里需要写一个类去继承com.google.gson.reflect.TypeToken，然后再调用gson.fromJson

package com.zju.json;

import com.google.gson.reflect.TypeToken;
import com.zju.pojo.Person;

import java.util.HashMap;

/**
 * @author guosongyuan
 * @version 1.0
 */
public class PersonMapType extends TypeToken<HashMap<Integer, Person>> {
}

注意，除了这种硬编码的继承方式，也可以使用匿名类【推荐】。

// 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);

    // 输出：{"1":{"id":1,"name":"郭哥好帅"},"2":{"id":2,"name":"国哥好帅"}}
    System.out.println(personMapJsonString);

    // 这里需要定一个一个类去继承 com.google.gson.reflect.TypeToken
    Map<Integer, Person> map = gson.fromJson(personMapJsonString, new PersonMapType().getType());

    /**
     * 1=Person{id=1, name='郭哥好帅'}
     * 2=Person{id=2, name='国哥好帅'}
     */
    map.entrySet().forEach(System.out :: println);

    // 也可以直接使用匿名类实现继承【推荐】
    Map<Integer, Person> map2 = gson.fromJson(personMapJsonString, new TypeToken<HashMap<Integer, Person>>() {
    }.getType());

    /**
     * 1=Person{id=1, name='郭哥好帅'}
     * 2=Person{id=2, name='国哥好帅'}
     */
    map2.entrySet().forEach(System.out :: println);
}