Rest Assured JSONPath 泛型值提取：构建可重用工具函数

public static Object getJsonPathValue(String path, Response response) {
    return response.jsonPath().getObject(path, Object.class);
}

// 这种尝试是错误的，会导致编译错误或运行时异常
public static <T> T getJsonPathValue(String path, Response response) {
    // 编译错误：T.class 是无效的
    return response.jsonPath().getObject(path, T.class);
}

import io.restassured.response.Response;
import io.restassured.path.json.JsonPathException; // 引入JsonPathException

public class JsonPathExtractor {

    /**
     * 从Rest Assured响应中，根据JSONPath提取指定类型的值。
     *
     * @param <T>      期望返回的类型。
     * @param path     JSONPath表达式，用于定位要提取的值。
     * @param response Rest Assured的Response对象。
     * @param type     期望返回值的Class对象，例如 String.class, Integer.class, User.class。
     * @return 提取到的指定类型的值，如果JSONPath未找到或类型不匹配，可能返回null或抛出异常。
     * @throws JsonPathException 如果JSONPath表达式无效或类型转换失败。
     */
    public static <T> T getJsonPathValue(String path, Response response, Class<T> type) {
        if (response == null || response.body() == null) {
            throw new IllegalArgumentException("Response or response body cannot be null.");
        }
        if (path == null || path.trim().isEmpty()) {
            throw new IllegalArgumentException("JSONPath cannot be null or empty.");
        }

        try {
            return response.jsonPath().getObject(path, type);
        } catch (JsonPathException e) {
            // 可以选择在这里处理异常，例如记录日志，或重新抛出更具体的业务异常
            System.err.println("Error extracting JSON value for path '" + path + "' with type '" + type.getName() + "': " + e.getMessage());
            throw e; // 或者返回null，取决于业务需求
        }
    }

    // 示例：一个简单的POJO类
    public static class User {
        private String name;
        private int age;

        // 构造函数、Getter和Setter
        public User() {}

        public User(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String getName() { return name; }
        public void setName(String name) { this.name = name; }
        public int getAge() { return age; }
        public void setAge(int age) { this.age = age; }

        @Override
        public String toString() {
            return "User{name='" + name + "', age=" + age + '}';
        }
    }
}

{
  "status": "success",
  "data": {
    "id": "12345",
    "name": "Alice",
    "age": 30,
    "isActive": true,
    "address": {
      "street": "123 Main St",
      "city": "Anytown"
    },
    "users": [
      {"name": "Bob", "age": 25},
      {"name": "Charlie", "age": 35}
    ]
  }
}

import io.restassured.RestAssured;
import io.restassured.response.Response;
import static io.restassured.RestAssured.given;

public class JsonPathExtractionDemo {

    public static void main(String[] args) {
        // 模拟一个Rest Assured Response对象
        // 在实际应用中，response会通过API调用获得
        String jsonString = "{\n" +
                "  \"status\": \"success\",\n" +
                "  \"data\": {\n" +
                "    \"id\": \"12345\",\n" +
                "    \"name\": \"Alice\",\n" +
                "    \"age\": 30,\n" +
                "    \"isActive\": true,\n" +
                "    \"address\": {\n" +
                "      \"street\": \"123 Main St\",\n" +
                "      \"city\": \"Anytown\"\n" +
                "    },\n" +
                "    \"users\": [\n" +
                "      {\"name\": \"Bob\", \"age\": 25},\n" +
                "      {\"name\": \"Charlie\", \"age\": 35}\n" +
                "    ]\n" +
                "  }\n" +
                "}";

        Response response = RestAssured.given().body(jsonString).when().get("/"); // 示例响应

        // 提取字符串
        String status = JsonPathExtractor.getJsonPathValue("$.status", response, String.class);
        System.out.println("Status: " + status); // Output: Status: success

        // 提取整数
        Integer age = JsonPathExtractor.getJsonPathValue("$.data.age", response, Integer.class);
        System.out.println("Age: " + age); // Output: Age: 30

        // 提取布尔值
        Boolean isActive = JsonPathExtractor.getJsonPathValue("$.data.isActive", response, Boolean.class);
        System.out.println("Is Active: " + isActive); // Output: Is Active: true

        // 提取自定义POJO对象
        JsonPathExtractor.User user = JsonPathExtractor.getJsonPathValue("$.data.users[0]", response, JsonPathExtractor.User.class);
        System.out.println("First User: " + user); // Output: First User: User{name='Bob', age=25}

        // 提取不存在的路径（会抛出JsonPathException）
        try {
            String nonExistentValue = JsonPathExtractor.getJsonPathValue("$.data.nonExistentField", response, String.class);
            System.out.println("Non-existent value: " + nonExistentValue);
        } catch (JsonPathException e) {
            System.out.println("Caught expected exception for non-existent path: " + e.getMessage());
        }

        // 提取类型不匹配的值（会抛出JsonPathException）
        try {
            Integer nameAsInteger = JsonPathExtractor.getJsonPathValue("$.data.name", response, Integer.class);
            System.out.println("Name as Integer: " + nameAsInteger);
        } catch (JsonPathException e) {
            System.out.println("Caught expected exception for type mismatch: " + e.getMessage());
        }
    }
}