JSONPath 解析 JSON 内容详解（翻译自 github）

 

Github ：https://github.com/json-path/JsonPath

http://www.ibloger.net/article/2329.html

JSONPath Online Evaluator：http://jsonpath.com

 

 

JsonPath 是一种简单的方法来提取给定JSON文档的部分内容。 JsonPath有许多编程语言，如Javascript，Python和PHP，Java。JsonPath 提供的 json 解析非常强大，它提供了类似正则表达式的语法，基本上可以满足所有你想要获得的 json 内容.

JsonPath 表达式总是引用 JSON 结构，其方式与XPath表达式解析XML文档的方式类似。JsonPath中的 “根成员对象” 总是被引用为$，不管它是对象还是数组。

JsonPath 可以使用 点 表示法：$.store.book[0].title
或者 括号 表示法：$['store']['book'][0]['title']

 

 

操作符

 

操作符 和 描述

操作符	描述
$	查询根元素。这将开始所有路径表达式
@	使用过滤谓词来处理当前节点。即过滤当前节点。
*	通配符。 任何可以使用名称和数字的地方都可以使用。
..	深层扫描。 任何可以使用名称的地方都可以使用
.	点，表示子节点。
['' (, '')]	括号 表示子项。
[ (, )]	数组索引 或 索引
[start:end]	数组切片操作。
[?()]	过滤表达式。 表达式的结果必须是一个 bool 值。

 

 

函数

 

函数可以在路径的末尾调用——函数的输入是路径表达式的输出。函数输出由函数本身决定。

函数	描述	输出
min()	提供数字数组的最小值	Double
max()	提供数字数组的最大值	Double
avg()	提供数字数组的平均值	Double
stddev()	提供数字数组的标准偏差值	Double
length()	提供数组的长度	Integer
sum()	提供数字数组的所有元素的和	Double

 

 

过滤器运算符

 

过滤器 是 用于筛选数组的逻辑表达式。一个典型的过滤器应该是 [?(@.age > 18)]，其中 @ 表示当前正在处理的项。可以使用逻辑运算符 && 和 || 创建更复杂的过滤器。字符串文字 必须用 单引号 或 双引号 括起来 ([?(@.color == 'blue')] or [?(@.color == "blue")])。

操作符	描述
==	左边得值 等于 右边的值 ( 注意：数字 1 不等于 字符串 '1' )
!=	不等于
<	小于
<=	小于等于
>	大于
>=	大于等于
=~	匹配正则表达式  [?(@.name =~ /foo.*?/i)]
in	左边 in 右边 [?(@.size in ['S', 'M'])]
nin	左边 not in 右边
subsetof	左边是右边的一个子字符串 [?(@.sizes subsetof ['S', 'M', 'L'])]
anyof	左边和右边相交 [?(@.sizes anyof ['M', 'L'])]
noneof	左边和右边不相交 [?(@.sizes noneof ['M', 'L'])]
size	（数组或字符串）长度
empty	（数组或字符串）为空

 

 

示例

 

示例 Json：

{
    "store": {
        "book": [
            {
                "category": "reference",
                "author": "Nigel Rees",
                "title": "Sayings of the Century",
                "price": 8.95
            },
            {
                "category": "fiction",
                "author": "Evelyn Waugh",
                "title": "Sword of Honour",
                "price": 12.99
            },
            {
                "category": "fiction",
                "author": "Herman Melville",
                "title": "Moby Dick",
                "isbn": "0-553-21311-3",
                "price": 8.99
            },
            {
                "category": "fiction",
                "author": "J. R. R. Tolkien",
                "title": "The Lord of the Rings",
                "isbn": "0-395-19395-8",
                "price": 22.99
            }
        ],
        "bicycle": {
            "color": "red",
            "price": 19.95
        }
    },
    "expensive": 10
}

JsonPath 表达式示例：

JsonPath ( 点击链接测试 )	结果
$.store.book[*].author	获取 Json 中 store下book下的所有author值
$..author	获取 Json 中 所有 author 的值。
$.store.*	获取 store 下所有东西（ book 和 bicycle ）
$.store..price	获取 store下以及所有子节点下的所有 price
$..book[2]	获取 book数组的第3个值
$..book[-2]	获取 book数组的倒数第二个值
$..book[0,1]	获取 book数组的第一、第二的值
$..book[:2]	获取 book数组从索引 0 (包括) 到 索引 2 (不包括) 的所有值
$..book[1:2]	获取 book数组从索引 1 (包括) 到 索引 2 (不包括) 的所有值
$..book[-2:]	获取 book数组从索引 -2 (包括) 到 结尾 的所有值
$..book[2:]	获取 book数组从索引 2 (包括) 到 结尾 的所有值
$..book[?(@.isbn)]	获取 所有节点以及子节点中 book 数组包含 isbn 的所有值
$.store.book[?(@.price < 10)]	获取 store下 book 数组中 price < 10 的所有值
$..book[?(@.price <= $['expensive'])]	获取 所有节点以及子节点下 book 数组中 price <= expensive 的所有值
$..book[?(@.author =~ /.*REES/i)]	获取所有匹配正则的 book （ 不区分大小写 ）
$..*	逐层列出 json 中 的所有值，层级由外到内
$..book.length()	book 数组的长度

 

 

阅读文档

 

使用 JsonPath 的最简单的最直接的方法是通过静态读取 API。

String json = "...";

List authors = JsonPath.read(json, "$.store.book[*].author");

如果你只想读取一次，那么上面的代码就可以了。如果你还想读取其他路径，现在上面不是很好的方法，因为他每次获取都需要再解析整个文档。所以，我们可以先解析整个文档，再选择调用路径。

String json = "...";
Object document = Configuration.defaultConfiguration().jsonProvider().parse(json);

String author0 = JsonPath.read(document, "$.store.book[0].author");
String author1 = JsonPath.read(document, "$.store.book[1].author");

JsonPath还提供流畅的API。 这也是最灵活的一个。

String json = "...";

ReadContext ctx = JsonPath.parse(json);

List authorsOfBooksWithISBN = ctx.read("$.store.book[?(@.isbn)].author");


List> expensiveBooks = JsonPath
                            .using(configuration)
                            .parse(json)
                            .read("$.store.book[?(@.price > 10)]", List.class);

 

何时返回

 

当在 java 中使用 JsonPath 时，重要的是要知道你在结果中期望什么类型。 JsonPath 将自动尝试将结果转换为调用者预期的类型。

//Will throw an java.lang.ClassCastException    
List list = JsonPath.parse(json).read("$.store.book[0].author")

//Works fine
String author = JsonPath.parse(json).read("$.store.book[0].author")

当评估路径时，你需要理解路径确定的概念。路径是不确定的，它包含

• .. ：深层扫描操作

• ?() ：表达式

• [, (, )] ：多个数组索引

不确定的路径总是返回一个列表（由当前的JsonProvider表示）。

默认情况下，MappingProvider SPI提供了一个简单的对象映射器。 这允许您指定所需的返回类型，MappingProvider将尝试执行映射。 在下面的示例中，演示了Long和Date之间的映射。

String json = "{\"date_as_long\" : 1411455611975}";

Date date = JsonPath.parse(json).read("$['date_as_long']", Date.class);

如果您将JsonPath配置为使用JacksonMappingProvider或GsonMappingProvider，您甚至可以将JsonPath输出直接映射到POJO中。

Book book = JsonPath.parse(json).read("$.store.book[0]", Book.class);

要获取完整的泛型类型信息，请使用TypeRef。

TypeRef> typeRef = new TypeRef>() {};

List titles = JsonPath.parse(JSON_DOCUMENT).read("$.store.book[*].title", typeRef);

 

谓词

 

在JsonPath中创建过滤器谓词有三种不同的方法。

 

内联谓词

内联谓词是路径中定义的谓词。

List> books =  JsonPath.parse(json)
                                     .read("$.store.book[?(@.price < 10)]");

你可以使用 && 和 || 结合多个谓词 [?(@.price < 10 && @.category == 'fiction')] , [?(@.category == 'reference' || @.price > 10)].

你也可以使用！否定一个谓词 [?(!(@.price < 10 && @.category == 'fiction'))].

 

过滤谓词

谓词可以使用Filter API构建，如下所示：

import static com.jayway.jsonpath.JsonPath.parse;
import static com.jayway.jsonpath.Criteria.where;
import static com.jayway.jsonpath.Filter.filter;
...
...

Filter cheapFictionFilter = filter(
   where("category").is("fiction").and("price").lte(10D)
);

List> books =  
   parse(json).read("$.store.book[?]", cheapFictionFilter);

注意占位符？ 为路径中的过滤器。 当提供多个过滤器时，它们按照占位符数量与提供的过滤器数量相匹配的顺序应用。 您可以在一个过滤器操作[？，？]中指定多个谓词占位符，这两个谓词都必须匹配。

过滤器也可以与“OR”和“AND”

Filter fooOrBar = filter(
   where("foo").exists(true)).or(where("bar").exists(true)
);
   
Filter fooAndBar = filter(
   where("foo").exists(true)).and(where("bar").exists(true)
);

 

自定义

第三个选择是实现你自己的谓词

Predicate booksWithISBN = new Predicate() {
    @Override
    public boolean apply(PredicateContext ctx) {
        return ctx.item(Map.class).containsKey("isbn");
    }
};

List> books = 
   reader.read("$.store.book[?].isbn", List.class, booksWithISBN);

 

Path vs Value

在 Goessner 实现中，JsonPath 可以返回 Path 或 Value。 值是默认值，上面所有示例返回。 如果你想让我们查询的元素的路径可以通过选项来实现。

Configuration conf = Configuration.builder()
   .options(Option.AS_PATH_LIST).build();

List pathList = using(conf).parse(json).read("$..author");

assertThat(pathList).containsExactly(
    "$['store']['book'][0]['author']",
    "$['store']['book'][1]['author']",
    "$['store']['book'][2]['author']",
    "$['store']['book'][3]['author']");

 

调整配置

 

选项创建配置时，有几个可以改变默认行为的选项标志。

DEFAULT_PATH_LEAF_TO_NULL

此选项使JsonPath对于缺少的叶子返回null。 考虑下面的json

[
   {
      "name" : "john",
      "gender" : "male"
   },
   {
      "name" : "ben"
   }
]

Configuration conf = Configuration.defaultConfiguration();

//Works fine
String gender0 = JsonPath.using(conf).parse(json).read("$[0]['gender']");
//PathNotFoundException thrown
String gender1 = JsonPath.using(conf).parse(json).read("$[1]['gender']");

Configuration conf2 = conf.addOptions(Option.DEFAULT_PATH_LEAF_TO_NULL);

//Works fine
String gender0 = JsonPath.using(conf2).parse(json).read("$[0]['gender']");
//Works fine (null is returned)
String gender1 = JsonPath.using(conf2).parse(json).read("$[1]['gender']");

 

ALWAYS_RETURN_LIST
This option configures JsonPath to return a list even when the path is definite.

Configuration conf = Configuration.defaultConfiguration();

//Works fine
List genders0 = JsonPath.using(conf).parse(json).read("$[0]['gender']");
//PathNotFoundException thrown
List genders1 = JsonPath.using(conf).parse(json).read("$[1]['gender']");

SUPPRESS_EXCEPTIONS
This option makes sure no exceptions are propagated from path evaluation. It follows these simple rules:

• If option ALWAYS_RETURN_LIST is present an empty list will be returned
• If option ALWAYS_RETURN_LIST is NOT present null returned

JsonProvider SPI

JsonPath is shipped with five different JsonProviders:

• JsonSmartJsonProvider (default)
• JacksonJsonProvider
• JacksonJsonNodeJsonProvider
• GsonJsonProvider
• JsonOrgJsonProvider

Changing the configuration defaults as demonstrated should only be done when your application is being initialized. Changes during runtime is strongly discouraged, especially in multi threaded applications.

Configuration.setDefaults(new Configuration.Defaults() {

    private final JsonProvider jsonProvider = new JacksonJsonProvider();
    private final MappingProvider mappingProvider = new JacksonMappingProvider();
      
    @Override
    public JsonProvider jsonProvider() {
        return jsonProvider;
    }

    @Override
    public MappingProvider mappingProvider() {
        return mappingProvider;
    }
    
    @Override
    public Set options() {
        return EnumSet.noneOf(Option.class);
    }
});

Note that the JacksonJsonProvider requires com.fasterxml.jackson.core:jackson-databind:2.4.5 and the GsonJsonProvider requires com.google.code.gson:gson:2.3.1 on your classpath.

 

Cache SPI

In JsonPath 2.1.0 a new Cache SPI was introduced. This allows API consumers to configure path caching in a way that suits their needs. The cache must be configured before it is accesses for the first time or a JsonPathException is thrown. JsonPath ships with two cache implementations

• com.jayway.jsonpath.spi.cache.LRUCache (default, thread safe)
• com.jayway.jsonpath.spi.cache.NOOPCache (no cache)

If you want to implement your own cache the API is simple.

CacheProvider.setCache(new Cache() {
    //Not thread safe simple cache
    private Map map = new HashMap();

    @Override
    public JsonPath get(String key) {
        return map.get(key);
    }

    @Override
    public void put(String key, JsonPath jsonPath) {
        map.put(key, jsonPath);
    }
});

 

 

Java 操作示例源码

 

示例 Json：

{
  "store": {
    "book": [
      {
        "category": "reference",
        "author": "Nigel Rees",
        "title": "Sayings of the Century",
        "price": 8.95
      },
      {
        "category": "fiction",
        "author": "Evelyn Waugh",
        "title": "Sword of Honour",
        "price": 12.99
      },
      {
        "category": "fiction",
        "author": "Herman Melville",
        "title": "Moby Dick",
        "isbn": "0-553-21311-3",
        "price": 8.99
      },
      {
        "category": "JavaWeb",
        "author": "X-rapido",
        "title": "Top-link",
        "isbn": "0-553-211231-3",
        "price": 32.68
      },
      {
        "category": "fiction",
        "author": "J. R. R. Tolkien",
        "title": "The Lord of the Rings",
        "isbn": "0-395-19395-8",
        "price": 22.99
      }
    ],
    "bicycle": {
      "color": "red",
      "price": 19.95
    }
  },
  "expensive": 10
}

java 示例：

import java.io.BufferedReader;
import java.io.FileReader;
import java.util.Iterator;
import java.util.List;
import com.jayway.jsonpath.JsonPath;

public class TestJsonPath {
	public static void main(String[] args) {
        String sjson = readtxt();
        print("--------------------------------------getJsonValue--------------------------------------");
        getJsonValue(sjson);
    }

    private static String readtxt() {
        StringBuilder sb = new StringBuilder();
        try {
            FileReader fr = new FileReader("D:/books.txt");
            BufferedReader bfd = new BufferedReader(fr);
            String s = "";
            while((s=bfd.readLine())!=null) {
                sb.append(s);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(sb.toString());
        return sb.toString();
    }
    
    private static void getJsonValue(String json) {
        //The authors of all books：获取json中store下book下的所有author值
        List authors1 = JsonPath.read(json, "$.store.book[*].author");
        
        //All authors：获取所有json中所有author的值
        List authors2 = JsonPath.read(json, "$..author");
        
        //All things, both books and bicycles 
        //authors3返回的是net.minidev.json.JSONArray：获取json中store下的所有value值，不包含key，如key有两个，book和bicycle
        List