如何使用Rest-assured Java API解析并验证JSON响应？

我来给你详细讲讲怎么用Rest-Assured解析并验证你拿到的这个JSON响应，结合你提到的代码示例，分两种常用方法来演示：

先把目标JSON响应贴出来，方便对照：

[ 
  { "Emp": "00000", "Emp_ID": 901, "First_Name": "agar", "Last_Name": "vedi", "Country": "India", "EmpLocation": "Noida" }, 
  { "Emp": "001", "Emp_ID": 383, "First_Name": "Manoj", "Last_Name": "jee", "Country": "India", "EmpLocation": "Noida" } 
]

1. 先搞定依赖（Maven为例） #

确保你的项目里已经引入Rest-Assured的核心依赖，这样才能正常调用它的API：

<!-- Rest-Assured核心依赖 -->
<dependency>
    <groupId>io.rest-assured</groupId>
    <artifactId>rest-assured</artifactId>
    <version>5.3.0</version>
    <scope>test</scope>
</dependency>
<!-- 如果用JUnit 5做断言，需要额外引入 -->
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-api</artifactId>
    <version>5.9.2</version>
    <scope>test</scope>
</dependency>

2. 方法一：用JsonPath直接解析验证 #

这是最灵活的方式，不用额外创建类，适合快速验证单字段或批量数据，完全适配你提到的httpRequest.request()代码逻辑：

import io.restassured.RestAssured;
import io.restassured.http.Method;
import io.restassured.response.Response;
import io.restassured.specification.RequestSpecification;
import io.restassured.path.json.JsonPath;
import static org.junit.jupiter.api.Assertions.*;

public class EmployeeValidationTest {
    public static void main(String[] args) {
        // 1. 设置API基础地址
        RestAssured.baseURI = "你的API基础URL";
        
        // 2. 创建请求实例
        RequestSpecification httpRequest = RestAssured.given();
        
        // 3. 发送GET请求（和你提到的代码示例逻辑一致）
        Response response = httpRequest.request(Method.GET, "你的接口路径，比如/employees");
        
        // 4. 将响应转为JsonPath对象，方便解析
        JsonPath jsonPath = response.jsonPath();
        
        // ---------- 开始各种验证操作 ----------
        
        // 验证员工总数是2
        int employeeCount = jsonPath.getList("$").size();
        assertEquals(2, employeeCount, "员工数量不符合预期");
        
        // 验证第一个员工的名字是"agar"
        String firstEmpFirstName = jsonPath.getString("[0].First_Name");
        assertEquals("agar", firstEmpFirstName, "第一个员工的名字不正确");
        
        // 验证第二个员工的ID是383
        int secondEmpId = jsonPath.getInt("[1].Emp_ID");
        assertEquals(383, secondEmpId, "第二个员工的ID不正确");
        
        // 批量验证所有员工的国家都是India
        java.util.List<String> allCountries = jsonPath.getList("Country");
        for (String country : allCountries) {
            assertEquals("India", country, "存在员工的国家不是India");
        }
    }
}

这里的$代表整个JSON根节点，[0]表示数组的第一个元素，用.就能直接访问对象内的字段，逻辑非常直观。

3. 方法二：映射到POJO类进行验证 #

如果你的接口响应结构固定，这种方法更优雅，面向对象的方式更适合复杂结构的长期维护：

第一步：创建Employee POJO类 #

public class Employee {
    private String Emp;
    private int Emp_ID;
    private String First_Name;
    private String Last_Name;
    private String Country;
    private String EmpLocation;

    // 必须保留无参构造函数（Rest-Assured反射需要）
    public Employee() {}

    // 全参构造函数（可选，方便测试时实例化）
    public Employee(String emp, int emp_ID, String first_Name, String last_Name, String country, String empLocation) {
        Emp = emp;
        Emp_ID = emp_ID;
        First_Name = first_Name;
        Last_Name = last_Name;
        Country = country;
        EmpLocation = empLocation;
    }

    // 所有字段的Getter和Setter方法（必须要有，Rest-Assured需要访问字段）
    public String getEmp() { return Emp; }
    public void setEmp(String emp) { Emp = emp; }
    public int getEmp_ID() { return Emp_ID; }
    public void setEmp_ID(int emp_ID) { Emp_ID = emp_ID; }
    public String getFirst_Name() { return First_Name; }
    public void setFirst_Name(String first_Name) { First_Name = first_Name; }
    public String getLast_Name() { return Last_Name; }
    public void setLast_Name(String last_Name) { Last_Name = last_Name; }
    public String getCountry() { return Country; }
    public void setCountry(String country) { Country = country; }
    public String getEmpLocation() { return EmpLocation; }
    public void setEmpLocation(String empLocation) { EmpLocation = empLocation; }
}

第二步：将响应转为POJO列表并验证 #

import io.restassured.RestAssured;
import io.restassured.http.Method;
import io.restassured.response.Response;
import io.restassured.specification.RequestSpecification;
import java.util.List;
import static org.junit.jupiter.api.Assertions.*;

public class EmployeePojoValidationTest {
    public static void main(String[] args) {
        // 1. 设置API基础地址
        RestAssured.baseURI = "你的API基础URL";
        
        // 2. 创建请求实例
        RequestSpecification httpRequest = RestAssured.given();
        
        // 3. 发送GET请求
        Response response = httpRequest.request(Method.GET, "你的接口路径");
        
        // 4. 直接将响应转为List<Employee>
        List<Employee> employeeList = response.jsonPath().getList("", Employee.class);
        
        // ---------- 开始验证 ----------
        
        // 验证列表长度
        assertEquals(2, employeeList.size());
        
        // 验证第一个员工的完整信息
        Employee firstEmp = employeeList.get(0);
        assertEquals("00000", firstEmp.getEmp());
        assertEquals(901, firstEmp.getEmp_ID());
        assertEquals("agar", firstEmp.getFirst_Name());
        assertEquals("vedi", firstEmp.getLast_Name());
        assertEquals("India", firstEmp.getCountry());
        assertEquals("Noida", firstEmp.getEmpLocation());
        
        // 验证第二个员工的完整信息
        Employee secondEmp = employeeList.get(1);
        assertEquals("001", secondEmp.getEmp());
        assertEquals(383, secondEmp.getEmp_ID());
        assertEquals("Manoj", secondEmp.getFirst_Name());
        assertEquals("jee", secondEmp.getLast_Name());
        assertEquals("India", secondEmp.getCountry());
        assertEquals("Noida", secondEmp.getEmpLocation());
    }
}

这种方法的优势是代码更整洁，后续如果接口字段有变更，只需要修改POJO类即可，维护成本更低。

内容的提问来源于stack exchange，提问作者aditya rawat