JSON多维度校验及自定义校验报告生成方案咨询

Here's a robust, annotation-friendly third approach that addresses all your requirements while keeping maintenance manageable even with 200+ fields:

Core Approach: Jackson + Bean Validation 2.0 (JSR380) + Custom Constraints #

This combines Jackson's JSON parsing with standard Bean Validation annotations (plus custom extensions for conditional logic) to handle all four validation steps in a unified flow, avoiding the pain points of your previous solutions.

1. Unified JSON Format Validation & POJO Conversion #

Instead of writing separate error parsing logic, wrap Jackson's deserialization in a global exception handler to convert JsonProcessingException (and its subclasses like JsonParseException for invalid JSON, JsonMappingException for type mismatches) directly into your custom validation report format.

Example code snippet for exception handling:

@ControllerAdvice
public class JsonValidationExceptionHandler {

    @ExceptionHandler(JsonProcessingException.class)
    public ResponseEntity<CustomValidationReport> handleJsonErrors(JsonProcessingException ex) {
        CustomValidationReport report = new CustomValidationReport();
        if (ex instanceof JsonParseException) {
            report.addError("JSON_FORMAT_INVALID", "Invalid JSON syntax: " + ex.getOriginalMessage());
        } else if (ex instanceof JsonMappingException) {
            String fieldPath = ((JsonMappingException) ex).getPath().stream()
                    .map(JsonMappingException.Reference::getFieldName)
                    .collect(Collectors.joining("."));
            report.addError("FIELD_TYPE_MISMATCH", "Field '" + fieldPath + "' has invalid type: " + ex.getOriginalMessage());
        }
        return ResponseEntity.badRequest().body(report);
    }
}

2. Annotation-Based Field Constraint Validation (For 200+ Fields) #

Leverage standard JSR380 annotations directly on your POJO fields—this is far more maintainable than JSON Schema for large payloads, as constraints are tied directly to the fields they apply to.

Example POJO snippet:

public class LargePayload {
    @NotNull(message = "Field 'id' is required")
    @Size(min = 10, max = 30, message = "Field 'id' must be between 10-30 characters")
    private String id;

    @NotNull(message = "Field 'status' is required")
    @Pattern(regexp = "ACTIVE|INACTIVE", message = "Field 'status' must be 'ACTIVE' or 'INACTIVE'")
    private String status;

    // ... 197+ other fields with appropriate annotations
}

For custom constraints (e.g., a specific business rule for a field), create reusable custom annotations:

@Constraint(validatedBy = CustomLengthValidator.class)
@Target({FIELD})
@Retention(RUNTIME)
public @interface CustomLength {
    String message() default "Field length is invalid";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
    int min() default 0;
    int max() default Integer.MAX_VALUE;
}

// Validator implementation
public class CustomLengthValidator implements ConstraintValidator<CustomLength, String> {
    private int min;
    private int max;

    @Override
    public void initialize(CustomLength constraintAnnotation) {
        this.min = constraintAnnotation.min();
        this.max = constraintAnnotation.max();
    }

    @Override
    public boolean isValid(String value, ConstraintValidatorContext context) {
        return value != null && value.length() >= min && value.length() <= max;
    }
}

3. Handling Conditional Dependencies (IF-THEN-ELSE Logic) #

For conditional rules (e.g., "if fieldA is 'valueA', fieldB must be 'valueB'"), use one of two approaches:

Option A: Simple Conditions with @AssertTrue

Add a validation method directly to your POJO for straightforward conditional checks:

public class LargePayload {
    private String fieldA;
    private String fieldB;

    @AssertTrue(message = "When fieldA is 'valueA', fieldB must be 'valueB'")
    public boolean isFieldBConditional() {
        if ("valueA".equals(fieldA)) {
            return "valueB".equals(fieldB);
        }
        return true; // No constraint if fieldA isn't 'valueA'
    }

    // Getters/setters
}

Option B: Reusable Conditional Constraints

For complex or reusable conditional logic, create a custom annotation:

@Constraint(validatedBy = ConditionalMatchValidator.class)
@Target({TYPE})
@Retention(RUNTIME)
public @interface ConditionalMatch {
    String message() default "Conditional field constraint violated";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};

    String triggerField();
    String triggerValue();
    String targetField();
    String targetValue();
}

// Validator implementation (uses reflection to access fields)
public class ConditionalMatchValidator implements ConstraintValidator<ConditionalMatch, Object> {
    private String triggerField;
    private String triggerValue;
    private String targetField;
    private String targetValue;

    @Override
    public void initialize(ConditionalMatch constraintAnnotation) {
        this.triggerField = constraintAnnotation.triggerField();
        this.triggerValue = constraintAnnotation.triggerValue();
        this.targetField = constraintAnnotation.targetField();
        this.targetValue = constraintAnnotation.targetValue();
    }

    @Override
    public boolean isValid(Object obj, ConstraintValidatorContext context) {
        try {
            Field trigger = obj.getClass().getDeclaredField(triggerField);
            trigger.setAccessible(true);
            Object triggerVal = trigger.get(obj);

            if (triggerValue.equals(triggerVal)) {
                Field target = obj.getClass().getDeclaredField(targetField);
                target.setAccessible(true);
                Object targetVal = target.get(obj);
                return targetValue.equals(targetVal);
            }
            return true;
        } catch (NoSuchFieldException | IllegalAccessException e) {
            throw new RuntimeException("Failed to validate conditional constraint", e);
        }
    }
}

Then apply it to your POJO:

@ConditionalMatch(
    triggerField = "fieldA",
    triggerValue = "valueA",
    targetField = "fieldB",
    targetValue = "valueB",
    message = "When fieldA is 'valueA', fieldB must equal 'valueB'"
)
public class LargePayload {
    // Fields...
}

4. Unified Custom Validation Report #

After deserializing to the POJO, use a Bean Validator (like Hibernate Validator) to run all constraint checks, then map the Set<ConstraintViolation<T>> to your custom report format:

@Service
public class PayloadValidator {
    private final Validator validator;

    public PayloadValidator(Validator validator) {
        this.validator = validator;
    }

    public CustomValidationReport validate(LargePayload payload) {
        CustomValidationReport report = new CustomValidationReport();
        Set<ConstraintViolation<LargePayload>> violations = validator.validate(payload);
        for (ConstraintViolation<LargePayload> violation : violations) {
            String fieldPath = violation.getPropertyPath().toString();
            String errorMessage = violation.getMessage();
            report.addError("FIELD_CONSTRAINT_VIOLATION", "Field '" + fieldPath + "': " + errorMessage);
        }
        return report;
    }
}

Why This Beats Your Previous Solutions #

• No dual parsers: Jackson handles JSON parsing, and exceptions are converted directly to your report format in one place.
• Maintainable for 200+ fields: Annotation-based constraints live alongside the POJO fields, making it easy to update or debug individual fields without editing a massive JSON Schema.
• Full conditional support: Custom annotations or @AssertTrue handle IF-THEN-ELSE logic without relying on niche JSON Schema v7 libraries.
• Standard ecosystem: Uses widely supported libraries (Jackson, Hibernate Validator) with strong community support.

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