从 JsonPath 到 SPL

JSON的多层结构可存储丰富的信息,再加上体积小传输效率高,因此被广泛应用于微服务、程序间通讯、配置文件等场景。但多层结构比二维结构格式复杂,计算起来难度很大,这就对JSON类库提出了较高的要求。其中,Gson\Jackson等类库不支持JSON计算语言,只提供了将JSON串解析为JAVA\C#对象的函数。这些类库没有计算能力,即使实现最简单的条件查询,也要编写大量代码,开发效率低且实用性差。

好消息是,JsonPath出现了。

与前面提到的类库不同,JsonPath仿照XPath语法,提供了原始的JSON计算语言,可以用表达式查询出符合条件的节点,并支持一些聚合计算。下面试举几例。

文件data.json存储员工记录以及员工的订单,部分数据如下:

[  {"EId":2,"State":"NewYork  ","Dept":"Finance","Name":"Ashley","Gender":"F",
"Salary":11000,"Birthday":"1980-07-19",
"Orders":[]
},
{"EId":3,"State":"New   Mexico","Dept":"Sales","Name":"Rachel","Gender":"F",
"Salary":9000,"Birthday":"1970-12-17",
"Orders":[
{"OrderID":32,"Client":"JFS","SellerId":3,"Amount":468.0,"OrderDate":"2009-08-13"},
…
{"OrderID":99,"Client":"RA","SellerId":3,"Amount":1731.2,"OrderDate":"2009-11-05"}
]
},
…
]

条件查询:找到员工Rachel的所有订单。JsonPath代码如下:

File file = new File("D:\\json\\data.json");
Long fileLength = file.length();
byte[] fileContent = new byte[fileLength.intValue()];
FileInputStream in = new FileInputStream(file);
in.read(fileContent);
in.close();
String JsonStr= new String(fileContent, "UTF-8")
Object document = Configuration.defaultConfiguration().jsonProvider().parse(JsonStr);
ArrayList l=JsonPath.read(document,   "$[?(@.Name=='Rachel')].Orders");

上面代码先从文件读入字符串,再转为JSON对象,最后进行查询。具体的查询表达式是 $[?(@.Name=='Rachel')].Orders,其中$代表根节点,即员工记录(含订单字段),Orders代表下层的订单记录(即订单字段),上下层之间用点号隔开。每层节点后面可跟随查询条件,形如[?(…)],具体用法参考官网。

组合查询:找出所有价格在1000-2000,且客户名包含business字样的订单。关键代码如下:

……//省去JSON对象生成过程
l=JsonPath.read(document,   "$[*].Orders[?((@.Amount>1000 && @.Amount<2000) &&   @.Client =~ /.*?business.*?/i )]");

代码中的(@.Amount>1000 && @.Amount<2000)是区间查询条件,@.Client =~ /.*?business.*?/i是正则表达式的模糊查询条件,&&是逻辑运算符“与”(|| 是“或”)。

聚合计算:统计所有订单的总金额。关键代码如下:

……
Double   d=JsonPath.read(document, "$.sum($[*].Orders[*].Amount)");

代码中的sum是求和函数,类似的函数还有平均、max、min、计数。

从这些例子可以看出来,JsonPath的语法直观易懂,可以用点号方便地访问多层结构,可以用较短的代码实现条件查询,还能进行简单的聚合计算。Gson\JacksonJsonPath实现了计算能力从无到有的突破,这要归功于JSON计算语言。

 

有不表示强。实际上,JsonPath的JSON计算语言还比较原始,计算能力很弱。JsonPath只支持查询和聚合这两种最简单的计算,不支持其他大多数基础计算,离任意和自由的计算更是遥远。要实现大多数基础计算,JsonPath仍然要硬编码实现。

分组汇总为例:对所有订单按客户分组,统计各组的订单金额。关键代码如下:

……
ArrayList orders=JsonPath.read(document,   "$[*].Orders[*]");
Comparator comparator = new   Comparator() {
    public int   compare(HashMap record1, HashMap record2) {
        if   (!record1.get("Client").equals(record2.get("Client"))) {
             return   ((String)record1.get("Client")).compareTo((String)record2.get("Client"));
        } else {
              return   ((Integer)record1.get("OrderID")).compareTo((Integer)record2.get("OrderID"));
        }
    }
};
Collections.sort(orders, comparator);
ArrayList result=new   ArrayList();
HashMap currentGroup=(HashMap)orders.get(0);
double sumValue=(double) currentGroup.get("Amount");
for(int i = 1;i < orders.size(); i ++){
    HashMap   thisRecord=(HashMap)orders.get(i);
      if(thisRecord.get("Client").equals(currentGroup.get("Client"))){
          sumValue=sumValue+(double)thisRecord.get("Amount");
    }else{
        HashMap   newGroup=new HashMap();
          newGroup.put(currentGroup.get("Client"),sumValue);
          result.add(newGroup);
        currentGroup=thisRecord;
          sumValue=(double) currentGroup.get("Amount");
    }
}
System.out.println(result);

上述代码先用JsonPath取出订单列表,再将订单列表按Client排序,取出第1条作为当前组的初值,然后依次循环剩余的订单。如果当前订单与当前组相比Client不变,则将当前订单的Amount累加到当前组;如果Client改变,则说明当前组已汇总完成。

JsonPath的计算能力很弱,不支持分组汇总,只能硬编码完成大部分计算,这就要求程序员控制所有细节,代码冗长且容易出错。如果换一个分组字段或汇总字段,则要修改多处代码,如果对多个字段分组或汇总,代码还需大量修改,这就很难写出通用代码。除了分组汇总,JsonPath不支持的基础计算还有:重命名、排序、去重、关联计算、集合计算、笛卡尔积、归并计算、窗口函数、有序计算等。JsonPath也不支持将大计算目标分解为基础计算的机制,比如子查询、多步骤计算等。实际上,对大多数计算来说,JsonPath都要硬编码完成。

除了计算能力之外,Jsonpath还有个问题,就是没有自己的数据源接口,即使最简单的文件JSON,也需要硬编码实现。而JSON一般来自http restful,特殊些的会来自MongoDB或elasticSearch,只有引入第三方类库或硬编码才能从这些接口取数,这导致架构复杂、不稳定因素增大、开发效率降低。

JsonPath的JSON计算能力很弱,本质是因为其计算语言过于原始。要想提高JSON计算能力,必须使用更专业的计算语言。

集算器 SPL是个更好的选择。

 

集算器 SPL是开源的结构化数据\半结构化数据计算语言,提供了丰富的类库和精炼的语法,可以用简短的代码实现所有的基础计算,可将大计算目标拆分为基础计算,支持多种数据源接口,同时提供JDBC集成接口。

同样的条件查询,SPL代码如下:

A
1 =json(file("d:\\json\\data.json").read())
2 =A1.select(Name=="Rachel").Orders

A1代码从文件读字符串,并转为序表。序表是通用的结构化\半结构化数据对象,JSON是半结构化数据的一种。A2中函数select查询出符合条件的员工记录,Orders表示记录的订单字段(订单列表),上下层之间用.号隔开。

同样的组合查询,SPL代码如下:

A
1 …. //省去JSON对象/序表生成过程
2 =A1.conj(Orders)
3 =A2.select((Amount>1000 &&   Amount<=2000) && like@c(Client,"*business*"))

A2合并所有员工的订单,A3进行条件查询,like函数用于模糊查询字符串,@c表示不区分大小写。这里用到了多步骤计算,代码逻辑更清晰,也可将A2A3合并为一句。

同样的聚合计算,SPL代码如下:

A
1 ….
2 =A1.conj(Orders).sum(Amount)

代码中的sum是求和函数,类似的函数还有avg\sum\min\count。

这段代码可在SPL的IDE中调试/执行,也可存为脚本文件(比如getSum.dfx),通过JDBC接口在JAVA中调用,具体代码如下:

package Test;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
public class test1 {
public static void main(String[]   args)throws Exception {
Class.forName("com.esproc.jdbc.InternalDriver");
Connection connection   =DriverManager.getConnection("jdbc:esproc:local://");
Statement statement =   connection.createStatement();
ResultSet result =   statement.executeQuery("call getSum()");
printResult(result);
if(connection != null)   connection.close();
}
…
}

上面的用法类似存储过程,其实SPL也支持类似SQL的用法,即无须脚本文件,直接将SPL代码嵌入JAVA,代码如下:

…
ResultSet result =   statement.executeQuery("=json(file(\"D:\\data\\data.json\").read()).conj(Orders).sum(Amount)");
…

 

SPL提供了丰富的库函数,支持各种基础计算,上面的查询和聚合只是其中一部分,更多基础计算如下:

A
1 ….
2 =A1.conj(Orders).groups(Client;sum(Amount)) 分组汇总
3 =A1.groups(State,Gender;avg(Salary),count(1)) 多字段分组汇总
45 =A1.new(Name,Gender,Dept,Orders.OrderID,Orders.Client,Orders.Client,Orders.SellerId,Orders.Amount,Orders.OrderDate) 关联
6 =A1.sort(Salary) 排序
7 =A1.id(State) 去重

 

SPL计算能力强,经常可以简化多层json的计算,比如:文件JSONstr.json的runners字段是子文档,子文档有3个字段:horseId、ownerColours、trainer,其中trainer含有下级字段trainerId ,ownerColours是逗号分割的数组。部分数据如下:

[
   {
      "race": {
            "raceId":"1.33.1141109.2",
            "meetingId":"1.33.1141109"
      },
      ...
      "numberOfRunners": 2,
      "runners": [
        {       "horseId":"1.00387464",
                "trainer": {
                    "trainerId":"1.00034060"
                },
            "ownerColours":"Maroon,pink,dark blue."
          },
          {     "horseId":"1.00373620",
                "trainer": {
                    "trainerId":"1.00010997"
                },
            "ownerColours":"Black,Maroon,green,pink."
          }
      ]
   },
...
]

现在要按 trainerId分组,统计每组中 ownerColours的成员个数,可用下面的SPL实现。

A
1 =json(file("/workspace/JSONstr.json").read())
2 =A1(1).runners
3 =A2.groups(trainer.trainerId; ownerColours.array().count():times)

SPL计算能力强,经常可以简化复杂的JSON计算。比如通过http restful可取得按时间排序的每日值班情况,部分数据如下:

[{"Date":"2018-03-01","name":"Emily"},
{"Date":"2018-03-02","name":"Emily"},
{"Date":"2018-03-04","name":"Emily"},
{"Date":"2018-03-04","name":"Johnson"},
{"Date":"2018-04-05","name":"Ashley"},
{"Date":"2018-03-06","name":"Emily"},
{"Date":"2018-03-07","name":"Emily"}
……]

一个人通常会持续值班几个工作日,之后再换人,现在要依次计算出每个人连续的值班情况,结果输出为二维表,部分结果如下:

name begin end
Emily 2018-03-01 2018-03-03
Johnson 2018-03-04 2018-03-04
Ashley 2018-03-05 2018-03-05
Emily 2018-03-06 2018-03-07

要获得上述结果,应先将数据按照name进行有序分组,即如果连续几条记录的name都相同,则这几条记录分为同一组,直到name发生变化。注意这种分组可能会使同一个员工分出多组数据,比如Emily。分组后,应按日期取各组的首尾两条,即所求的开始值班日期和结束值班日期。这里涉及有序分组、分组后计算(即窗口函数)、按位置取值等难度较高的计算,常见的计算语言写起来会很繁琐,改用SPL就简单多了。代码如下:

A
1 =json(httpfile("http://127.0.0.1:6868/api/getDuty").read())
2 =duty.group@o(name)
3 =A2.new(name,~.m(1).date:begin,~.m(-1).date:end)

除了较强的计算能力之外,SPL还提供了丰富的数据源接口,除了上面提到的文件、restful,还支持MongoDB、elsticSearch等,详情参考官网。

从Gson\Jackson到JsonPath,JSON计算语言从无到有,从JsonPath到SPL,JSON计算能力由弱到强,每一次质的飞跃,都驱动着开发效率的大幅提升。