json-14

Python publisher01 40℃

JSON

JSON 是一种轻量级易与解析的数据格式,它按照 js 的对象和数组的字面
量格式来书写。 现在 JSON 的光环已经逐渐超越了 XML,各大网站提供的数据
接口一般都是 JSON。

下面的代码是用 JSON 编写的用户列表:


[
{
“name”: “john”,
“age”: 15
},
{
“name”: “wall”,
“age”: 22
},
{
“name”: “ben”,
“age”: 8
}
]


jquery 1.4 以后对 json
格式变严格了,也就是说必须要这种格式的{“键”:”值
“,”键”:”值”};像原来的{键:值,键:值}和{‘键’:’值’,’键’:’值’}这种都是错误的,不合标准,所以
jquery 返回 error
如”{\”success\”:true,\”msg\”:\”success\”}”,如果说是boolean
类型,则不用加 引号,其它的键/值都需要加引号。

1. JSON 是什么?
JSON: JavaScript 对象表示法(JavaScript Object Notation) ,
一种轻量级的数\据交换格式, 易于人阅读和编写, 也易于机器解析和生成。用来描述数据结构,
它是基于纯文本的数据格式,是一种轻量级的数据交换格式。广泛应用于服务端与客户端的数据交互。
JSON 是存储和交换文本信息的语法,类似 XML。
JSON 采用完全独立于语言的文本格式,也使用了类似于 C 语言家族的习
惯(包括 C, C++, C#, Java, JavaScript, Perl, Python…)这些特性使 JSON
成为理想
的数据交换语言。

JSON 是一个新的人类可读( human readable)的数据格式,在过去几年中已变
得非常 受欢迎,尤其是在 web 开发中。

1) 基本类型


{
“name”: 张三,
“age”: 18,
“sex”: true
}


2) 数组类型

[
{
"name": "张三",
"age": 18,
"sex": true
},
{
"name": "李四",
"age": 19,
"sex": false
}
]

3) 对象嵌套

{
"name": "teacher",
"computer": {
"CPU": "intel7",
"disk": "512G"
},
"students": [
{
"name": "张三",
"age": 18,
"sex": true
},
{
"name": "李四",
"age": 19,
"sex": false
}
]
}

2. JSON 格式
1) 两种构建结构
a)、对象:”名称/对的集合**(A collection of name/value
pairs)\

不同的语言中,它被理解为对象(object),记录(record),结构(struct),
字典 (dictionary),哈希表(hash table),有键列表(keyed
list),或者关联数组(associative array)。
b)、数组:值的有序列表**(An ordered list of values)
**在大多数语言中,它被理解为数组(array)、矢量(vector),
列表(list)或者序列
(sequence)。
经过对象、数组 2 种结构就可以组合成复杂的数据结构了。

2) 具体形式
Json 以 key-value 的形式存储数据
Key 的取值 为 String 类型;
Value 的取值 为 String,boolean,Number,数组,Object,null;
Json 串以{开始,以}结尾;
Json 串中数组是以[开始,以]结尾;
Json 串中 Object 是以{开始,以}结尾;
具体如下: [http://www.json.org/]{.underline}

a)、对象是一个无序的”名称/值”对集合。一个对象以”{“开始, “}”结束。每
个名称后跟一个”:”; “名称/值 “对之间使用”,”分隔。


image.png

b)、数组是值的有序集合。一个数组以”[“开始,
“]”结束。各值间使用”,”分隔。


image.png

c)、值(value)可以是双引号括起来的字符串(string)、数值(number)、
true、
false、 null、 对象(object)或者数组(array)。这些结构可以嵌套。


image.png

d)、字符串(string)是由 0 到多个 Unicode 字符组成的序列,封装在双引
号中, 可
以使用反斜杠’\’进行转义。一个字符可以表示为一个单一字符的字符串。


image.png

e)、数字(number)类似 C 或者 Java 里面的数,没有用到的 8 进制和 16 进
制数除外


image.png

二、 解析方式
1. 使用 gson 处理
Gson是一个 Google提供的一个 Java库,可用于将 Java对象转换为 JSON表示。
它也可以被用来将 JSON 字符串转换成一个等效的 Java 对象。
提供易于使用的机制如 toString()和构造函数(工厂方法)将 Java 转换为 JSON,
反之亦然。 允许自定义表示对象,支持任意复杂的对象,生成紧凑和可读性的JSON
输出.

***1) 转为 Json 字符串
I)、获得需要的对象:


Student stu = new Student();
stu.setName(“张三”);
stu.setAge(18);


II)、格式化为字符串


Gson gson = new Gson();
//将 对象 转化成 json 字符串
String json = gson.toJson(stu)


2) 解析成 java 对象
I)、 Gson 的 节点对象:**
JsonElement : 所有的节点 都是 JsonElement 对象.
JsonPrimitive : 基本的 数据类型的 节点 对象, JsonElement 的子类.
JsonNull : 代表 空节点 对象,即 有 key, value 为空, JsonElement
的子类.
JsonObject : 对象 数据类型的 节点 对象, JsonElement 的 子类.
JsonArray : 数组 数据类型的 节点 对象, JsonElement 的 子类.
II)、 JsonElement 的取值:

**JsonPrimitive : value 的 取值对应 java 的
int,double,float,long,short,boolean,char,byte,String,BigDecimal,BigI
nteger,Number
JsonObject : value 的取值对应 java 的 Object 对象.
JsonArray : value 的取值对应 java 的 List 及其子类对象.

  • -Json 解析成 java 对象

  • -Json 解析 成 List

  • Json 解析 成 map

  • -Json 节点解析

  • Json 节点解析

{
“flag”: true,
“data”: {
“name”: 张三,
“age”: 18,
“sex”:
}
}


解析步骤 :
①获得解析器


JsonParser parser = new JsonParser();


②获得根节点元素


JsonElement element = parser.parse(json);


③根据文档判断根节点属于什么类型的 Gson 节点对象


// 假如文档 显示 根节点 为对象类型
// 获得 根节点 的实际 节点类型
JsonObject root = element.getAsJsonObject();


④取得节点下的某个节点的 value


// 获得 flag 节点的值, flag 节点为基本数据节点
JsonPrimitive flagJson = root.getAsJsonPrimitive(“flag”);
// 基本节点取值
boolean flag = flagJson.getAsBoolean();
// 获得 data 节点的值, data 节点为 Object 数据节点
JsonObject dataJson = root.getAsJsonObject(“data”);
// 将节点上的数据转换为对象


package com.shsxt.test;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.Test;
import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.google.gson.JsonPrimitive;
import com.google.gson.reflect.TypeToken;
import com.shsxt.model.User;
/**
 * 单元测试类
 *  选择要执行的方法,右键,选择Run As 或 Debug As,选择JUnit Test执行方法(如果没有选择方法,则全部执行)
 *      成功:绿色;报错:暗红色
 * 注:
 *  1、单元测试的方法都必须加注解@Test
 *  2、不能有父类
 *  3、不能是静态方法
 *  4、不能有参数
 *  5、返回值是void
 * @author Lisa Li
 *
 */
public class GsonTest {
    @Test
    public void test() {
        // fail("Not yet implemented");
        //System.out.println("Hello JUnit!");
    }
    
    
    /**
     * 将java对象转换成json字符串
     */
    @Test
    public void testJavaToJson() {
        
        // 得到Gson对象
        Gson gson = new Gson();
        
        // JavaBean对象
        User user = new User(1, "zhangsan", "123456", 18, "上海");
        // 将JavaBean对象转换为json字符串
        String json = gson.toJson(user);
        
        System.out.println(json);
        
        // List集合
        List<String> list = new ArrayList<String>();
        list.add("zhangsan");
        list.add("lisi");
        list.add("wangwu");
        String json2 = gson.toJson(list);
        System.out.println(json2);
        
        // JavaBean List
        List<User> userList = new ArrayList<>();
        User user2 = new User(2, "lisi", "123124", 19, "北京");
        User user3 = new User(3, "wangwu", "111111", 20, "杭州");
        userList.add(user);
        userList.add(user2);
        userList.add(user3);
        String json3 = gson.toJson(userList);
        System.out.println(json3);
        
        
        // Map
        Map<String, Object> map = new HashMap<>();
        map.put("name","zhansgan");
        map.put("sex",true);
        map.put("user", user);
        map.put("userList", userList);
        String json4 = gson.toJson(map);
        System.out.println(json4);
        
        
        Map<String, Object> map2 = new HashMap<>();
        map2.put("user1", user);
        map2.put("user2", user2);
        map2.put("user3", user3);
        String json5 = gson.toJson(map2);
        System.out.println(json5);
        
    }
    
    /**
     * 将json字符串转换成java对象
     */
    @Test
    public void testJsonTtoJava() {
        // 转JavaBean
        String json1 = "{\"userId\":1,\"userName\":\"zhangsan\",\"userPwd\":\"123456\",\"userAge\":18,\"address\":\"上海\"}";
        User user = new Gson().fromJson(json1, User.class);
        System.out.println(user.getUserName());
        
        
        // 转List
        String json2 = "[\"zhangsan\",\"lisi\",\"wangwu\"]";
        List<String> list = new Gson().fromJson(json2, new TypeToken<List<String>>(){}.getType());
        System.out.println(list.get(0));
        
        
        String json3 = "[{\"userId\":1,\"userName\":\"zhangsan\",\"userPwd\":\"123456\",\"userAge\":18,\"address\":\"上海\"},{\"userId\":2,\"userName\":\"lisi\",\"userPwd\":\"123124\",\"userAge\":19,\"address\":\"北京\"},{\"userId\":3,\"userName\":\"wangwu\",\"userPwd\":\"111111\",\"userAge\":20,\"address\":\"杭州\"}]";
        List<User> userList = new Gson().fromJson(json3, new TypeToken<List<User>>(){}.getType());
        System.out.println(userList.get(0));
        
        
        String json4 = "{\"user1\":{\"userId\":1,\"userName\":\"zhangsan\",\"userPwd\":\"123456\",\"userAge\":18,\"address\":\"上海\"},\"user2\":{\"userId\":2,\"userName\":\"lisi\",\"userPwd\":\"123124\",\"userAge\":19,\"address\":\"北京\"},\"user3\":{\"userId\":3,\"userName\":\"wangwu\",\"userPwd\":\"111111\",\"userAge\":20,\"address\":\"杭州\"}}";
        Map<String,User> map = new Gson().fromJson(json4, new TypeToken<Map<String,User>>(){}.getType());
        System.out.println(map.get("user2"));
    
    }
    
    
    /**
     * 节点解析
     * {
     *  "userList":[
     *      {"userId":1,"userName":"zhangsan","userPwd":"123456","userAge":18,"address":"上海"},
     *      {"userId":2,"userName":"lisi","userPwd":"123124","userAge":19,"address":"北京"},
     *      {"userId":3,"userName":"wangwu","userPwd":"111111","userAge":20,"address":"杭州"}
     *   ],
     *  "sex":true,
     *  "name":"zhansgan",
     *  "user":{
     *      "userId":1,
     *      "userName":"zhangsan",
     *      "userPwd":"123456",
     *      "userAge":18,
     *      "address":"上海"
     *  }
     * }
     * 
     */
    @Test
    public void jsonParser() {
        String json = "{\"userList\":[{\"userId\":1,\"userName\":\"zhangsan\",\"userPwd\":\"123456\",\"userAge\":18,\"address\":\"上海\"},{\"userId\":2,\"userName\":\"lisi\",\"userPwd\":\"123124\",\"userAge\":19,\"address\":\"北京\"},{\"userId\":3,\"userName\":\"wangwu\",\"userPwd\":\"111111\",\"userAge\":20,\"address\":\"杭州\"}],\"sex\":true,\"name\":\"zhansgan\",\"user\":{\"userId\":1,\"userName\":\"zhangsan\",\"userPwd\":\"123456\",\"userAge\":18,\"address\":\"上海\"}}";
        
        // 得到解析器
        JsonParser parser = new JsonParser();
        // 得到文档节点
        JsonElement jsonElement = parser.parse(json);
        // 根据文档的字符串类型判断节点类型   {}对象是JsonObject类型
        JsonObject root = jsonElement.getAsJsonObject();
        
        // 开始解析文档中的具体节点
        // sex  布尔类型  基本数据类型
        JsonPrimitive jsonPrimitive = root.getAsJsonPrimitive("sex");
        boolean sex = jsonPrimitive.getAsBoolean();
        System.out.println(sex);
        
        // name 字符串 基本数据类型
        JsonPrimitive jsonPrimitive2 = root.getAsJsonPrimitive("name");
        String name = jsonPrimitive2.getAsString();
        System.out.println(name);
        
        // user  user对象    jsonObject
        JsonObject jsonObject = root.getAsJsonObject("user");
        User user = new Gson().fromJson(jsonObject, User.class);
        System.out.println(user);
        
        // userList   List   JsonArray
        JsonArray jsonArray = root.getAsJsonArray("userList");
        List<User> userList = new Gson().fromJson(jsonArray, new TypeToken<List<User>>(){}.getType());
        System.out.println(userList);
        
    
    }
}

用户类

package com.shsxt.model;
/**
 * 用户类
 * @author Lisa Li
 *
 */
public class User {
    private Integer userId; // 主键,用户ID
    private String userName; // 用户名
    private String userPwd; // 用户密码
    private Integer userAge; // 用户年龄
    private String address; // 地址
    
    
    public User() {
        super();
    }
    public User(Integer userId, String userName, String userPwd, Integer userAge, String address) {
        super();
        this.userId = userId;
        this.userName = userName;
        this.userPwd = userPwd;
        this.userAge = userAge;
        this.address = address;
    }
    public Integer getUserId() {
        return userId;
    }
    public void setUserId(Integer userId) {
        this.userId = userId;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getUserPwd() {
        return userPwd;
    }
    public void setUserPwd(String userPwd) {
        this.userPwd = userPwd;
    }
    public Integer getUserAge() {
        return userAge;
    }
    public void setUserAge(Integer userAge) {
        this.userAge = userAge;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    @Override
    public String toString() {
        return "User [userId=" + userId + ", userName=" + userName + ", userPwd=" + userPwd + ", userAge=" + userAge
                + ", address=" + address + "]";
    }
    
}

2. 使用 fastjson 处理

阿里巴巴 fastJson 是一个 Json 处理工具包,包括”序列化”和”反序列化”两
部分,它 具备如下特征:速度最快,测试表明, fastjson 具有极快的性能,超
越其他的 Java Json parser。包括自称最快的 JackJson;功能强大,完全支持
Java
Bean、集合、 Map、 日期、 Enum,支持范型,支持自省;无依赖。
下载路径:https://github.com/alibaba/fastjson/releases/tag/1.2.13
Fastjson 是一个 Java 语言编写的高性能功能完善的 JSON 库。 fastjson 采
用独创的算法,将 parse 的速度提升到极致,超过所有 json 库,包括曾经号称
最快的 JackJson。并且还超越了 google 的二进制协议 protocol buf。
Fastjson 完
全支持 http://json.org 的标准,
也是官方网站收录的参考实现之一。支持各种
JDK 类型。包括基本类型、 JavaBean、 Collection、 Map、
Enum、泛型等。支持 JDK5、 JDK 6、 Android、阿里云手机等环境。
1) 转为 json 字符串


String jsonString = JSON.toJSONString(object);


2) 解析成对象


1). JavaBean : Person person = JSON.parseObject(jsonString, Person.class);
2). List : List listPerson =JSON.parseArray(jsonString, Person.class);
3). List:List listString = JSON.parseArray(jsonString, String.class);
4). List<Map> List<Map> listMap = JSON.parseObject(jsonString, **new
**TypeReference<List<Map>>(){});


package com.shsxt.test;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.Test;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.shsxt.model.User;
public class FastJsonTest {
    /**
     * 将java对象转换成json格式的字符串
     */
    @Test
    public void testJavaToJson() {
        
        // JavaBean对象
        User user = new User(1, "zhangsan", "123456", 18, "上海");
        String json1 = JSON.toJSONString(user);
        System.out.println(json1);
        
        
        // List集合
        List<String> list = new ArrayList<String>();
        list.add("zhangsan");
        list.add("lisi");
        list.add("wangwu");
        String json2 = JSON.toJSONString(list);
        System.out.println(json2);
        
        // JavaBean List
        List<User> userList = new ArrayList<>();
        User user2 = new User(2, "lisi", "123124", 19, "北京");
        User user3 = new User(3, "wangwu", "111111", 20, "杭州");
        userList.add(user);
        userList.add(user2);
        userList.add(user3);
        String json3 = JSON.toJSONString(userList);
        System.out.println(json3);
        
        
        // Map
        Map<String, Object> map = new HashMap<>();
        map.put("name","zhansgan");
        map.put("sex",true);
        map.put("user", user);
        map.put("userList", userList);
        String json4 = JSON.toJSONString(map);
        System.out.println(json4);
        
        
        Map<String, Object> map2 = new HashMap<>();
        map2.put("user1", user);
        map2.put("user2", user2);
        map2.put("user3", user3);
        String json5 = JSON.toJSONString(map2);
        System.out.println(json5);
        
        
        List<Map<String,String>> listMap = new ArrayList<>();
        Map<String, String> m1 = new HashMap<>();
        m1.put("user1", "aa");
        m1.put("user2", "bb");
        m1.put("user3", "cc");
        Map<String, String> m2 = new HashMap<>();
        m2.put("user4", "dd");
        m2.put("user5", "ee");
        m2.put("user6", "ff");
        listMap.add(m1);
        listMap.add(m2);
        String json6 = JSON.toJSONString(listMap);
        System.out.println(json6);
        
    }
    
    
    /**
     * 将json字符串转换成java对象
     */
    @Test
    public void testJsonTtoJava() {
        // 转JavaBean
        String json1 = "{\"userId\":1,\"userName\":\"zhangsan\",\"userPwd\":\"123456\",\"userAge\":18,\"address\":\"上海\"}";
        User user = JSON.parseObject(json1, User.class);
        System.out.println(user);
        
        // 转List
        String json2 = "[\"zhangsan\",\"lisi\",\"wangwu\"]";
        List<String> list = JSON.parseArray(json2,String.class);
        System.out.println(list);
        
        String json3 = "[{\"userId\":1,\"userName\":\"zhangsan\",\"userPwd\":\"123456\",\"userAge\":18,\"address\":\"上海\"},{\"userId\":2,\"userName\":\"lisi\",\"userPwd\":\"123124\",\"userAge\":19,\"address\":\"北京\"},{\"userId\":3,\"userName\":\"wangwu\",\"userPwd\":\"111111\",\"userAge\":20,\"address\":\"杭州\"}]";
        List<User> userList = JSON.parseArray(json3,User.class);    
        System.out.println(userList);
        
        String json4 = "[{\"user1\":\"aa\",\"user2\":\"bb\",\"user3\":\"cc\"},{\"user4\":\"dd\",\"user5\":\"ee\",\"user6\":\"ff\"}]";
        List<Map<String,String>> listMap =  JSON.parseObject(json4, new TypeReference<List<Map<String,String>>>(){});
        System.out.println(listMap);
        
        
        
        
    }
}

转载请注明:Python量化投资 » json-14

喜欢 (0)or分享 (0)