新老系统切换响应结果差异对比

新老系统切换响应结果差异对比

方案

现在要做系统迁移，要对比新系统和老系统某个查询接口出参的差异对比，给出一个方案

1.定义标准

• 确定要比较的具体接口，包括接口名称、请求方法（GET, POST等）
• 列出接口的预期输出参数，包括参数名称、类型、是否必填、默认值等

2.数据获取:

• 对新旧系统接口分别发起请求，捕获并记录响应结果。
• 使用curl命令或编程方式（如Java的HttpURLConnection或RestTemplate）来调用接口。

3.数据解析:

• 解析接口返回的JSON或XML数据，提取出每个参数的值。
• 可以使用JSON库（如Java的org.json或com.google.gson）来解析JSON数据。

4.参数对比:

• 按照比较标准，对比新旧系统的响应中每个参数是否存在、值是否相同。
• 如果参数数量不同，或者参数值有差异，记录下来。

5.编写自动化脚本:

• 为了提高效率，可以编写自动化脚本来执行上述步骤，例如使用Python或Java。
• 脚本应能处理多个接口，并输出详细的比较报告。

6.异常处理:

• 处理可能的网络问题、超时或接口错误，确保对比的完整性。
• 记录任何异常情况和错误信息。

7.生成报告:

• 生成对比报告，列出所有差异，包括新增、删除和修改的参数。
• 报告应包含接口名称、具体参数、新旧值以及差异描述。

8.人工审查:

• 除了自动化工具，还需要进行人工审查，确保理解每个差异的原因。
• 根据需要与开发团队讨论，确定是否需要调整新系统的接口设计。

9.持续监控:

• 在迁移后的一段时间内，持续监控新接口的行为，确保没有未预见的问题。

通过以上步骤，你可以有效地对比新旧系统查询接口的出参差异，并为系统迁移做好充分准备。

示例

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.oldSystem.OldSystemService;
import com.fasterxml.newSystem.NewSystemService;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;

public class SystemMigrationComparator {

    private static final String OLD_SYSTEM_API_URL = "http://old-system/api/query";
    private static final String NEW_SYSTEM_API_URL = "http://new-system/api/query";

    public static void main(String[] args) {
        RestTemplate restTemplate = new RestTemplate();
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);

        // 获取旧系统接口响应
        ResponseEntity<String> oldResponse = restTemplate.exchange(OLD_SYSTEM_API_URL, HttpMethod.GET, new HttpEntity<>(headers), String.class);
        JsonNode oldJson = mapper.readTree(oldResponse.getBody());

        // 获取新系统接口响应
        ResponseEntity<String> newResponse = restTemplate.exchange(NEW_SYSTEM_API_URL, HttpMethod.GET, new HttpEntity<>(headers), String.class);
        JsonNode newJson = mapper.readTree(newResponse.getBody());

        // 对比出参
        compareOutputs(oldJson, newJson);
    }

    private static void compareOutputs(JsonNode oldJson, JsonNode newJson) {
        oldJson.fieldNames().forEachRemaining(oldField -> {
            if (newJson.has(oldField)) {
                JsonNode oldValue = oldJson.get(oldField);
                JsonNode newValue = newJson.get(oldField);

                if (!oldValue.equals(newValue)) {
                    System.out.println("Field: " + oldField + ", Old Value: " + oldValue + ", New Value: " + newValue);
                }
            } else {
                System.out.println("Field: " + oldField + " is removed in the new system");
            }
        });

        newJson.fieldNames().forEachRemaining(newField -> {
            if (!oldJson.has(newField)) {
                System.out.println("Field: " + newField + " is newly added in the new system");
            }
        });
    }
}

这个示例中，我们首先创建了一个RestTemplate实例，然后设置HTTP头为JSON类型。接着，我们分别调用旧系统和新系统的接口，并将响应内容转换为JSON节点。最后，我们遍历两个JSON对象的字段，对比它们的差异，并打印出有变化的字段。

请注意，你需要根据实际情况替换OLD_SYSTEM_API_URL和NEW_SYSTEM_API_URL，并处理可能出现的异常。如果接口需要身份验证或其他特定的请求头，你也需要在HttpHeaders中设置。此外，你需要导入com.fasterxml.jackson.databind.ObjectMapper并初始化它（在这个例子中，我假设你有一个全局的mapper实例）。

mapper.readTree是什么?

mapper.readTree是com.fasterxml.jackson.databind.ObjectMapper类中的一个方法，它用于将JSON格式的文本转换为JsonNode对象。JsonNode是Jackson库中表示JSON数据结构的一个抽象类，你可以通过它来遍历和操作JSON数据。以下是一个使用readTree方法的典型Java代码示例：

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;

public class JsonExample {
    public static void main(String[] args) throws Exception {
        // JSON字符串
        String jsonString = "{\"name\":\"John\", \"age\":30, \"city\":\"New York\"}";

        // 创建 ObjectMapper 实例
        ObjectMapper mapper = new ObjectMapper();

        // 使用 readTree 方法将 JSON 字符串转换为 JsonNode 对象
        JsonNode jsonNode = mapper.readTree(jsonString);

        // 遍历 JsonNode 并访问属性
        if (jsonNode.isObject()) {
            ObjectNode objectNode = (ObjectNode) jsonNode;
            System.out.println("Name: " + objectNode.get("name").asText());
            System.out.println("Age: " + objectNode.get("age").asInt());
            System.out.println("City: " + objectNode.get("city").asText());
        }
    }
}

在这个例子中，我们创建了一个ObjectMapper实例，然后调用readTree方法将JSON字符串转换为JsonNode对象。接着，我们检查这个节点是否是对象类型（isObject()），如果是，我们将其转换为ObjectNode以便更容易地访问其属性。然后，我们打印出name、age和city的值。

ArrayNode的处理

在Java中，你可以使用com.fasterxml.jackson.databind.ObjectMapper和com.fasterxml.jackson.databind.node.ArrayNode来遍历和比较两个ArrayNode。以下是一个示例，展示了如何遍历并比较两个ArrayNode中对应元素的每个字段：

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;

import java.io.IOException;
import java.util.Iterator;

public class ArrayNodeComparator {

    private static final ObjectMapper mapper = new ObjectMapper();

    public static void main(String[] args) {
        String json1 = "[{\"name\":\"Alice\", \"age\":30}, {\"name\":\"Bob\", \"age\":35}]";
        String json2 = "[{\"name\":\"Alice\", \"age\":30}, {\"name\":\"Eve\", \"age\":35}]";

        ArrayNode arrayNode1 = parseToJsonArray(json1);
        ArrayNode arrayNode2 = parseToJsonArray(json2);

        compareArrayNodes(arrayNode1, arrayNode2);
    }

    private static ArrayNode parseToJsonArray(String jsonString) {
        try {
            return (ArrayNode) mapper.readTree(jsonString);
        } catch (IOException e) {
            throw new RuntimeException("Failed to parse JSON", e);
        }
    }

    private static void compareArrayNodes(ArrayNode array1, ArrayNode array2) {
        Iterator<ObjectNode> iterator1 = array1.iterator();
        Iterator<ObjectNode> iterator2 = array2.iterator();

        while (iterator1.hasNext() && iterator2.hasNext()) {
            ObjectNode obj1 = iterator1.next();
            ObjectNode obj2 = iterator2.next();

            compareObjects(obj1, obj2);
        }

        if (iterator1.hasNext() || iterator2.hasNext()) {
            System.out.println("Array lengths are different");
        }
    }

    private static void compareObjects(ObjectNode obj1, ObjectNode obj2) {
        Iterator<String> fieldIterator = obj1.fieldNames();

        while (fieldIterator.hasNext()) {
            String fieldName = fieldIterator.next();
            JsonNode node1 = obj1.get(fieldName);
            JsonNode node2 = obj2.get(fieldName);

            if (!node1.equals(node2)) {
                System.out.println("Field [" + fieldName + "] differs: " + node1 + " != " + node2);
            }
        }
    }
}

这个示例首先将JSON字符串转换为ArrayNode，然后遍历并比较两个数组中的每个元素。如果有不等的字段，它会打印出来。请注意，这个示例假设JSON对象的字段类型相同，如果字段类型不同，你可能需要添加额外的逻辑来处理这种情况。