JAVA JsonPath 查询失败？路径表达式与嵌套结构匹配问题剖析 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

JSONPath 查询失败？路径表达式与嵌套结构匹配问题剖析

大家好，今天我们来深入探讨一个在 Java 开发中经常遇到的问题：使用 JSONPath 查询 JSON 数据时遇到的失败情况。JSONPath 作为一种强大的 JSON 查询语言，能够帮助我们从复杂的 JSON 结构中提取所需数据。然而，在实际应用中，由于路径表达式编写不当或者对 JSON 结构理解不够透彻，我们常常会遇到查询失败的情况。本次讲座将从以下几个方面展开，通过实际案例分析，帮助大家理解 JSONPath 的工作原理，掌握解决查询失败问题的技巧。

一、JSONPath 基础回顾

在深入分析问题之前，我们先来回顾一下 JSONPath 的一些基本概念和语法。

根对象 ($)： JSONPath 表达式总是从根对象开始，用 $ 符号表示。
子节点运算符 (.)： 用于访问 JSON 对象的子节点。例如，$.store.book[0].title 表示访问 store 对象的 book 数组的第一个元素的 title 属性。
数组索引 ([索引])： 用于访问 JSON 数组中的元素。索引从 0 开始。例如，$.store.book[0] 表示访问 book 数组的第一个元素。
*通配符 ()：* 用于匹配数组或对象的所有元素。例如，`$.store.book[].author表示访问book数组中所有元素的author` 属性。
递归下降 (..)： 用于在 JSON 结构中递归查找匹配的元素。例如，$..author 表示在整个 JSON 结构中查找所有名为 author 的属性。
过滤表达式 ([?表达式])： 用于根据条件过滤数组元素。例如，$.store.book[?(@.price < 10)].title 表示访问 book 数组中 price 小于 10 的元素的 title 属性。@ 符号代表当前正在处理的元素。
函数表达式： JSONPath 支持一些内置函数，例如 min(), max(), avg(), stddev(), length() 等。

二、常见的 JSONPath 查询失败场景及原因分析

现在我们来看一些实际的 JSONPath 查询失败的例子，并分析其原因。

场景 1：NoSuchMethodException

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
      }
    ],
    "bicycle": {
      "color": "red",
      "price": 19.95
    }
  }
}

Java 代码：

import com.jayway.jsonpath.JsonPath;

public class JsonPathExample {
    public static void main(String[] args) {
        String 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}],"bicycle":{"color":"red","price":19.95}}}";

        try {
            // 错误的写法：使用 String 类型调用 getDouble() 方法
            Double price = JsonPath.read(json, "$.store.book[0].price");  // 会抛出 ClassCastException
            System.out.println("Price: " + price);
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
            e.printStackTrace();
        }

        try {
          // 正确的写法
          Double price = ((Number) JsonPath.read(json, "$.store.book[0].price")).doubleValue();
          System.out.println("Price: " + price);
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

错误原因：

JsonPath.read() 方法返回的是 Object 类型，你需要将其转换为正确的类型。直接将其赋值给 Double 类型会导致 ClassCastException。

解决方法：

将 JsonPath.read() 返回的结果强制转换为 Number 类型，然后调用 doubleValue() 方法获取 double 值。

场景 2：PathNotFoundException

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
      }
    ]
  }
}

Java 代码：

import com.jayway.jsonpath.JsonPath;

public class JsonPathExample {
    public static void main(String[] args) {
        String 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}]}}";

        try {
            String author = JsonPath.read(json, "$.store.book[0].authors"); // 查询不存在的字段 authors
            System.out.println("Author: " + author);
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

错误原因：

JSONPath 表达式中的路径 $.store.book[0].authors 指向的字段 authors 在 JSON 数据中不存在。

解决方法：

确保 JSONPath 表达式中的路径与 JSON 数据的结构完全匹配。检查字段名称是否正确，大小写是否一致。在这个例子中，应该将 authors 改为 author。

增强容错性:

import com.jayway.jsonpath.JsonPath;
import com.jayway.jsonpath.PathNotFoundException;

public class JsonPathExample {
    public static void main(String[] args) {
        String 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}]}}";

        try {
            String author = JsonPath.read(json, "$.store.book[0].authors"); // 查询不存在的字段 authors
            System.out.println("Author: " + author);
        } catch (PathNotFoundException e) {
            System.out.println("Field not found.");
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

场景 3：JSONArray 与 JSONObject 混淆

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
      }
    ]
  }
}

Java 代码：

import com.jayway.jsonpath.JsonPath;
import java.util.List;

public class JsonPathExample {
    public static void main(String[] args) {
        String 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}]}}";

        try {
            // 错误写法：将 book 数组当成对象处理
            String title = JsonPath.read(json, "$.store.book.title"); // 会抛出异常
            System.out.println("Title: " + title);
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
            e.printStackTrace();
        }

       try {
            // 正确的写法：获取所有 book 的 title
            List<String> titles = JsonPath.read(json, "$.store.book[*].title");
            System.out.println("Titles: " + titles);
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
            e.printStackTrace();
        }

        try {
            // 正确的写法：获取第一个 book 的 title
            String title = JsonPath.read(json, "$.store.book[0].title");
            System.out.println("Title: " + title);
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

错误原因：

$.store.book.title 试图将 book 数组作为一个对象来访问其 title 属性，这是不正确的。book 是一个数组，需要使用索引或通配符来访问其元素。

解决方法：

如果要访问所有 book 的 title，可以使用 $.store.book[*].title。
如果要访问第一个 book 的 title，可以使用 $.store.book[0].title。

场景 4：过滤表达式使用错误

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
      }
    ]
  }
}

Java 代码：

import com.jayway.jsonpath.JsonPath;
import java.util.List;

public class JsonPathExample {
    public static void main(String[] args) {
        String 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}]}}";

        try {
            // 错误的写法：过滤表达式语法错误
            List<String> titles = JsonPath.read(json, "$.store.book[price < 10].title"); // 语法错误
            System.out.println("Titles: " + titles);
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
            e.printStackTrace();
        }

        try {
            // 正确的写法：使用 @ 符号引用当前元素
            List<String> titles = JsonPath.read(json, "$.store.book[?(@.price < 10)].title");
            System.out.println("Titles: " + titles);
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

错误原因：

过滤表达式的语法不正确。在过滤表达式中，需要使用 @ 符号来引用当前正在处理的数组元素。

解决方法：

使用正确的过滤表达式语法，例如 $.store.book[?(@.price < 10)].title。

场景 5：使用了不支持的 JSONPath 函数

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
      }
    ]
  }
}

Java 代码：

import com.jayway.jsonpath.JsonPath;

public class JsonPathExample {
    public static void main(String[] args) {
        String 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}]}}";

        try {
            // 错误的写法：使用了不支持的函数
            Double averagePrice = JsonPath.read(json, "$.store.book.average(price)"); //average 是错误的函数
            System.out.println("Average Price: " + averagePrice);
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
            e.printStackTrace();
        }

        try {
            // 正确的写法：使用 avg() 函数
            Double averagePrice = JsonPath.read(json, "$.store.book.avg(price)");
            System.out.println("Average Price: " + averagePrice);
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

错误原因：

JSONPath 的具体实现可能不支持某些函数。使用了 average 函数，而实际上应该使用 avg 函数。

解决方法：

查阅 JSONPath 实现的文档，确认支持的函数列表，并使用正确的函数名称。

场景 6：空指针异常

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"
      }
    ]
  }
}

Java 代码：

import com.jayway.jsonpath.JsonPath;

public class JsonPathExample {
    public static void main(String[] args) {
        String 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"}]}}";

        try {
            // 第二本书没有 price 字段，直接读取会导致空指针异常
            Double price = ((Number) JsonPath.read(json, "$.store.book[1].price")).doubleValue();
            System.out.println("Price: " + price);
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
            e.printStackTrace();
        }

        try {
            // 增加判空处理
            Object priceObject = JsonPath.read(json, "$.store.book[1].price");
            Double price = (priceObject != null) ? ((Number) priceObject).doubleValue() : null;

            if (price != null) {
                System.out.println("Price: " + price);
            } else {
                System.out.println("Price not found for book[1].");
            }
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

错误原因：

JSON 数据中，第二个 book 对象缺少 price 字段，直接读取该字段会导致 JsonPath 返回 null。然后尝试将 null 转换为 Number 类型，从而引发 NullPointerException。

解决方法：

在读取可能为空的字段之前，先判断其是否存在。可以使用 try-catch 块捕获 PathNotFoundException 异常，或者先使用 JSONPath 查询该字段是否存在。更简单的做法是直接判断返回值是否为 null。

三、调试 JSONPath 查询的技巧

当遇到 JSONPath 查询失败时，可以尝试以下调试技巧：

仔细检查 JSON 数据： 确认 JSON 数据的结构是否符合预期，字段名称、类型、大小写是否正确。
逐步构建 JSONPath 表达式： 从简单的路径开始，逐步增加复杂度，例如先 $.store，然后 $.store.book，再 $.store.book[0]，以此类推，直到找到出错的地方。
使用在线 JSONPath 工具： 使用在线 JSONPath 工具（例如：https://jsonpath.com/）验证 JSONPath 表达式是否正确。将 JSON 数据和 JSONPath 表达式输入到工具中，查看查询结果。
打印 JSONPath 的返回值： 在 Java 代码中，打印 JsonPath.read() 方法的返回值，查看返回的是什么，是否有异常抛出。
使用 JSONPath 提供的配置选项： com.jayway.jsonpath.Configuration 类提供了一些配置选项，可以影响 JSONPath 的行为。例如，可以使用 Configuration.defaultConfiguration().setOptions(Option.DEFAULT_PATH_LEAF_TO_NULL) 来使 JSONPath 在找不到路径时返回 null 而不是抛出异常。
编写单元测试： 针对不同的 JSON 数据和 JSONPath 表达式编写单元测试，确保查询的正确性。

四、实际案例分析：嵌套 JSON 结构的复杂查询

假设我们有以下 JSON 数据，描述了一个在线商店的商品信息：

{
  "store": {
    "name": "My Online Store",
    "products": [
      {
        "id": "123",
        "name": "Laptop",
        "price": 1200.00,
        "category": "Electronics",
        "details": {
          "brand": "Dell",
          "model": "XPS 13"
        },
        "reviews": [
          {
            "user": "John",
            "rating": 5,
            "comment": "Great laptop!"
          },
          {
            "user": "Jane",
            "rating": 4,
            "comment": "Good value for money."
          }
        ]
      },
      {
        "id": "456",
        "name": "Book",
        "price": 25.00,
        "category": "Books",
        "details": {
          "author": "George Orwell",
          "title": "1984"
        },
        "reviews": [
          {
            "user": "Peter",
            "rating": 5,
            "comment": "A must-read!"
          }
        ]
      }
    ]
  }
}

现在，我们尝试使用 JSONPath 查询以下信息：

所有商品的名称： $.store.products[*].name
价格大于 100 的商品的名称： $.store.products[?(@.price > 100)].name
第一个商品的品牌： $.store.products[0].details.brand
所有评论的平均评分： $.store.products[*].reviews[*].rating.avg() (注意：这个需要自定义函数支持，因为 JsonPath 默认不支持对嵌套数组求平均值)
所有 Electronics 类别商品的ID: $.store.products[?(@.category == 'Electronics')].id
所有商品中，评分大于等于4.5的评论的用户: $.store.products[*].reviews[?(@.rating >= 4.5)].user

对于第4个查询，我们需要自定义函数来支持平均评分的计算，这里我们假设已经实现了自定义函数。

Java 代码示例（部分）：

import com.jayway.jsonpath.JsonPath;
import java.util.List;

public class JsonPathExample {
    public static void main(String[] args) {
        String json = "{"store":{"name":"My Online Store","products":[{"id":"123","name":"Laptop","price":1200.00,"category":"Electronics","details":{"brand":"Dell","model":"XPS 13"},"reviews":[{"user":"John","rating":5,"comment":"Great laptop!"},{"user":"Jane","rating":4,"comment":"Good value for money."}]},{"id":"456","name":"Book","price":25.00,"category":"Books","details":{"author":"George Orwell","title":"1984"},"reviews":[{"user":"Peter","rating":5,"comment":"A must-read!"}]}]}}";

        try {
            List<String> productNames = JsonPath.read(json, "$.store.products[*].name");
            System.out.println("Product Names: " + productNames);

            List<String> highPricedProductNames = JsonPath.read(json, "$.store.products[?(@.price > 100)].name");
            System.out.println("High Priced Product Names: " + highPricedProductNames);

            String firstProductBrand = JsonPath.read(json, "$.store.products[0].details.brand");
            System.out.println("First Product Brand: " + firstProductBrand);

            List<String> electronicsProductIds = JsonPath.read(json, "$.store.products[?(@.category == 'Electronics')].id");
            System.out.println("Electronics Product IDs: " + electronicsProductIds);

            List<String> highRatingUsers = JsonPath.read(json, "$.store.products[*].reviews[?(@.rating >= 4.5)].user");
            System.out.println("High Rating Users: " + highRatingUsers);

        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

这个案例展示了如何使用 JSONPath 查询嵌套的 JSON 结构，包括访问数组元素、使用过滤表达式和访问对象的属性。通过这个案例，我们可以更深入地理解 JSONPath 的使用方法。

五、JSONPath 的局限性与替代方案

虽然 JSONPath 功能强大，但也存在一些局限性：

标准不统一： 不同的 JSONPath 实现可能支持不同的语法和函数。
不支持修改 JSON 数据： JSONPath 主要用于查询，不支持修改 JSON 数据。
性能问题： 对于非常大的 JSON 数据，JSONPath 的查询性能可能较低。

针对这些局限性，我们可以考虑使用以下替代方案：

自定义 Java 代码： 使用 Java 代码手动解析 JSON 数据，并提取所需信息。这种方法灵活性高，但代码量大。
使用 Jackson 或 Gson 等 JSON 库提供的 API： 这些库提供了更强大的 JSON 处理能力，例如修改 JSON 数据、序列化和反序列化等。
JPQL (Java Persistence Query Language)： 如果你的 JSON 数据映射到 Java 对象，可以使用 JPQL 进行查询。

特性	JSONPath	自定义 Java 代码	Jackson/Gson API	JPQL
适用场景	复杂 JSON 查询，需要灵活的路径表达式	简单的 JSON 查询，需要高度控制	需要修改 JSON 数据，序列化/反序列化	JSON 数据映射到 Java 对象，需要对象查询
优点	语法简洁，易于使用	灵活性高，可以实现复杂逻辑	功能强大，提供丰富的 API	面向对象查询，易于维护
缺点	标准不统一，性能可能较低	代码量大，维护成本高	学习成本较高，需要熟悉 API	需要 ORM 框架支持，学习成本较高

六、配置选项的影响

com.jayway.jsonpath.Configuration 类允许您配置 JSONPath 引擎的行为。一些重要的选项包括：

Option.DEFAULT_PATH_LEAF_TO_NULL: 当路径不存在时，返回 null 而不是抛出 PathNotFoundException。
Option.ALWAYS_RETURN_LIST: 始终返回一个列表，即使查询结果只有一个元素。
Option.SUPPRESS_EXCEPTIONS: 抑制异常，当查询失败时返回 null 或空列表。

合理使用这些配置选项可以提高 JSONPath 查询的健壮性和容错性。例如：

import com.jayway.jsonpath.Configuration;
import com.jayway.jsonpath.JsonPath;
import com.jayway.jsonpath.Option;

public class JsonPathExample {
    public static void main(String[] args) {
        String json = "{"store":{"name":"My Online Store"}}";

        Configuration conf = Configuration.defaultConfiguration().setOptions(Option.DEFAULT_PATH_LEAF_TO_NULL);

        Object result = JsonPath.using(conf).parse(json).read("$.store.products"); // products 不存在
        System.out.println("Result: " + result); // 输出 Result: null
    }
}

七、JSON结构不规范导致的问题

JSON结构不规范可能导致JSONPath查询失败，例如：

缺少必要的引号： JSON 规范要求键名必须使用双引号括起来。
数据类型不一致： 同一个字段在不同的对象中类型不一致，例如，有时是字符串，有时是数字。
格式错误： JSON 格式错误，例如缺少逗号或括号不匹配。

在处理 JSON 数据之前，务必使用 JSON 校验工具（例如：https://jsonlint.com/）验证 JSON 数据的格式是否正确。

八、处理大型JSON文件

当处理大型 JSON 文件时，需要注意性能问题。以下是一些优化技巧：

使用流式 API： 使用流式 API (例如 Jackson 的 JsonParser) 逐行读取 JSON 数据，避免一次性加载整个文件到内存中。
避免使用 .. 操作符： .. 操作符会递归遍历整个 JSON 结构，性能较低。尽量使用更精确的路径表达式。
使用索引： 如果 JSON 数据支持索引，可以使用索引来加速查询。

九、灵活运用，有效查询

JSONPath 是一个强大的工具，可以帮助我们从复杂的 JSON 结构中提取所需数据。但是，在使用 JSONPath 时，我们需要仔细理解 JSON 数据的结构，编写正确的路径表达式，并注意处理可能出现的异常。通过掌握这些技巧，我们可以更有效地使用 JSONPath，提高开发效率。

本次讲座主要介绍了 JSONPath 查询失败的一些常见场景和解决方法，希望能够帮助大家在实际开发中更好地使用 JSONPath。谢谢大家！

JSONPath 查询失败？路径表达式与嵌套结构匹配问题剖析

发表回复 取消回复

发表回复取消回复