这个 Java 依赖包是 jmespath.java，它是一个 JMESPath 查询语言的 Java 实现。

Maven 依赖地址

<dependency>
    <groupId>io.burt</groupId>
    <artifactId>jmespath-jcf</artifactId>
    <version>0.5.1</version>
</dependency>

详细说明和示例

1. 基本介绍

JMESPath 是一种 JSON 查询语言，类似于 XPath 用于 XML。jmespath.java 提供了：

• JMESPath 表达式的解析和执行
• 支持标准的 Java 集合框架（JCF）
• 线程安全的运行时环境

2. 完整示例代码

import io.burt.jmespath.Expression;
import io.burt.jmespath.JmesPath;
import io.burt.jmespath.jcf.JcfRuntime;

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class JmesPathExample {
    
    public static void main(String[] args) {
        // 创建运行时环境
        JmesPath<Object> jmespath = new JcfRuntime();
        
        // 示例1: 基本查询
        basicQueryExample(jmespath);
        
        // 示例2: 复杂数据结构查询
        complexQueryExample(jmespath);
        
        // 示例3: 列表操作
        listOperationsExample(jmespath);
    }
    
    // 基本查询示例
    public static void basicQueryExample(JmesPath<Object> jmespath) {
        System.out.println("=== 基本查询示例 ===");
        
        // 创建测试数据
        Map<String, Object> data = new HashMap<>();
        data.put("name", "张三");
        data.put("age", 30);
        data.put("city", "北京");
        
        // 编译查询表达式
        Expression<Object> expression = jmespath.compile("name");
        
        // 执行查询
        Object result = expression.search(data);
        System.out.println("查询 name: " + result); // 输出: 张三
    }
    
    // 复杂数据结构查询
    public static void complexQueryExample(JmesPath<Object> jmespath) {
        System.out.println("\n=== 复杂查询示例 ===");
        
        // 创建嵌套数据结构
        Map<String, Object> person = new HashMap<>();
        person.put("name", "李四");
        person.put("age", 25);
        
        Map<String, Object> address = new HashMap<>();
        address.put("street", "长安街");
        address.put("city", "北京");
        address.put("zipcode", "100000");
        person.put("address", address);
        
        Map<String, Object> company = new HashMap<>();
        company.put("name", "ABC公司");
        company.put("department", "技术部");
        person.put("company", company);
        
        // 各种查询示例
        String[] queries = {
            "name",                           // 直接属性
            "address.city",                   // 嵌套属性
            "company.name",                   // 另一个嵌套属性
            "age",                            // 数字属性
            "address.street"                  // 字符串属性
        };
        
        for (String query : queries) {
            Expression<Object> expr = jmespath.compile(query);
            Object result = expr.search(person);
            System.out.println(query + ": " + result);
        }
    }
    
    // 列表操作示例
    public static void listOperationsExample(JmesPath<Object> jmespath) {
        System.out.println("\n=== 列表操作示例 ===");
        
        // 创建包含列表的数据
        Map<String, Object> data = new HashMap<>();
        List<Map<String, Object>> users = Arrays.asList(
            createUser("王五", 28, "上海"),
            createUser("赵六", 35, "广州"),
            createUser("钱七", 22, "深圳")
        );
        data.put("users", users);
        
        // 各种列表查询
        String[] queries = {
            "users[0].name",                  // 第一个用户的名字
            "users[-1].city",                 // 最后一个用户的城市
            "users[0:2].name",                // 前两个用户的名字
            "users[?age > `25`].name",        // 年龄大于25的用户名字
            "users[*].name",                  // 所有用户的名字
            "length(users)"                   // 用户数量
        };
        
        for (String query : queries) {
            try {
                Expression<Object> expr = jmespath.compile(query);
                Object result = expr.search(data);
                System.out.println(query + ": " + result);
            } catch (Exception e) {
                System.out.println(query + ": 错误 - " + e.getMessage());
            }
        }
    }
    
    // 创建用户对象的辅助方法
    private static Map<String, Object> createUser(String name, int age, String city) {
        Map<String, Object> user = new HashMap<>();
        user.put("name", name);
        user.put("age", age);
        user.put("city", city);
        return user;
    }
}

3. 高级功能示例

import io.burt.jmespath.Expression;
import io.burt.jmespath.JmesPath;
import io.burt.jmespath.jcf.JcfRuntime;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class AdvancedJmesPathExample {
    
    public static void main(String[] args) throws Exception {
        JmesPath<Object> jmespath = new JcfRuntime();
        
        // JSON 字符串处理
        jsonStringProcessing(jmespath);
        
        // 复杂过滤和投影
        complexFiltering(jmespath);
    }
    
    // JSON 字符串处理
    public static void jsonStringProcessing(JmesPath<Object> jmespath) throws Exception {
        System.out.println("=== JSON 字符串处理 ===");
        
        String jsonString = "{\"store\":{\"books\":[" +
            "{\"title\":\"Java编程\",\"price\":45,\"category\":\"技术\"}," +
            "{\"title\":\"设计模式\",\"price\":38,\"category\":\"技术\"}," +
            "{\"title\":\"小说选\",\"price\":25,\"category\":\"文学\"}" +
            "]}}";
        
        ObjectMapper mapper = new ObjectMapper();
        Map<String, Object> data = mapper.readValue(jsonString, Map.class);
        
        // 查询所有技术类书籍的标题和价格
        Expression<Object> expr = jmespath.compile("store.books[?category=='技术'].[title, price]");
        Object result = expr.search(data);
        System.out.println("技术书籍: " + result);
        
        // 查询价格低于40的书籍标题
        Expression<Object> expr2 = jmespath.compile("store.books[?price < `40`].title");
        Object result2 = expr2.search(data);
        System.out.println("低价书籍: " + result2);
    }
    
    // 复杂过滤和投影
    public static void complexFiltering(JmesPath<Object> jmespath) {
        System.out.println("\n=== 复杂过滤和投影 ===");
        
        Map<String, Object> data = new HashMap<>();
        List<Map<String, Object>> products = Arrays.asList(
            createProduct("笔记本电脑", "电子产品", 5999, 4.5),
            createProduct("智能手机", "电子产品", 3999, 4.3),
            createProduct("书籍", "文化用品", 45, 4.7),
            createProduct("耳机", "电子产品", 299, 4.2)
        );
        data.put("products", products);
        
        // 查询电子产品中评分高于4.3的产品名称和价格
        Expression<Object> expr = jmespath.compile(
            "products[?category=='电子产品' && rating > `4.3`].{name: name, price: price}"
        );
        Object result = expr.search(data);
        System.out.println("高评分电子产品: " + result);
        
        // 计算平均价格
        Expression<Object> expr2 = jmespath.compile("avg(products[*].price)");
        Object result2 = expr2.search(data);
        System.out.println("平均价格: " + result2);
    }
    
    private static Map<String, Object> createProduct(String name, String category, 
                                                   int price, double rating) {
        Map<String, Object> product = new HashMap<>();
        product.put("name", name);
        product.put("category", category);
        product.put("price", price);
        product.put("rating", rating);
        return product;
    }
}

4. Maven 完整配置

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
                             http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    
    <groupId>com.example</groupId>
    <artifactId>jmespath-demo</artifactId>
    <version>1.0.0</version>
    
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    
    <dependencies>
        <!-- JMESPath 核心依赖 -->
        <dependency>
            <groupId>io.burt</groupId>
            <artifactId>jmespath-jcf</artifactId>
            <version>0.5.1</version>
        </dependency>
        
        <!-- 可选: Jackson 用于 JSON 处理 -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.15.2</version>
        </dependency>
    </dependencies>
</project>

主要特性

1. 简单易用: API 设计简洁，学习成本低
2. 类型安全: 编译时检查表达式语法
3. 高性能: 表达式编译后可以重复使用
4. 标准兼容: 完全支持 JMESPath 规范
5. 线程安全: 运行时环境线程安全

这个库特别适合处理复杂的 JSON 数据查询和转换任务。