如何高效验证含随机值的JSON输出？正则匹配方案对比

我需要验证输出JSON文件的有效性，包含两项核心要求：

• 确认所需的所有键值对均存在于文件中；
• 验证值的格式符合预期（如时间戳、字符串、整数等）。

由于部分值（如timestamp、id）为随机生成，无法直接与同结构的参考文件做完全匹配对比。

JSON示例文件 #

[
  {
    "metadata": {
      "RecordEnd": 19,
      "Type": null,
      "RecordOffset": 0,
      "Character_Set": "UTF-8",
      "MsgType": 8,
      "Expire": 0,
      "Name": "y1",
      "delivered": false,
      "Timestamp": 1664189426609,
      "UserID": "1jnj2232",
      "Encoding": 273,
      "id": "ID:414d51205120202020210040",
      "DType": "type1"
    }
]

现有两种验证方案 #

方案1：手动构建HashMap匹配正则 #

通过硬编码HashMap存储键与对应正则表达式，逐个遍历键值对做匹配：

HashMap<String,String> metaData = new HashMap();
metaData.put("RecordEnd","\\d+");metaData.put("Type","\\w+");
metaData.put("RecordOffset","\\d+");metaData.put("Character_Set","UTF-8");
metaData.put("MsgType","\\d+");metaData.put("Expire","\\w+");
metaData.put("Name","\\w+");metaData.put("delivered","\\w+");
metaData.put("Timestamp","\\d+");metaData.put("UserID","\\w+");
metaData.put("Encoding","\\d+");metaData.put("id","ID\\:\\w+");
metaData.put("DType","type1");


ObjectMapper mapper = new ObjectMapper();
String json = FileUtils.readFileToString(new File(outputJSONFile),"UTF-8");
json = json.substring(1, json.length() - 1);
Map<?, ?> map = mapper.readValue(json, Map.class);

HashMap<String,Object> metaMap = (HashMap<String, Object>) map.get("metadata");
metaMap.entrySet().forEach(e-> {
  if (!(e.getValue() == null)) {
    if (e.getValue().toString().matches(metaData.get(e.getKey()))) {
      log.info(e + "- Matched");
    } else {
      throw new RuntimeException(
          "MetaData key " + e.getKey() + " data is invalid");
    }
  }
});

但当字段数量超过40个时，手动配置HashMap会异常繁琐，代码可读性也会大幅下降。

方案2：静态基准JSON文件对比 #

计划创建包含所有键及对应正则值的静态JSON文件，以此为基准与输出JSON文件做对比，目前尚未落地。

请问第二种方案是否更高效，或者存在更合适的验证方案？

关于方案2的效率分析 #

方案2相比手动构建HashMap确实有明显优势：

• 可维护性提升：把正则规则抽离到JSON配置文件中，无需修改代码就能调整校验逻辑，字段越多越能体现管理优势，可读性也更好；
• 复用性更强：基准JSON可以作为通用配置在不同场景复用，不用在代码里硬编码规则。

但它也存在局限：

• 核心校验逻辑和方案1差别不大，只是把规则从代码移到了配置文件，仍需自己编写读取、遍历、匹配的逻辑，没有减少核心工作量；
• 正则匹配无法精准校验JSON原生数据类型，比如无法区分"19"（字符串）和19（整数），也没法直接校验布尔值delivered的类型合法性。

更合适的验证方案 #

1. 使用JSON Schema校验 #

这是行业标准的JSON结构与格式验证方案，完美匹配你的需求：

• 强制校验指定键是否存在；
• 精准校验值的原生数据类型（整数、布尔、字符串等）；
• 支持正则匹配字符串格式、枚举值限制、数值范围校验等。

先编写对应你的JSON结构的Schema文件：

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "array",
  "items": {
    "type": "object",
    "required": ["metadata"],
    "properties": {
      "metadata": {
        "type": "object",
        "required": ["RecordEnd", "Type", "RecordOffset", "Character_Set", "MsgType", "Expire", "Name", "delivered", "Timestamp", "UserID", "Encoding", "id", "DType"],
        "properties": {
          "RecordEnd": {"type": "integer"},
          "Type": {"type": ["null", "string"]},
          "RecordOffset": {"type": "integer"},
          "Character_Set": {"type": "string", "const": "UTF-8"},
          "MsgType": {"type": "integer"},
          "Expire": {"type": "integer"},
          "Name": {"type": "string", "pattern": "^\\w+$"},
          "delivered": {"type": "boolean"},
          "Timestamp": {"type": "integer"},
          "UserID": {"type": "string", "pattern": "^\\w+$"},
          "Encoding": {"type": "integer"},
          "id": {"type": "string", "pattern": "^ID:\\w+$"},
          "DType": {"type": "string", "const": "type1"}
        }
      }
    }
  }
}

然后用Java的JSON Schema校验库（如org.everit.json.schema）实现校验：

import org.everit.json.schema.Schema;
import org.everit.json.schema.loader.SchemaLoader;
import org.json.JSONObject;
import org.json.JSONTokener;

import java.io.FileReader;

public class JsonSchemaValidator {
    public static void validate(String jsonPath, String schemaPath) throws Exception {
        JSONObject json = new JSONObject(new JSONTokener(new FileReader(jsonPath)));
        JSONObject schemaJson = new JSONObject(new JSONTokener(new FileReader(schemaPath)));
        Schema schema = SchemaLoader.load(schemaJson);
        schema.validate(json); // 校验不通过会直接抛出ValidationException
    }
}

这种方式标准化程度高，规则清晰，字段越多越能体现效率，无需自己编写遍历匹配逻辑，直接用成熟库完成所有校验。

2. 基于POJO的注解校验 #

如果你的JSON结构固定，可以先定义对应的POJO类，然后用Hibernate Validator这类注解式校验框架实现验证：
先定义POJO：

import javax.validation.constraints.NotNull;
import javax.validation.constraints.Pattern;
import javax.validation.constraints.PositiveOrZero;

public class Metadata {
    @NotNull
    @PositiveOrZero
    private Integer RecordEnd;

    private String Type; // 允许null值

    @NotNull
    @PositiveOrZero
    private Integer RecordOffset;

    @NotNull
    @Pattern(regexp = "UTF-8")
    private String Character_Set;

    @NotNull
    private Integer MsgType;

    @NotNull
    @PositiveOrZero
    private Integer Expire;

    @NotNull
    @Pattern(regexp = "^\\w+$")
    private String Name;

    @NotNull
    private Boolean delivered;

    @NotNull
    private Long Timestamp;

    @NotNull
    @Pattern(regexp = "^\\w+$")
    private String UserID;

    @NotNull
    private Integer Encoding;

    @NotNull
    @Pattern(regexp = "^ID:\\w+$")
    private String id;

    @NotNull
    @Pattern(regexp = "type1")
    private String DType;

    // 省略getter、setter
}

public class RootObject {
    @NotNull
    private Metadata metadata;

    // 省略getter、setter
}

然后结合Jackson和Hibernate Validator做校验：

import com.fasterxml.jackson.databind.ObjectMapper;
import org.hibernate.validator.HibernateValidator;

import javax.validation.Validation;
import javax.validation.Validator;
import javax.validation.ValidatorFactory;
import java.io.File;
import java.util.Set;

public class PojoValidator {
    private static final Validator validator;

    static {
        ValidatorFactory factory = Validation.byProvider(HibernateValidator.class)
                .configure()
                .buildValidatorFactory();
        validator = factory.getValidator();
    }

    public static void validate(String jsonPath) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        RootObject root = mapper.readValue(new File(jsonPath), RootObject.class);
        Set<?> violations = validator.validate(root);
        if (!violations.isEmpty()) {
            throw new RuntimeException("JSON校验失败：" + violations.toString());
        }
    }
}

这种方式类型安全，校验规则与POJO绑定，代码可读性高，适合后端Java项目中固定结构的JSON校验，同时还能自动完成JSON到POJO的转换，一举两得。

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