目录
- JsonPath
- 1、概述
- 2、JsonPath语法
- 2.1、操作符
- 2.2、函数
- 2.3、过滤器
- 2.4、示例
- 3、基于Java的使用
- 3.1、使用方式
- 3.2、返回类型
- 3.3、JsonProvider
- 3.4、谓词
- 1、内联谓词
- 2)、过滤器谓词
- 3)、自定义谓词
- 4)、示例
- 3.5、使用函数
- 3.6、返回路径
- 3.7、添加/设置值
- 3.8、配置
- 1)、Options
- 2)、JsonProvider SPI
- 3)、Cache SPI
JsonPath
1、概述
JsonPath是用来解析多层嵌套的JSON数据。可以认为JsonPath就是JSON版本的XPath。它是一种信息抽取类库，是从JSON文档中抽取指定信息的工具。JsonPath对于JSON来说，就相当于XPath之于XML。
JsonPath在线解析：https://jsonpath.com/
2、JsonPath语法
2.1、操作符
| 语法 | 含义 |
|---|---|
$ | 表示根节点 |
@ | 当前节点 |
.<节点名称> | 获取子节点 |
[<节点名称1>(,<节点名称2>)] | 获取子节点，与点号不同，这里可以获取多个子节点 |
* | 匹配所有元素节点 |
.. | 获取子孙节点，无论嵌套多少层，都可以获取到 |
[<下标1>(,<下标2>)] | 表示一个或多个下标 |
[start:end:step] | 表示切片语法 |
[?(<表达式>)] | 过滤器表达式，表达式结果必须是布尔值 |
() | 支持表达式计算 |
2.2、函数
可以在JsonPath表达式执行后进行调用，其输入表达式的结果。
| 函数 | 描述 | 输出 |
|---|---|---|
min() | 提供数字数组的最小值 | Double |
max() | 提供数字数组的最大值 | Double |
avg() | 提供数字数据的平均值 | Double |
stddev() | 提供数字数组的标准偏差值 | Double |
length() | 提供数组的长度 | Integer |
sum() | 提供数字数组的和值 | Double |
keys() | 提供属性键（终端自键~的替代选择） | Set<E> |
concat(X) | 提供路径输出的合并版本，并添加一个新项目 | like input |
append(X) | 为 json 路径输出数组添加项目 | like input |
first() | 提供数组的第一个项目 | Depends on the array |
last() | 提供数组的最后一项 | Depends on the array |
index(X) | 提供索引数组的项： X，如果 X 为负数，则向后取值 | Depends on the array |
2.3、过滤器
过滤器是用于过滤数组的逻辑表达式，一个通常的表达式形如：[?(@.age > 18)]，可以通过逻辑表达式&&或||组合多个过滤器表达式，例如[?(@.price < 10 && @.category == ‘fiction’)]，字符串必须用单引号包围，例如[?(@.color == ‘blue’)]。
| 操作符 | 描述 |
|---|---|
== | 等于符号，但数字1不等于字符1（1 is not equal to ‘1’） |
!= | 不等于 |
< | 小于 |
<= | 小于等于 |
> | 大于等于 |
>= | 大于等于 |
=~ | 判断是否符合正则表达式，例如[?(@.name =~ /foo.*?/i)] |
in | 属于，例如[?(@.size in ['S', 'M'])] |
nin | 排除符号 |
size | 左侧（数组或字符串）的大小应与右侧一致 |
empty | 数组或字符串）应为空 |
subsetof | 左是右的子集 [?(@.sizes subsetof [‘S’, ‘M’, ‘L’])] |
anyof | 左与右有交集 [?(@.sizes anyof [‘M’, ‘L’])] |
noneof | 左边与右边没有交集 [?(@.sizes noneof [‘M’, ‘L’])] |
2.4、示例
{
"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 | Result |
|---|---|
$.store.book[*].author | 所有书籍的作者 |
$..author | 所有作者 |
$..book[2] | 第3本数 |
$..book[0,1] | 前2本数 |
$..book[1:3] | 切片操作，从索引 1（含）到索引 3（不含）的所有书籍 |
$..book[-1:] | 倒数第一本数 |
$..book[?(@.isbn)] | 所有有 ISBN 编号的书籍 |
$.store.book[?(@.price < 10)] | 价格低于10的所有数据 |
$..book.length | 书籍的数量 |
3、基于Java的使用
Jayway JsonPath则提供了Java版本的实现，方便开发者进行集成使用。
Maven依赖：
<!--Json Path-->
<dependency>
<groupId>com.jayway.jsonpath</groupId>
<artifactId>json-path</artifactId>
<version>2.7.0</version>
</dependency>
3.1、使用方式
使用 JsonPath 最简单直接的方法是通过静态读取 API。
public class Demo {
private String jsonStr = "{\n" +
" \"store\": {\n" +
" \"book\": [\n" +
" {\n" +
" \"category\": \"reference\",\n" +
" \"author\": \"Nigel Rees\",\n" +
" \"title\": \"Sayings of the Century\",\n" +
" \"price\": 8.95\n" +
" },\n" +
" {\n" +
" \"category\": \"fiction\",\n" +
" \"author\": \"Evelyn Waugh\",\n" +
" \"title\": \"Sword of Honour\",\n" +
" \"price\": 12.99\n" +
" },\n" +
" {\n" +
" \"category\": \"fiction\",\n" +
" \"author\": \"Herman Melville\",\n" +
" \"title\": \"Moby Dick\",\n" +
" \"isbn\": \"0-553-21311-3\",\n" +
" \"price\": 8.99\n" +
" },\n" +
" {\n" +
" \"category\": \"fiction\",\n" +
" \"author\": \"J. R. R. Tolkien\",\n" +
" \"title\": \"The Lord of the Rings\",\n" +
" \"isbn\": \"0-395-19395-8\",\n" +
" \"price\": 22.99\n" +
" }\n" +
" ],\n" +
" \"bicycle\": {\n" +
" \"color\": \"red\",\n" +
" \"price\": 19.95\n" +
" }\n" +
" },\n" +
" \"expensive\": 10\n" +
"}";
@Test
public void test1() {
List<String> authors = JsonPath.read(jsonStr, "$.store.book[*].author");
//["Nigel Rees","Evelyn Waugh","Herman Melville","J. R. R. Tolkien"]
System.out.println(authors);
}
}
如果你只读取一次，这没有问题。如果还需要读取其他路径，这就不是办法了，因为每次调用 JsonPath.read(…) 都会对文档进行解析。为了避免这个问题，可以先解析 json。
@Test
public void test2() {
final Object document = Configuration.defaultConfiguration().jsonProvider().parse(jsonStr);
String author0 = JsonPath.read(document, "$.store.book[0].author");
String author1 = JsonPath.read(document, "$.store.book[1].author");
//Nigel Rees
System.out.println(author0);
//Evelyn Waugh
System.out.println(author1);
}
JsonPath还提供了流畅的应用程序接口。这也是最灵活的一种：
@Test
public void test3() {
DocumentContext ctx = JsonPath.parse(jsonStr);
List<String> authorsOfBooksWithISBN = ctx.read("$.store.book[?(@.isbn)].author");
//["Herman Melville","J. R. R. Tolkien"]
System.out.println(authorsOfBooksWithISBN);
//[{"category":"fiction","author":"Evelyn Waugh","title":"Sword of Honour","price":12.99},
// {"category":"fiction","author":"J. R. R. Tolkien","title":"The Lord of the Rings","isbn":"0-395-19395-8","price":22.99}]
List<Map<String, Object>> expensiveBooks = JsonPath.using(Configuration.defaultConfiguration())
.parse(jsonStr)
.read("$.store.book[?(@.price > 10)]", List.class);
System.out.println(expensiveBooks);
}
3.2、返回类型
在 Java 中使用 JsonPath 时，了解结果的预期类型非常重要。JsonPath 会自动尝试将结果转换为调用者期望的类型。
//Nigel Rees
String author = JsonPath.parse(jsonStr).read("$.store.book[0].author");
//java.lang.ClassCastException: java.lang.String cannot be cast to java.util.List
List<String> list = JsonPath.parse(jsonStr).read("$.store.book[0].author");
在评估一条路径时，你需要了解一条路径何时是确定的这一概念。如果一条路径包含以下内容，那么它就是不确定的：
..：扫描操作符?(<expression>)：表达式[<number>, <number>(, <number)]：多个数组索引
无限路径总是返回一个列表（由当前 JsonProvider 表示）。
默认情况下，MappingProvider SPI 会提供一个简单对象映射器。这允许你指定想要的返回类型，而 MappingProvider 会尝试执行映射。下面的示例演示了 Long 和 Date 之间的映射。
String json = "{\"date_as_long\": 1411455611975}";
Date date = JsonPath.parse(json).read("$['date_as_long']", Date.class);
//Tue Sep 23 15:00:11 CST 2014
System.out.println(date);
如果将 JsonPath 配置为使用 JacksonMappingProvider、GsonMappingProvider 或 JakartaJsonProvider，甚至可以将 JsonPath 输出直接映射到 POJO 中。
Book book = JsonPath.parse(jsonStr).read("$.store.book[0]", Book.class);
//Book{category='reference', title='Sayings of the Century', author='Nigel Rees', price=8.95, isbn='null'}
System.out.println(book);
要获取完整的类属类型信息，请使用 TypeRef。
//注意，默认的Json-smart provider不支持TypeRef，可以使用Jackson或Gson Provider
TypeRef<List<String>> typeRef = new TypeRef<List<String>>() {};
List<String> titles = JsonPath.parse(jsonStr).read("$.store.book[*].title", typeRef);
System.out.println(titles);
3.3、JsonProvider
在Jayway JsonPath中提供了多种JsonProvider，其中默认的为JsonSmartJsonProvider。这里我们期望能够直接对读取的数据进行反序列化，这里我们选用JacksonJsonProvider，此时要求jackson-databind依赖的版本至少为2.4.5。
<!--Jackson-->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.11.3</version>
</dependency>
@AllArgsConstructor
@NoArgsConstructor
@Builder
@Data
class Book {
private String category;
private String title;
private String author;
private Double price;
private String isbn;
}
public class JsonProviderTest {
private String jsonStr = "{\n" +
" \"store\": {\n" +
" \"book\": [\n" +
" {\n" +
" \"category\": \"reference\",\n" +
" \"author\": \"Nigel Rees\",\n" +
" \"title\": \"Sayings of the Century\",\n" +
" \"price\": 8.95\n" +
" },\n" +
" {\n" +
" \"category\": \"fiction\",\n" +
" \"author\": \"Evelyn Waugh\",\n" +
" \"title\": \"Sword of Honour\",\n" +
" \"price\": 12.99\n" +
" },\n" +
" {\n" +
" \"category\": \"fiction\",\n" +
" \"author\": \"Herman Melville\",\n" +
" \"title\": \"Moby Dick\",\n" +
" \"isbn\": \"0-553-21311-3\",\n" +
" \"price\": 8.99\n" +
" },\n" +
" {\n" +
" \"category\": \"fiction\",\n" +
" \"author\": \"J. R. R. Tolkien\",\n" +
" \"title\": \"The Lord of the Rings\",\n" +
" \"isbn\": \"0-395-19395-8\",\n" +
" \"price\": 22.99\n" +
" }\n" +
" ],\n" +
" \"bicycle\": {\n" +
" \"color\": \"red\",\n" +
" \"price\": 19.95\n" +
" }\n" +
" },\n" +
" \"expensive\": 10\n" +
"}";
@Test
public void test() {
//使用JacksonJsonProvider
Configuration configuration = Configuration
.builder()
.mappingProvider(new JacksonMappingProvider())
.build();
ReadContext ctx = JsonPath.using(configuration).parse(jsonStr);
TypeRef<List<Book>> typeRef = new TypeRef<List<Book>>() {};
List<Book> books = ctx.read("$.store.book[*]", typeRef);
books.forEach(System.out::println);
}
}
Book{category='reference', title='Sayings of the Century', author='Nigel Rees', price=8.95, isbn='null'}
Book{category='fiction', title='Sword of Honour', author='Evelyn Waugh', price=12.99, isbn='null'}
Book{category='fiction', title='Moby Dick', author='Herman Melville', price=8.99, isbn='0-553-21311-3'}
Book{category='fiction', title='The Lord of the Rings', author='J. R. R. Tolkien', price=22.99, isbn='0-395-19395-8'}
3.4、谓词
在JsonPath中创建过滤器谓词有三种不同的方法：
- 内联谓词
- 过滤器谓词
- 自定义谓词
1、内联谓词
内联谓词是在路径中定义的谓词。
可以使用 && 和 || 组合多个谓词 [?(@.price < 10 && @.category == ‘fiction’)] , [?(@.category == ‘reference’ || @.price > 10)]。
可以使用! 来否定一个谓词 [?(!(@.price < 10 && @.category == ‘fiction’))] 。
@Test
public void test1() {
List<Map<String, Object>> books = JsonPath.parse(jsonStr)
.read("$.store.book[?(@.price < 10)]");
books.forEach(System.out::println);
//{category=reference, author=Nigel Rees, title=Sayings of the Century, price=8.95}
//{category=fiction, author=Herman Melville, title=Moby Dick, isbn=0-553-21311-3, price=8.99}
books = JsonPath.parse(jsonStr)
.read("$.store.book[?(!@.price < 10)]");
books.forEach(System.out::println);
//{category=reference, author=Nigel Rees, title=Sayings of the Century, price=8.95}
//{category=fiction, author=Herman Melville, title=Moby Dick, isbn=0-553-21311-3, price=8.99}
}
2)、过滤器谓词
如下所示，可以使用过滤器 API 构建谓词：
@Test
public void test2() {
Filter cheapFictionFilter = Filter.filter(
Criteria.where("price").lte(10)
);
//注意路径中过滤器的占位符 ?
//当提供多个过滤器时，它们将按顺序应用，其中占位符的数量必须与提供的过滤器数量相匹配。
//可以在一个过滤器操作中指定多个谓词占位符[?, ?]，但两个谓词必须匹配。
List<Map<String, Object>> books = JsonPath.parse(jsonStr)
.read("$.store.book[?]", cheapFictionFilter);
books.forEach(System.out::println);
//{category=reference, author=Nigel Rees, title=Sayings of the Century, price=8.95}
//{category=fiction, author=Herman Melville, title=Moby Dick, isbn=0-553-21311-3, price=8.99}
//过滤器还可以与OR和AND组合使用
Filter f = Filter.filter(Criteria.where("price").lte(10))
.and(Criteria.where("isbn").exists(true));
books = JsonPath.parse(jsonStr)
.read("$.store.book[?]", f);
books.forEach(System.out::println);
//{category=fiction, author=Herman Melville, title=Moby Dick, isbn=0-553-21311-3, price=8.99}
}
3)、自定义谓词
@Test
public void test3() {
//自定义谓词
Predicate booksWithISBN = new Predicate() {
@Override
public boolean apply(PredicateContext ctx) {
return ctx.item(Map.class).containsKey("isbn");
}
};
List<Map<String, Object>> books = JsonPath.parse(jsonStr)
.read("$.store.book[?]", booksWithISBN);
books.forEach(System.out::println);
//{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}
}
4)、示例
{
"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
},
"clothes":[
{
"name":"牛仔裤",
"sizes":"S",
"price":94
},
{
"name":"背心",
"sizes":"M",
"price":48
},
{
"name":"裙子",
"sizes":["S", "M"],
"price":1.24
},
{
"name":"羊毛衫",
"sizes":["XS", "XL"],
"price":78.99
},
{
"name":"Polo衫",
"sizes":["XS", "XL", "M"],
"price":18.99
}
]
},
"expensive":10
}
@Test
public void test() {
//使用JacksonJsonProvider
Configuration configuration = Configuration
.builder()
.mappingProvider(new JacksonMappingProvider())
.build();
ReadContext ctx = JsonPath.using(configuration)
.parse(jsonStr);
//方式一：内联谓词
TypeRef<List<Clothes>> typeRef = new TypeRef<List<Clothes>>() {};
final List<Clothes> clothes1 = ctx.read("$.store.clothes[?(@.price > 50 || @.sizes anyof ['M'])]", typeRef);
System.out.println("************** clothes1 ***************");
clothes1.forEach(System.out::println);
//方式二：Filter谓词
Filter filter = Filter.filter(Criteria.where("price").gt(50))
.or(Criteria.where("sizes").anyof(Arrays.asList("M")));
//使用谓词占位符？
Clothes[] clothes2 = ctx.read("$.store.clothes[?]", Clothes[].class, filter);
System.out.println("************** clothes2 ***************");
for (Clothes clothes : clothes2) {
System.out.println(clothes);
}
//方式三：自定义谓词
Predicate rule = (context) -> {
final Map map = context.item(Map.class);
boolean b1 = false;
Object priceObj = map.getOrDefault("price", null);
if (priceObj != null) {
String priceStr = priceObj.toString();
Double price = 0d;
try {
price = Double.parseDouble(priceStr);
} catch (Exception e) {
}
b1 = price > 50d;
}
boolean b2 = false;
Object sizes = map.getOrDefault("sizes", null);
if (sizes != null && sizes instanceof List) {
List<String> sizeList = (List<String>) sizes;
List<String> targetList = Arrays.asList("M");
for (String size : sizeList) {
if (targetList.contains(size)) {
b2 = true;
break;
}
}
}
return b1 || b2;
};
// 使用谓词的占位符?
Clothes[] clothes3 = ctx.read("$.store.clothes[?]", Clothes[].class, rule);
System.out.println("-------------- clothes3 ---------------");
for (Clothes clothes : clothes3) {
System.out.println(clothes);
}
}
************** clothes1 ***************
Clothes{name='牛仔裤', price=94.0, sizes=S}
Clothes{name='裙子', price=1.24, sizes=[S, M]}
Clothes{name='羊毛衫', price=78.99, sizes=[XS, XL]}
Clothes{name='Polo衫', price=18.99, sizes=[XS, XL, M]}
************** clothes2 ***************
Clothes{name='牛仔裤', price=94.0, sizes=S}
Clothes{name='裙子', price=1.24, sizes=[S, M]}
Clothes{name='羊毛衫', price=78.99, sizes=[XS, XL]}
Clothes{name='Polo衫', price=18.99, sizes=[XS, XL, M]}
-------------- clothes3 ---------------
Clothes{name='牛仔裤', price=94.0, sizes=S}
Clothes{name='裙子', price=1.24, sizes=[S, M]}
Clothes{name='羊毛衫', price=78.99, sizes=[XS, XL]}
Clothes{name='Polo衫', price=18.99, sizes=[XS, XL, M]}
3.5、使用函数
//language=JSON
String jsonStr = "{\n" +
" \"name\": \"tom\",\n" +
" \"age\": 18,\n" +
" \"height\": 1.77,\n" +
" \"scores\": [1.1, 2.2, 3,3, 4.4, 5.5, 6.6]\n" +
"}";
ReadContext ctx = JsonPath.using(Configuration.defaultConfiguration()).parse(jsonStr);
Double min = ctx.read("$.scores.min()");
System.out.println(min);//1.1
Double max = ctx.read("$.scores.max()");
System.out.println(max);//6.6
Double avg = ctx.read("$.scores.avg()");
System.out.println(avg);//3.6857142857142864
Double stddev = ctx.read("$.scores.stddev()");
System.out.println(stddev);//1.7779832647682354
Double sum = ctx.read("$.scores.sum()");
System.out.println(sum);//25.800000000000004
Integer length = ctx.read("$.scores.length()");
System.out.println(length);//7
Set<String> keys = ctx.read("$.keys()");
System.out.println(keys);//[name, age, height, scores]
String concat = ctx.read("$.concat(@.name, \" \", @.age)");
System.out.println(concat);//tom 18
List<Double> scores = ctx.read("$.scores.append(99.9)");
System.out.println(scores);//[1.1,2.2,3,3,4.4,5.5,6.6,99.9]
3.6、返回路径
JsonPath 可以返回 Path 或 Value。Value 是默认值，也是上面所有示例的返回值。如果你更希望得到我们的查询所命中的元素的路径，这可以通过一个选项来实现。
//返回路径
Configuration configuration = Configuration
.builder()
.options(Option.AS_PATH_LIST)
.build();
List<String> pathList = JsonPath.using(configuration).parse(jsonStr).read("$..author");
System.out.println(pathList);
//["$['store']['book'][0]['author']",
// "$['store']['book'][1]['author']",
// "$['store']['book'][2]['author']","
// $['store']['book'][3]['author']"]
3.7、添加/设置值
String str = "{\"name\": \"tom\"}";
//设置值
String newStr1 = JsonPath.parse(str)
.set("$.name", "jerry")
.jsonString();
//添加
String newStr2 = JsonPath.parse(newStr1)
.put("$", "age",17)
.jsonString();
//{"name":"jerry","age":17}
System.out.println(newStr2);
3.8、配置
1)、Options
有几个选项标志可以改变JsonPath的默认行为：
- DEFAULT_PATH_LEAF_TO_NULL：该选项使 JsonPath 在缺少叶子节点时返回NUll值
@Test
public void configTest1() {
//language=JSON
String jsonStr = "[\n" +
" {\n" +
" \"name\" : \"john\",\n" +
" \"gender\" : \"male\"\n" +
" },\n" +
" {\n" +
" \"name\" : \"ben\"\n" +
" }\n" +
"]";
//默认情况抛出异常
//com.jayway.jsonpath.PathNotFoundException: No results for path: $[1]['gender']
String gender1 = JsonPath.parse(jsonStr).read("$[1].gender");
//使用DEFAULT_PATH_LEAF_TO_NULL，会返回Null
Configuration configuration = Configuration.builder()
.options(Option.DEFAULT_PATH_LEAF_TO_NULL)
.build();
String gender2 = JsonPath.using(configuration).parse(jsonStr).read("$[1].gender");
System.out.println(gender2);//null
}
- ALWAYS_RETURN_LIST：即使路径是确定的，也会返回一个列表
@Test
public void configTest2() {
String jsonStr = "[\n" +
" {\n" +
" \"name\" : \"john\",\n" +
" \"gender\" : \"male\"\n" +
" },\n" +
" {\n" +
" \"name\" : \"ben\"\n" +
" }\n" +
"]";
//默认情况下抛出异常
//java.lang.ClassCastException: java.lang.String cannot be cast to java.util.List
List<String> genders1 = JsonPath.parse(jsonStr).read("$[0].gender");
//使用ALWAYS_RETURN_LIST，返回一个列表
Configuration configuration = Configuration.builder()
.options(Option.ALWAYS_RETURN_LIST)
.build();
List<String> genders2 = JsonPath.using(configuration).parse(jsonStr).read("$[0].gender");
System.out.println(genders2);//["male"]
}
- SUPPRESS_EXCEPTIONS：该选项确保路径评估不会传播异常。它遵循以下简单规则：
- 如果存在 ALWAYS_RETURN_LIST 选项，则返回空列表
- 如果不存在 ALWAYS_RETURN_LIST 选项，则返回Null
@Test
public void configTest3() {
String jsonStr = "[\n" +
" {\n" +
" \"name\" : \"john\",\n" +
" \"gender\" : \"male\"\n" +
" },\n" +
" {\n" +
" \"name\" : \"ben\"\n" +
" }\n" +
"]";
//存在 ALWAYS_RETURN_LIST选项，则返回空列表
Configuration configuration1 = Configuration.builder()
.options(Option.ALWAYS_RETURN_LIST, Option.SUPPRESS_EXCEPTIONS)
.build();
List<String> genders1 = JsonPath.using(configuration1).parse(jsonStr).read("$[1].gender");
System.out.println(genders1);//[]
//不存在 ALWAYS_RETURN_LIST选项，则返回Null
Configuration configuration2 = Configuration.builder()
.options(Option.SUPPRESS_EXCEPTIONS)
.build();
List<String> genders2 = JsonPath.using(configuration2).parse(jsonStr).read("$[1].gender");
System.out.println(genders2);//null
}
- REQUIRE_PROPERTIES：在评估不确定路径时要求使用路径中定义的属性
- 如果REQUIRE_PROPERTIES选项存在，则抛出PathNotFoundException
- 如果REQUIRE_PROPERTIES选项不存在正常返回
@Test
public void configTest4() {
String jsonStr = "[\n" +
" {\n" +
" \"name\" : \"john\",\n" +
" \"gender\" : \"male\"\n" +
" },\n" +
" {\n" +
" \"name\" : \"ben\"\n" +
" }\n" +
"]";
//存在 REQUIRE_PROPERTIES，则抛出异常
//com.jayway.jsonpath.PathNotFoundException: No results for path: $[1]['gender']
Configuration configuration1 = Configuration.builder()
.options(Option.REQUIRE_PROPERTIES)
.build();
// List<String> genders1 = JsonPath.using(configuration1).parse(jsonStr).read("$[*].gender");
//不存在 REQUIRE_PROPERTIES，返回["male"]
Configuration configuration2 = Configuration.builder()
.options()
.build();
List<String> genders2 = JsonPath.using(configuration2).parse(jsonStr).read("$[*].gender");
System.out.println(genders2);//["male"]
}
- AS_PATH_LIST：不返回值，返回路径
2)、JsonProvider SPI
JsonPath 提供五种不同的 JsonProviders：
- JsonSmartJsonProvider (default)
- JacksonJsonProvider
- JacksonJsonNodeJsonProvider
- GsonJsonProvider
- JsonOrgJsonProvider
- JakartaJsonProvider
只有在应用程序初始化时，才能按演示更改配置默认值。强烈不建议在运行期间更改配置，尤其是在多线程应用程序中。
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<Option> options() {
return EnumSet.noneOf(Option.class);
}
});
请注意，JacksonJsonProvider 需要 com.fasterxml.jackson.core:jackson-databind:2.4.5 的类路径，而 GsonJsonProvider 需要 com.google.code.gson:gson:2.3.1 的类路径。
Jakarta EE 9 JSON-P (JSR-342) 和 JSON-B (JSR-367) 提供程序至少需要 Java 8，并要求应用程序运行时类路径上有兼容的 JSON API 实现（如 Eclipse Glassfish 和 Eclipse Yasson）；Java EE 应用程序容器也可能提供此类实现。还请注意，Apache Johnzon 尚不兼容 Jakarta EE 9 规范的类路径，如果选择 JSON-B 映射提供程序，则还必须配置和使用 JSON-P 提供程序。
Jakarta EE 9 关于 JSON 处理和数据库绑定（映射）的规范有一个特点，即 Json 数组和对象在完全解析或写入后具有不变性。为了遵守 API 规范，同时允许 JsonPath 通过添加、设置/输入、替换和删除操作来修改 Json 文档，JakartaJsonProvider 必须使用可选的 true 参数进行 initiliazed：
- JsonProvider jsonProvider = new JakartaJsonProvider(true)（启用可变 Json 数组和对象）
- JsonProvider jsonProvider = new JakartaJsonProvider()（默认，严格遵循 JSON-P API）
无论采用哪种启动模式，都支持使用 JsonPath 进行的所有查找和读取操作。默认模式所需的内存更少，性能更高。
3)、Cache SPI
JsonPath 2.1.0 引入了新的缓存 SPI。这允许 API 用户根据自己的需要配置路径缓存。缓存必须在首次访问前配置好，否则会产生 JsonPathException 异常。JsonPath 有两种缓存实现
com.jayway.jsonpath.spi.cache.LRUCache（默认，线程安全）com.jayway.jsonpath.spi.cache.NOOPCache（无缓存）
如果您想实现自己的缓存，API 也很简单：
CacheProvider.setCache(new Cache() {
//Not thread safe simple cache
private Map<String, JsonPath> map = new HashMap<String, JsonPath>();
@Override
public JsonPath get(String key) {
return map.get(key);
}
@Override
public void put(String key, JsonPath jsonPath) {
map.put(key, jsonPath);
}
});
