如何基于Swagger的JSON Schema对所有JSON文件字段排序（Java+Maven）

核心思路 #

要实现按Swagger定义的JSON Schema字段顺序排序JSON文件，需完成三个核心步骤：

1. 解析Swagger YAML文件，提取目标API模型的字段顺序
2. 读取待处理的JSON文件，解析为Jackson可操作的节点对象
3. 依据提取的字段顺序重新序列化JSON，保证输出字段与Schema定义顺序一致

具体实现步骤 #

1. 添加Maven依赖 #

在pom.xml中引入以下必要依赖：

• Swagger解析库：io.swagger.core.v3:swagger-core和io.swagger.parser.v3:swagger-parser，用于解析Swagger YAML结构
• Jackson处理库：com.fasterxml.jackson.core:jackson-databind和com.fasterxml.jackson.dataformat:jackson-dataformat-yaml，负责JSON与YAML的解析和序列化

<dependencies>
    <!-- Swagger解析依赖 -->
    <dependency>
        <groupId>io.swagger.core.v3</groupId>
        <artifactId>swagger-core</artifactId>
        <version>2.2.15</version>
    </dependency>
    <dependency>
        <groupId>io.swagger.parser.v3</groupId>
        <artifactId>swagger-parser</artifactId>
        <version>2.1.16</version>
    </dependency>
    <!-- Jackson依赖 -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.15.2</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.dataformat</groupId>
        <artifactId>jackson-dataformat-yaml</artifactId>
        <version>2.15.2</version>
    </dependency>
</dependencies>

2. 解析Swagger YAML提取字段顺序 #

编写工具类从Swagger YAML中提取指定模型的字段定义顺序（Swagger会保留模型定义时的字段顺序）：

import io.swagger.v3.oas.models.OpenAPI;
import io.swagger.v3.oas.models.media.Schema;
import io.swagger.v3.parser.OpenAPIV3Parser;
import java.util.List;
import java.util.Map;

public class SwaggerSchemaUtils {
    public static List<String> getFieldOrderFromSchema(String swaggerYamlPath, String schemaName) {
        OpenAPI openAPI = new OpenAPIV3Parser().read(swaggerYamlPath);
        Schema<?> schema = openAPI.getComponents().getSchemas().get(schemaName);
        if (schema == null) {
            throw new IllegalArgumentException("Schema " + schemaName + " not found in Swagger YAML");
        }
        // 提取Schema中定义的字段顺序
        return schema.getProperties().keySet().stream().toList();
    }
}

3. 自定义Jackson序列化实现字段排序 #

通过自定义序列化器，强制按照Schema提取的字段顺序输出JSON，同时保留JSON中额外的未定义字段：

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.databind.node.ObjectNode;
import java.io.IOException;
import java.util.List;

public class JsonFieldSorter {
    public static String sortJsonBySchema(String jsonContent, List<String> fieldOrder) throws IOException {
        ObjectMapper mapper = new ObjectMapper();
        ObjectNode objectNode = mapper.readValue(jsonContent, ObjectNode.class);

        // 注册自定义序列化器
        SimpleModule module = new SimpleModule();
        module.addSerializer(ObjectNode.class, new JsonSerializer<ObjectNode>() {
            @Override
            public void serialize(ObjectNode value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
                gen.writeStartObject();
                // 优先输出Schema定义的字段
                for (String field : fieldOrder) {
                    if (value.has(field)) {
                        gen.writeFieldName(field);
                        serializers.defaultSerializeValue(value.get(field), gen);
                    }
                }
                // 输出Schema未定义的额外字段
                for (String field : value.fieldNames()) {
                    if (!fieldOrder.contains(field)) {
                        gen.writeFieldName(field);
                        serializers.defaultSerializeValue(value.get(field), gen);
                    }
                }
                gen.writeEndObject();
            }
        });

        mapper.registerModule(module);
        return mapper.writerWithDefaultPrettyPrinter().writeValueAsString(objectNode);
    }
}

4. 批量处理JSON文件 #

编写主程序遍历目标目录下的所有JSON文件，完成批量排序处理：

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;

public class JsonBatchProcessor {
    public static void main(String[] args) throws IOException {
        // 配置路径与目标模型名
        String swaggerYamlPath = "path/to/your/swagger.yml";
        String schemaName = "User"; // 替换为Swagger中对应的模型名称
        String jsonDirPath = "path/to/json/test/data";

        // 提取字段顺序
        List<String> fieldOrder = SwaggerSchemaUtils.getFieldOrderFromSchema(swaggerYamlPath, schemaName);

        // 遍历处理所有JSON文件
        File jsonDir = new File(jsonDirPath);
        File[] jsonFiles = jsonDir.listFiles((dir, name) -> name.endsWith(".json"));
        if (jsonFiles == null) {
            return;
        }

        for (File file : jsonFiles) {
            String originalJson = Files.readString(Paths.get(file.getAbsolutePath()));
            String sortedJson = JsonFieldSorter.sortJsonBySchema(originalJson, fieldOrder);
            // 可改为写入新目录避免覆盖原文件
            Files.writeString(Paths.get(file.getAbsolutePath()), sortedJson);
            System.out.println("已处理文件：" + file.getName());
        }
    }
}

注意事项 #

• 若Swagger模型包含嵌套结构，需扩展代码递归解析嵌套Schema的字段顺序
• 若不同JSON文件对应不同Swagger模型，需先识别每个JSON对应的模型，再匹配对应的字段顺序
• 处理超大JSON文件时，建议使用Jackson流式解析（JsonParser）避免内存溢出

内容的提问来源于stack exchange，提问作者Albert Vesker