JsonPath详解
JsonPath1、概述
JsonPath是用来解析多层嵌套的JSON数据。可以以为JsonPath就是JSON版本的XPath。它是一种信息抽取类库，是从JSON文档中抽取指定信息的工具。JsonPath对于JSON来说，就相当于XPath之于XML。
JsonPath在线解析：https://jsonpath.com/
2、JsonPath语法
2.1、操纵符
语法寄义$表示根节点@当前节点.<节点名称>获取子节点[<节点名称1>(,<节点名称2>)]获取子节点，与点号差别，这里可以获取多个子节点*匹配所有元素节点..获取子孙节点，无论嵌套多少层，都可以获取到[<下标1>(,<下标2>)]表示一个或多个下标表示切片语法[?(<表达式>)]过滤器表达式，表达式效果必须是布尔值()支持表达式盘算 2.2、函数
可以在JsonPath表达式执行后进行调用，其输入表达式的效果。
函数描述输出min()提供数字数组的最小值Doublemax()提供数字数组的最大值Doubleavg()提供数字数据的均匀值Doublestddev()提供数字数组的标准偏差值Doublelength()提供数组的长度Integersum()提供数字数组的和值Doublekeys()提供属性键（终端自键~的替代选择）Set<E>concat(X)提供路径输出的合并版本，并添加一个新项目like inputappend(X)为 json 路径输出数组添加项目like inputfirst()提供数组的第一个项目Depends on the arraylast()提供数组的末了一项Depends on the arrayindex(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
}
JsonPathResult$.store.book
[*].author所有册本的作者$..author所有作者$..book第3本数$..book前2本数$..book切片操纵，从索引 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.author");
String author1 = JsonPath.read(document, "$.store.book.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.author");
//java.lang.ClassCastException: java.lang.String cannot be cast to java.util.List
List<String> list = JsonPath.parse(jsonStr).read("$.store.book.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", 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=}
Clothes{name='羊毛衫', price=78.99, sizes=}
Clothes{name='Polo衫', price=18.99, sizes=}
************** clothes2 ***************
Clothes{name='牛仔裤', price=94.0, sizes=S}
Clothes{name='裙子', price=1.24, sizes=}
Clothes{name='羊毛衫', price=78.99, sizes=}
Clothes{name='Polo衫', price=18.99, sizes=}
-------------- clothes3 ---------------
Clothes{name='牛仔裤', price=94.0, sizes=S}
Clothes{name='裙子', price=1.24, sizes=}
Clothes{name='羊毛衫', price=78.99, sizes=}
Clothes{name='Polo衫', price=18.99, sizes=}
3.5、使用函数
//language=JSON
String jsonStr = "{\n" +
"\"name\": \"tom\",\n" +
"\"age\": 18,\n" +
"\"height\": 1.77,\n" +
"\"scores\": \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);//
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);//
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']['author']",
// "$['store']['book']['author']",
// "$['store']['book']['author']","
// $['store']['book']['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: $['gender']
String gender1 = JsonPath.parse(jsonStr).read("$.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("$.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("$.gender");
//使用ALWAYS_RETURN_LIST，返回一个列表
Configuration configuration = Configuration.builder()
.options(Option.ALWAYS_RETURN_LIST)
.build();
List<String> genders2 = JsonPath.using(configuration).parse(jsonStr).read("$.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("$.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("$.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: $['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);
}
});
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
页:
[1]