如何用Java从可变JSON文件生成SQL语句？基于OpenAPI规范建SQL表

我来帮你搞定这个问题——从OpenAPI的JSON定义生成SQL表，同时用Java动态处理可变JSON生成SQL语句，咱们一步步来：

一、从给定的Order定义生成SQL表 #

先看你提供的OpenAPI里的Order定义：

"definitions": {
  "Order": {
    "type": "object",
    "properties": {
      "id": { "type": "integer", "format": "int64" },
      "petId": { "type": "integer", "format": "int64" },
      "quantity": { "type": "integer", "format": "int32" },
      "shipDate": { "type": "string", "format": "date-time" },
      "status": { "type": "string", "description": "Order Status", "enum": [ "placed", "approved", "delivered" ] }
    }
  }
}

根据这个定义，我们可以直接生成对应的SQL表结构。这里要注意SQL的命名规范（用下划线代替驼峰）、类型映射，还有枚举值的约束：

CREATE TABLE orders (
    id BIGINT PRIMARY KEY,
    pet_id BIGINT,
    quantity INT,
    ship_date DATETIME,
    status VARCHAR(50) COMMENT 'Order Status',
    CHECK (status IN ('placed', 'approved', 'delivered'))
);

简单解释下： #

• id作为主键，用BIGINT对应OpenAPI的int64类型；
• petId转成pet_id（SQL常用风格），同样用BIGINT；
• quantity对应INT（匹配int32）；
• shipDate转成ship_date，用DATETIME对应date-time格式；
• status用VARCHAR(50)存储，加上字段注释，同时通过CHECK约束限制只能取枚举里的有效值，保证数据合法性。

二、用Java从可变JSON（OpenAPI定义）生成SQL语句 #

如果你的OpenAPI定义是动态变化的，想要用Java自动生成SQL，我们可以通过解析JSON+类型映射+字符串拼接来实现，下面是完整的实现思路和代码示例：

步骤1：引入JSON解析依赖 #

我们用Jackson来解析JSON，如果你用Maven，先在pom.xml里加依赖：

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.15.2</version>
</dependency>

步骤2：定义Java类映射OpenAPI结构 #

先创建几个POJO类，用来映射OpenAPI里的definitions、schema和property结构，方便Jackson解析：

import com.fasterxml.jackson.annotation.JsonProperty;
import java.util.Map;

class OpenApiDefinition {
    @JsonProperty("definitions")
    private Map<String, Schema> definitions;

    public Map<String, Schema> getDefinitions() {
        return definitions;
    }

    public void setDefinitions(Map<String, Schema> definitions) {
        this.definitions = definitions;
    }
}

class Schema {
    private String type;
    private Map<String, Property> properties;

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public Map<String, Property> getProperties() {
        return properties;
    }

    public void setProperties(Map<String, Property> properties) {
        this.properties = properties;
    }
}

class Property {
    private String type;
    private String format;
    private String description;
    private String[] enums;

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getFormat() {
        return format;
    }

    public void setFormat(String format) {
        this.format = format;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public String[] getEnums() {
        return enums;
    }

    public void setEnums(String[] enums) {
        this.enums = enums;
    }
}

步骤3：核心生成逻辑 #

写一个工具类，实现从OpenAPI JSON到SQL语句的转换，包含类型映射、命名转换、约束生成等逻辑：

import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class OpenApiToSqlGenerator {

    public static void main(String[] args) throws IOException {
        // 读取你的OpenAPI JSON文件
        ObjectMapper mapper = new ObjectMapper();
        OpenApiDefinition openApi = mapper.readValue(new File("openapi.json"), OpenApiDefinition.class);

        // 遍历每个定义（比如Order、Pet等）
        for (Map.Entry<String, Schema> entry : openApi.getDefinitions().entrySet()) {
            String tableName = toSnakeCase(entry.getKey()); // 驼峰转下划线，避免SQL关键字冲突
            Schema schema = entry.getValue();
            List<String> columnDefinitions = new ArrayList<>();

            // 遍历每个字段，生成列定义
            for (Map.Entry<String, Property> propEntry : schema.getProperties().entrySet()) {
                String columnName = toSnakeCase(propEntry.getKey());
                Property prop = propEntry.getValue();
                String sqlType = mapToSqlType(prop.getType(), prop.getFormat());

                StringBuilder columnDef = new StringBuilder(columnName).append(" ").append(sqlType);

                // 添加字段注释（如果有描述）
                if (prop.getDescription() != null && !prop.getDescription().isEmpty()) {
                    columnDef.append(" COMMENT '").append(prop.getDescription()).append("'");
                }

                // 添加枚举约束（如果有enum值）
                if (prop.getEnums() != null && prop.getEnums().length > 0) {
                    String enumValues = String.join("', '", prop.getEnums());
                    columnDef.append(", CHECK (").append(columnName).append(" IN ('").append(enumValues).append("'))");
                }

                columnDefinitions.add(columnDef.toString());
            }

            // 拼接成完整的CREATE TABLE语句
            StringBuilder createTableSql = new StringBuilder("CREATE TABLE ").append(tableName).append(" (\n");
            createTableSql.append("    ").append(String.join(",\n    ", columnDefinitions));
            
            // 自动把id字段设为主键（可以根据需求调整这个逻辑）
            if (schema.getProperties().containsKey("id")) {
                createTableSql.append(",\n    PRIMARY KEY (id)");
            }
            
            createTableSql.append("\n);");

            // 输出或者保存SQL语句
            System.out.println("生成的SQL语句：");
            System.out.println(createTableSql.toString());
            System.out.println("------------------------");
        }
    }

    // 驼峰命名转下划线命名的工具方法
    private static String toSnakeCase(String camelCase) {
        return camelCase.replaceAll("([a-z])([A-Z])", "$1_$2").toLowerCase();
    }

    // OpenAPI类型到SQL类型的映射逻辑，可以根据需求扩展
    private static String mapToSqlType(String type, String format) {
        if ("integer".equals(type)) {
            return "int64".equals(format) ? "BIGINT" : "INT";
        } else if ("string".equals(type)) {
            return "date-time".equals(format) ? "DATETIME" : "VARCHAR(255)";
        } else if ("boolean".equals(type)) {
            return "BOOLEAN";
        } else if ("number".equals(type)) {
            return "DECIMAL(10,2)";
        }
        // 默认用VARCHAR(255)处理未匹配的类型
        return "VARCHAR(255)";
    }
}

功能说明 #

• 自动命名转换：把OpenAPI里的驼峰命名（比如petId）转成SQL常用的下划线命名（pet_id），避免和SQL关键字冲突；
• 类型映射：支持常见的OpenAPI类型到SQL类型的转换，还可以扩展mapToSqlType方法支持更多类型；
• 约束与注释：自动把description转成字段注释，把enum转成CHECK约束；
• 动态处理：不管你的OpenAPI里有多少个定义（比如Order、Pet、User），都会自动生成对应的SQL表。

内容的提问来源于stack exchange，提问作者Justin Oldfield