FastJson使用示例

一，几个基本概念

①JSONArray 相当于 JAVA中的List<Object>，如：[‘a‘,‘b‘,‘c‘....]

②JSONObject相当于JAVA中的Map<String, Object>，如：{‘1‘:‘a‘, ‘2‘:‘b‘...}

③对于具有结构层次的JSON格式的数据，可以一层一层地来解析，可参考：这篇文章

二，当待解析的JSON文件很大时，可使用JSON Stream API，比如如下 List类型的数据在 F:\\test.txt 中，假设有上万条时...：

[
{"begin_int":"1677721","end_int":"1677747"},
{"begin_int":"1677747","end_int":"1677823"},
{"begin_int":"1677824","end_int":"1677926"},
{"begin_int":"1677926","end_int":"1678131"},
{"begin_int":"1678131","end_int":"1678540"},
{"begin_int":"1678540","end_int":"1679359"},
{"begin_int":"1690880","end_int":"1690905"},
{"begin_int":"1690905","end_int":"1690931"},
{"begin_int":"1690931","end_int":"1690956"},
{"begin_int":"1690956","end_int":"1690982"}
]

解析代码：将List中的每个元素当作一个Object

 1 import java.io.File;
 2 import java.io.FileNotFoundException;
 3 import java.io.FileReader;
 4
 5 import com.alibaba.fastjson.JSONReader;
 6
 7 public class ParseListByFastJsonStreamApi {
 8
 9     private static final String FILE_PATH = "F:\\test.txt";
10
11     public static void main(String[] args) throws FileNotFoundException{
12
13         JSONReader jsonReader = new JSONReader(new FileReader(new File(FILE_PATH)));
14
15         jsonReader.startArray();//---> [
16
17         while(jsonReader.hasNext())
18         {
19             String info = jsonReader.readObject().toString();//---> {"key":"value"}
20             System.out.println(info);
21         }
22         jsonReader.endArray();//---> ]
23         jsonReader.close();
24     }
25 }

或者用如下代码来解析：（将List中的每个元素（如： {"begin_int":"1690956","end_int":"1690982"}）再进一步分解 成 Key 和 Value 对）

 1     public static void parse() throws FileNotFoundException{
 2
 3             JSONReader jsonReader = new JSONReader(new FileReader(new File(FILE_PATH)));
 4
 5             jsonReader.startArray();//---> [
 6
 7             while(jsonReader.hasNext())
 8             {
 9                 jsonReader.startObject();
10                 while(jsonReader.hasNext()) {
11                     String objKey = jsonReader.readString();
12                     String objVal = jsonReader.readObject().toString();
13                     System.out.println("key: " + objKey + ", value: " + objVal);
14                 }
15                 jsonReader.endObject();
16             }
17             jsonReader.endArray();//---> ]
18             jsonReader.close();
19     }

上面的第9行 和 第10行解析代码也验证了：“JSONObject相当于JAVA中的Map<String, Object>”。

或者根据 JAVA Bean 类来解析：

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;

import com.alibaba.fastjson.JSONReader;

public class ParseListByFastJsonStreamApi {

    private static final String FILE_PATH = "F:\\test.txt";

    public static void main(String[] args) throws FileNotFoundException{

        JSONReader jsonReader = new JSONReader(new FileReader(new File(FILE_PATH)));

        jsonReader.startArray();//---> [

        while(jsonReader.hasNext())
        {
            BeginEndBean obj = jsonReader.readObject(BeginEndBean.class);//根据 java bean 来解析
            int begin_int = obj.getBegin_int();
            int end_int = obj.getEnd_int();
            System.out.println("begin_int:" + begin_int + ", end_int" + end_int);
        }
        jsonReader.endArray();//---> ]
        jsonReader.close();
    }
}

JAVA Bean类如下：

 1 public class BeginEndBean {
 2     private int begin_int;
 3     private int end_int;
 4     public int getBegin_int() {
 5         return begin_int;
 6     }
 7     public void setBegin_int(int begin_int) {
 8         this.begin_int = begin_int;
 9     }
10     public int getEnd_int() {
11         return end_int;
12     }
13     public void setEnd_int(int end_int) {
14         this.end_int = end_int;
15     }
16 }

三，当需要解析JSON数据格式有点复杂（非扁平的数据）时，比如下面的JSON格式数据：

{"key":"value","anotherKey":[
{"begin_int":"1677721","end_int":"1677747"},
{"begin_int":"1687552","end_int":"1690828"},
{"begin_int":"1690905","end_int":"1690931"},
{"begin_int":"1690931","end_int":"1690956"},
{"begin_int":"1690956","end_int":"1690982"}
],"thirdKey":{"subKey":"subVal","anotherSubKey":["1","2","3"]}}

"key" 对应的就是只有一个值，"anotherKey"对应的是一个列表，"thirdKey"对应的是一个对象（Map）。

解析代码如下：

第17行，将整个Json格式的文件当作一个JSONObject，该JSONObject里面有三个子元素，分别是："key" 、"anotherKey"、"thirdKey"。因此第18行 while(hasNext())找到每个key，然后 if-else 分别解析对应的值。比如第25行，解析到"anotherKey"时，它对应的是一个List，因此在第26行 startArray() 来读取

由于List中的每个元素其实又是一个个的：{"begin_int":"1687552","end_int":"1690828"}

因此，第29行又开启 startObject() 读取，而每个{"begin_int":"1687552","end_int":"1690828"} 又有两个 ”xxx_int“:"xxx"，因此第30行又有一个while(hasNext())循环。

总之，读取Map格式的数据对应的是JSONObject，读取的方法就是 jsonReader.readObject()

 1 import java.io.File;
 2 import java.io.FileNotFoundException;
 3 import java.io.FileReader;
 4 import com.alibaba.fastjson.JSONReader;
 5
 6 public class ParseListByFastJsonStreamApi {
 7
 8     private static final String FILE_PATH = "F:\\test.txt";
 9
10     public static void main(String[] args) throws FileNotFoundException {
11         parseData();
12     }
13
14     public static void parseData() throws FileNotFoundException {
15         JSONReader jsonReader = new JSONReader(new FileReader(new File(FILE_PATH)));
16
17         jsonReader.startObject();//将整个json文件当作 Map<String,Object> 对象来解析 {,}
18         while(jsonReader.hasNext()) {
19             String key = jsonReader.readString();
20             if(key.equals("key"))//"key"对应的Object只有一个
21             {
22                 Object obj = jsonReader.readObject();//
23                 String val = obj.toString();
24                 System.out.println("obj: " + obj + ", value: " + val);
25             }else if(key.equals("anotherKey")) {//"anotherKey"对应的是一个List对象
26                 jsonReader.startArray();//---> [  开启读List对象
27                 while(jsonReader.hasNext()) {
28
29                     jsonReader.startObject();
30                     while(jsonReader.hasNext()) {
31                         String objKey = jsonReader.readString();
32                         String objVal = jsonReader.readObject().toString();
33                         System.out.println("objKey: " + objKey + ", objVal: " + objVal);
34                     }
35                     jsonReader.endObject();
36                 }
37                 jsonReader.endArray();//---> ]
38             }else if(key.equals("thirdKey")) {
39                 jsonReader.startObject();//{"subKey":"subVal","anotherSubKey":["1","2","3"]}
40                 while(jsonReader.hasNext()) {
41                     String sub_key = jsonReader.readString();
42                     Object third_obj = jsonReader.readObject();
43                     String subVal = third_obj.toString();
44                     System.out.println("sub_key: " + sub_key + ", subVal: " + subVal);
45                 }
46                 jsonReader.endObject();
47             }
48         }
49         jsonReader.endObject();
50         jsonReader.close();
51     }
52 }

也可以借助JAVA Bean 来解析 anotherKey 对应的 List 对象。代码如下：

 1 public class ParseListByFastJsonStreamApi {
 2
 3     private static final String FILE_PATH = "F:\\test.txt";
 4
 5     public static void main(String[] args) throws FileNotFoundException {
 6         parseData();
 7     }
 8
 9     public static void parseData() throws FileNotFoundException {
10         JSONReader jsonReader = new JSONReader(new FileReader(new File(FILE_PATH)));
11
12         jsonReader.startObject();//将整个json文件当作 Map<String,Object> 对象来解析 {,}
13         while(jsonReader.hasNext()) {
14             String key = jsonReader.readString();
15             if(key.equals("key"))//"key"对应的Object只有一个
16             {
17                 Object obj = jsonReader.readObject();//
18                 String val = obj.toString();
19                 System.out.println("obj: " + obj + ", value: " + val);
20             }else if(key.equals("anotherKey")) {//"anotherKey"对应的是一个List对象
21                 jsonReader.startArray();//---> [  开启读List对象
22                 while(jsonReader.hasNext()) {
23                     BeginEndBean objBean = jsonReader.readObject(BeginEndBean.class);
24                     int begin_int = objBean.getBegin_int();
25                     int end_int = objBean.getEnd_int();
26                     System.out.println("begin_int: " + begin_int + ", " + end_int);
27                 }
28                 jsonReader.endArray();//---> ]
29             }else if(key.equals("thirdKey")) {
30                 jsonReader.startObject();//{"subKey":"subVal","anotherSubKey":["1","2","3"]}
31                 while(jsonReader.hasNext()) {
32                     String sub_key = jsonReader.readString();
33                     Object third_obj = jsonReader.readObject();
34                     String subVal = third_obj.toString();
35                     System.out.println("sub_key: " + sub_key + ", subVal: " + subVal);
36                 }
37                 jsonReader.endObject();
38             }
39         }
40         jsonReader.endObject();
41         jsonReader.close();
42     }
43 }

两种方法的对比如下：

 1 else if(key.equals("anotherKey")) {//"anotherKey"对应的是一个List对象
 2                 jsonReader.startArray();//---> [  开启读List对象
 3                 while(jsonReader.hasNext()) {
 4                     BeginEndBean objBean = jsonReader.readObject(BeginEndBean.class);
 5                     int begin_int = objBean.getBegin_int();
 6                     int end_int = objBean.getEnd_int();
 7                     System.out.println("begin_int: " + begin_int + ", " + end_int);
 8                 }
 9                 jsonReader.endArray();//---> ]
10             }
11
12
13 ---------------------------------------------------------------------------
14
15 else if(key.equals("anotherKey")) {//"anotherKey"对应的是一个List对象
16                 jsonReader.startArray();//---> [  开启读List对象
17                 while(jsonReader.hasNext()) {
18                     jsonReader.startObject();
19                     while(jsonReader.hasNext()) {
20                         String objKey = jsonReader.readString();
21                         String objVal = jsonReader.readObject().toString();
22                         System.out.println("objKey: " + objKey + ", objVal: " + objVal);
23                     }
24                     jsonReader.endObject();
25                 }
26                 jsonReader.endArray();//---> ]
27             }

FastJson 官方github资料

时间： 2024-10-09 21:44:27

FastJson使用示例的相关文章

使用FastJSON，将对象或数组和JSON串互转

Fastjson,是阿里巴巴提供的一个Java语言编写的高性能功能完善的JSON库.其开源的下载网址为:https://github.com/AlibabaTech/fastjson. 示例代码如下: [java] view plaincopy package test; import java.util.ArrayList; import java.util.List; import com.alibaba.fastjson.JSON; class User { private String 

JAVA开发血泪之路：一步步搭建spring框架

前言 作为一个服务端开发感觉一直挺排斥框架这种东西的,总觉得什么实现逻辑都帮你封装在里面了,你只需要配置这配置那个,出了问题也不知道怎么排查,之前即使写web程序也宁愿使用jetty这样的嵌入式的web server实现,自己写servlet,总感觉从main函数开始都在自己的掌控范围之内,但是这样的方式的确有点原始,也看到各种各样的开源系统使用spring实现web服务,虽然代码总是能够看明白,但是还是不晓得一步步是怎么搭建的,于是抽出一个周末折腾折腾,不搞不知道,原来这玩意能把一个不熟悉的用

json-smart 使用示例(推荐fastjson)

摘自:http://www.cnblogs.com/zhenjing/p/json-smart.html 地址:https://github.com/alibaba/fastjson ======================================================= json是一种通用的数据格式.相比与protocal buffer.thrift等数据格式,json具有可读性强(文本).天生具备良好的扩展性(随意增减字段)等优良特点,利用json作为通讯协议,开发效率

Fastjson示例代码

package com.wzc.test.Test; import java.text.SimpleDateFormat; import java.util.Date; import java.util.HashMap; import java.util.List; import java.util.Map; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONArray; import com.alibaba.fa

分布式服务框架 dubbo/dubbox 入门示例(转)

dubbo是一个分布式的服务架构,可直接用于生产环境作为SOA服务框架. 官网首页:http://dubbo.io/ ,官方用户指南 http://dubbo.io/User+Guide-zh.htm上面的几张图画得不错,完全可以当做SOA架构的学习资料 淘宝将这个项目开源出来以后,得到了不少同行的支持,包括: 当当网的扩展版本dubbox :https://github.com/dangdangdotcom/dubbox 京东的扩展版本jd-hydra: http://www.oschina.

Android fastjson

Fastjson介绍 Fastjson是一个Java语言编写的JSON处理器. 1.遵循http://json.org标准,为其官方网站收录的参考实现之一. 2.功能qiang打,支持JDK的各种类型,包括基本的JavaBean.Collection.Map.Date.Enum.泛型. 3.无依赖,不需要例外额外的jar,能够直接跑在JDK上. 4.开源,使用Apache License 2.0协议开源.http://code.alibabatech.com/wiki/display/FastJ

Java Socket长连接示例代码

SocketListenerPusher.java代码如下: Java代码   import java.io.IOException; import java.net.InetSocketAddress; import java.net.ServerSocket; import java.net.Socket; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import ja

fastjson对Date的处理

对日期的序列化: 一种方法是通过注解 Java代码   @JSONField (format="yyyy-MM-dd HH:mm:ss") public Date birthday; 另一种是通过SerializeConfig: Java代码   private static SerializeConfig mapping = new SerializeConfig(); private static String dateFormat; static { dateFormat = &

fastjson的JSONArray和JSONObject

在做JSON反序列化的时候,我们可能经常传递一个class对象来获取对象的示例.但有的时候,可能并不存在这样的class对象: 模板类.并不能直接获取模板类的对象.比如class A<T> {},使用A<Integer>.class却会报错.一个解决办法就是创建一个新类class EA extends A<Integer>,这样使用EA.class就是可以的了.但这样增加很多类. 需要序列化的对象内部含有基类引用成员,它引用到一个派生类.反序列化的时候得不到派生类的信息