从 jsonpath 和 xpath 到 SPL

Posted 大数据梦想家

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了从 jsonpath 和 xpath 到 SPL相关的知识，希望对你有一定的参考价值。

        XML和Json不仅是结构化文本，而且擅长表示多层数据，可承载足够通用和足够丰富的信息，因此常被用于各种数据交换和信息传递事务，比如WebService/Restful，微服务等。但多层数据要比传统的二维表结构复杂，取数后再处理的难度也大。

        早期，没有专业的json/XML的后处理技术，JAVA开发者通常要采取硬写代码或入库再算的方式。硬编码计算能力差，代码量大，开发效率很低。入库虽然解决了部分计算能力，但步骤多，延迟大，额外制造了JAVA与数据库的紧耦合，架构性很差，而且数据库只擅长计算二维表，处理多层结构化数据的能力并不强。后来，专业的json/XML后处理技术开始出现，才使Java中做这些运算处理的效率有了较大的提升，JsonPath/XPath是其中的优秀者。

JsonPath和XPath具有突破性的计算能力

        XPath是广泛使用的XML处理语言，内置于XOM/Xerces-J/Jdom/Dom4J等函数库。JsonPath仿照XPath的语法，实现了类似的功能，且有自己的函数库，目前是广泛使用的Json处理语言。比起以前硬编码的方式，XPath/JsonPath代码简短得多，具有突破性的计算能力。

        比如，用arronlong HTTP函数库从WebService取XML字符串，使用Dom4J函数库将XML字符串解析为Document类型，使用Dom4J内置的XPath语法进行条件查询：

String path= "http://.../emp_orders.xml";
String XMLStr= com.arronlong.httpclientutil.HttpClientUtil.get(com.arronlong.httpclientutil.common.HttpConfig.custom().url(path));
Document doc = DocumentHelper.parseText(XMLStr);
List<Node> list=doc.selectNodes("/xml/row/Orders[Amount>1000 and Amount<=3000 and contains(Client,'bro')]")

        类似地，用JsonPath进行条件查询：

String path= "http://.../emp_orders.json";
String JsonStr= com.arronlong.httpclientutil.HttpClientUtil.get(com.arronlong.httpclientutil.common.HttpConfig.custom().url(path));
Object document = Configuration.defaultConfiguration().jsonProvider().parse(JsonStr);
ArrayList l=JsonPath.read(document, "$[*].Orders[?(@.Amount>1000 && @.Amount<2000 && @.Client =~ /.*?business.*?/i )]");

        JsonPath与XPath用法类似，语法相通，计算能力差别不大，下面以JsonPath为主进行说明。JsonPath/XPath对条件查询的支持比较完整，包括关系运算符，如大于、小于等于；逻辑运算符，如与、或、非；字符串正则表达式，如~ /.?business.?/i；字符串函数，如模糊匹配contains。此外，JsonPath/XPath还支持在条件查询中使用数学运算符（函数），如+ - *、div；位置函数，如position、last；日期函数，如year-from-date、timezone-from-time。

        需要特别说明的是，JsonPath/XPath可以灵活表达条件查询的层级范围，包括绝对位置、相对位置、父节点、子节点、属性、元素等，这是多层数据处理语言有别于二维数据处理语言（SQL）之处，如代码中的$[*].Orders和/xml/row/Orders。

        除了条件查询，JsonPath/XPath还支持聚合计算，比如用JsonPath求和：

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

        JsonPath/XPath还支持平均、最大、最小、计数等聚合函数。

        从这些例子可以看出来，JsonPath/XPath的语法直观易懂，可以用较短的代码实现条件查询和聚合计算，可以方便地访问多层结构，比硬编码方便多了。

JsonPath和XPath计算能力仍然不足

        比起直接用Java编码，JsonPath和XPath的计算能力的确是突破性的，但要进行日常计算甚至是基础计算，JsonPath和XPath的能力是严重不足的，远不如SQL。事实上，JsonPath/XPath只支持条件查询和聚合这两种最基本的计算，其他计算都要用复杂的编码辅助完成。

        比如，用JsonPath进行分组汇总：

ArrayList orders=JsonPath.read(document, "$[*].Orders[*]");
Comparator<HashMap> comparator = new Comparator<HashMap>() 
    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<HashMap> result=new ArrayList<HashMap>();
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");

        JsonPath/XPath不支持分组汇总，只能自行编码完成大部分计算，这就要求程序员控制所有细节，代码冗长且容易出错。如果换一个分组字段或汇总字段，则要修改多处代码，如果对多个字段分组或汇总，代码还需大量修改，很难写出通用代码。

        JsonPath/XPath的计算能力严重不足，不支持大部分基础计算，除了分组汇总，还包括：重命名、排序、去重、关联计算、集合计算、笛卡尔积、归并计算、窗口函数、有序计算等。JsonPath/XPath也不支持将大计算目标分解为基础计算的机制，比如子查询、多步骤计算等，因此难以进行较复杂的计算。

        除了计算能力之外，Jsonpath/XPath还有个问题，就是没有自己的HTTP接口，必须自行编码或利用第三方HTTP函数库，比如JourWon、Arronlong，前面的例子就使用了Arronlong函数库。除了基础的HTTP之外，MongoDB或elasticSearch也可以返回多层数据，每种数据源的接口协议都不同，Jsonpath/XPath没有提供相关的接口，只能自己写或再引入第三方类库，这导致架构复杂、不稳定因素增大、开发效率降低。

        JsonPath/XPath的计算能力不足，导致开发效率低下。要想提高开发效率，必须使用计算能力足够的json/XML处理技术。

         SPL是更优的选择。

SPL具有足够的计算能力

        esProc SPL是JVM下开源的结构化数据/多层数据处理语言，内置专业的多层数据对象，提供了丰富的计算函数、字符串函数、日期函数，具有不亚于SQL的计算能力，可以提高WebService/Restful后处理的开发效率。

        SPL内置专业的多层结构化数据对象，为计算功能提供了有力的底层支撑

        比如，从文件读取XML字符串，解析为SPL序表：

A
1=file(“d:\\xml\\emp_orders.xml”).read()
2=xml(A1,“xml/row”)

        点击A2格可以看到多层序表的结构，其中，EId、State等字段存储简单数据类型，Orders字段存储记录集合（二维表）。点击Orders中的某一行，可以展开观察数据：

        SPL序表是专业的数据对象，可以表示结构任意复杂的多层数据，下面再看一个例子：


        序表的专业性还体现在，可以表示任意来源的二维或多层数据，包括但不限于XML\\Json，文件\\网络服务。比如，从文件读取Json字符串（与前面的XML同构），解析为SPL序表：

A
1=file(“d:\\xml\\emp_orders.json”).read()
2=json(A1)

        这里的序表和前面来自XML的序表没有区别，后续的计算代码完全一样，下面以Json为主进行说明。

        SPL内置丰富的计算函数，基础计算一句完成

        比如，同样对多层Json进行条件查询:

A
2…//省略取数解析
3=A2.conj(Orders)
4=A3.select(Amount>1000 && Amount<=2000 && like@c(Client,“business”))

        可以看到，SPL对条件查询的支持很完整，覆盖了JsonPath/XPath的功能，包括关系运算符、逻辑运算符、正则表达式和字符串函数，如模糊匹配like。此外，SPL还支持在条件查询中使用数学运算符（函数）、位置函数、日期函数。SPL可以灵活地访问不同层级，且代码更简单，如代码中的A2.conj(Orders)。

        SPL实现各类聚合计算也很简单，比如求和：=A3.sum(Amount)

        SPL支持丰富的基础计算，具有不亚于SQL的计算能力，比如JsonPath/XPath必须硬编码实现的分组汇总，SPL一句就行：

=A2.conj(Orders).groups(Client;sum(Amount))

更多例子：

AB
1….
3=A2.groups(State,Gender;avg(Salary),count(1))多字段分组汇总
4=A1.new(Name,Gender,Dept,Orders.OrderID,Orders.Client,Orders.Client,Orders.SellerId,Orders.Amount,Orders.OrderDate)关联
5=A1.sort(Salary)排序
6=A1.id(State)去重
7=A2.top(-3;Amount)topN
8=A2.groups(Client;top(3,Amount))组内TopN（窗口函数）

        SPL提供了大量日期和字符串函数，开发效率更高

        SPL支持大量日期函数和字符串函数，在数量和功能上远远超过JsonPath/XPath甚至SQL，同样的运算代码量更短。比如：

        时间类函数，日期增减：elapse(“2020-02-27”,5) //返回2020-03-03

        星期几：day@w(“2020-02-27”) //返回5，即星期4

        N个工作日之后的日期：workday(date(“2022-01-01”),25) //返回2022-02-04

        字符串类函数，判断是否全为数字：isdigit(“12345”) //返回true

        取子串前面的字符串：substr@l(“abCDcdef”,“cd”) //返回abCD

        按竖线拆成字符串数组：“aa|bb|cc”.split(“|”) //返回[“aa”,“bb”,“cc”]

        SPL还支持年份增减、求年中第几天、求季度、按正则表达式拆分字符串、拆出SQL的where或select部分、拆出单词、按标记拆html等功能。

SPL支持更优的应用架构

        SPL支持脚本外置和热切换，可用一致的方法计算多种数据源，有助于实现更优的应用架构。

        SPL提供了JDBC接口，支持脚本外置和热切换

        比如，将前面的SPL代码存为脚本文件，在JAVA中以存储过程的形式调用文件名：

Class.forName("com.esproc.jdbc.InternalDriver");
Connection connection =DriverManager.getConnection("jdbc:esproc:local://");
Statement statement = connection.createStatement();
ResultSet result = statement.executeQuery("call groupBy()");

        SPL脚本文件外置于JAVA，使计算代码和应用程序分离，可有效降低系统耦合性。

        SPL是解释型语言，修改后不必重启JAVA应用就可以直接执行，从而实现代码热切换，可保障系统稳定，降低维护难度。

        SPL支持多种数据源，可用一致的方法计算多层数据

        除了文件，SPL也支持来自WebSerivce和Restful的多层文件。比如，从WebService读取多层XML，进行条件查询:

A
1=ws_client(“http://127.0.0.1:6868/ws/RQWebService.asmx?wsdl”)
2=ws_call(A1,“RQWebService”:“RQWebServiceSoap”:“getEmp_orders”)
3=A2.conj(Orders)
4=A3.select(Amount>1000 && Amount<=2000 && like@c(Client,“business”))

        类似地，从Restful取多层Json，进行同样的条件查询：

A
1=httpfile(“http://127.0.0.1:6868/restful/emp_orders”).read()
2=json(A1)
3=A2.conj(Orders)
4=A3.select(Amount>1000 && Amount<=2000 && like@c(Client,“business”))

        除了WebService和Restful，很多特殊数据源也是多层数据，常见的比如MongoDB、ElasticSearch、SalesForce。SPL支持多种数据源，可直接从这些数据源取数并计算。

        比如，从MongoDB取多层Json，进行条件查询：

A
1=mongo_open(“mongodb://127.0.0.1:27017/mongo”)
2=mongo_shell@x(A1,“data.find()”)
3=A2.conj(Orders)
4=A3.select(Amount>1000 && Amount<=2000 && like@c(Client,“business”))

        除了多层数据，SPL也支持数据库，txt\\csv\\xls等文件， Hadoop、redis、Kafka、Cassandra等NoSQL。

        虽然数据源不同，但在SPL中的数据类型都是序表，因此可以用一致的方法计算多层数据。一致的计算代码使SPL具有高度的可移植性。

SPL计算能力强大，可简化复杂的业务逻辑

        SPL内置更方便的函数语法，适合计算结构复杂的多层数据，可简化复杂的业务逻辑，计算能力超过SQL。

        SPL内置更方便的函数语法，提供了强大的计算能力

        SPL提供了特有的函数选项语法，功能相似的函数可以共用一个函数名，只用函数选项区分差别。比如select函数的基本功能是过滤，如果只过滤出符合条件的第1条记录，可使用选项@1：

Orders.select@1(Amount&gt;1000)

        数据量较大时，用并行计算提高性能，可使用选项@m：

Orders.select@m(Amount&gt;1000)

对排序过的数据，用二分法进行快速过滤，可用@b：

Orders.select@b(Amount&gt;1000)

函数选项还可以组合搭配，比如：

Orders.select@1b(Amount&gt;1000)

        结构化运算函数的参数常常很复杂，比如SQL就需要用各种关键字把一条语句的参数分隔成多个组，但这会动用很多关键字，也使语句结构不统一。

        SPL支持层次参数，通过分号、逗号、冒号自高而低将参数分为三层，用通用的方式简化复杂参数的表达：

join(Orders:o,SellerId ; Employees:e,EId)

        SPL表达能力强，适合计算结构复杂的多层数据

        比如：Restful返回多层Json，包含多个子文档，结构较复杂，部分数据如下：

[
 
 "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…
2=A1(1).runners
3=A2.groups(trainer.trainerId; ownerColours.array().count():times)

        SPL计算能力强，可简化复杂的业务逻辑

        SPL支持分步计算、有序计算、分组后计算等逻辑较复杂的计算，很多SQL/存储过程难以实现的计算，用SPL解决起来就很轻松。比如，找出销售额累计占到一半的前n个大客户，并按销售额从大到小排序：

AB
1…/取数据
2=A1.sort(amount:-1)/销售额逆序排序
3=A2.cumulate(amount)/计算累计序列
4=A3.m(-1)/2/最后的累计即总额
5=A3.pselect(~>=A4)/超过一半的位置
6=A2(to(A5))/按位置取值

        从编码到JsonPath/XPath，json/XML的计算处理技术从无到有。从JsonPath/XPath到SPL，多层数据的计算能力由弱到强。SPL内置专业的数据对象、丰富的计算函数、字符串函数、日期函数，具有足够的计算能力。SPL支持脚本外置和热切换，可用一致的方法计算多种数据源，有助于实现更优的应用架构。SPL内置更方便的函数语法，适合计算结构复杂的多层数据，可简化复杂的业务逻辑。

SPL资料

欢迎对SPL有兴趣的加小助手（VX号：SPL-helper），进SPL技术交流群

以上是关于从 jsonpath 和 xpath 到 SPL的主要内容，如果未能解决你的问题，请参考以下文章

从 jsonpath 和 xpath 到 SPL

从 jsonpath 和 xpath 到 SPL

SPL - 一篇带你读懂从 Jsonpath 和 Xpath 到 SPL

正则表达式、xpath、BeautifulSoup和JSONPath的区别？

为啥 JSONPath 不支持父级？

超好用的JSON解析工具—JSONPath