Spring Boot中如何实现配置属性的交叉验证？（多属性组合校验场景）

我的应用有以下配置属性：

employeeEngine.callLegacy=true
employeeEngine.callNewApi=true

我希望允许以下几种调用方式：仅调用遗留服务，同时调用遗留服务与新API接口（获取相同数据），或仅调用新API接口。唯一不允许的情况是两者都不调用！

我已经在业务服务中实现了简单的自定义验证（属性已注入到类字段中）：

public class BusinessService {
    @Value("employeeEngine.callLegacy:true")
    private boolean callLegacy;

    @Value("employeeEngine.callNewApi:true")
    private boolean callNewApi;

    // constructor
    // public methods with business logic    

    private boolean someInternalMethod() {
        if (!callLegacy && !callNewApi) {
            LOGGER.error("Bad!!");
            throw new BusinessException("At least one of {callLegacy} or {callNewApi} should be set"); 
        }
    }
}

但我觉得这类验证放在@ConfigurationProperties类中会更合适。请问这种方式可行吗？或者有没有更好的多属性组合验证方法？

另外，有没有办法获取属性值用于日志记录或异常消息展示？

回答 #

1. 用@ConfigurationProperties做组合验证完全可行，且更合理 #

将配置验证放在配置属性类中是最佳实践，能在应用启动阶段完成验证，避免业务逻辑执行时才发现配置错误。实现步骤如下：

首先定义带验证的配置属性类，结合@Validated和@AssertTrue实现自定义逻辑：

import jakarta.validation.constraints.AssertTrue;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.validation.annotation.Validated;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@ConfigurationProperties(prefix = "employeeEngine")
@Validated
public class EmployeeEngineProperties {
    private static final Logger LOGGER = LoggerFactory.getLogger(EmployeeEngineProperties.class);
    
    private boolean callLegacy;
    private boolean callNewApi;

    // Getters and Setters

    @AssertTrue(message = "At least one of callLegacy or callNewApi must be enabled")
    public boolean isAtLeastOneEnabled() {
        boolean isValid = callLegacy || callNewApi;
        if (!isValid) {
            LOGGER.error("Invalid config: callLegacy={}, callNewApi={} - at least one must be true", callLegacy, callNewApi);
        }
        return isValid;
    }
}

然后在配置类中启用该配置属性：

import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableConfigurationProperties(EmployeeEngineProperties.class)
public class AppConfig {
    // 其他配置逻辑
}

应用启动时Spring会自动验证约束，若两者都为false，直接抛出ConstraintViolationException，阻止应用启动，比业务逻辑中验证更及时。

2. 更通用的多属性组合验证方案 #

如果需要在多个配置类复用类似验证，可以自定义注解约束：

步骤1：定义自定义约束注解

import jakarta.validation.Constraint;
import jakarta.validation.Payload;
import java.lang.annotation.*;

@Target({ElementType.TYPE, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = AtLeastOneEnabledValidator.class)
public @interface AtLeastOneEnabled {
    String message() default "At least one of the specified properties must be true";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};

    // 指定需要检查的字段名，增强通用性
    String[] value() default {"callLegacy", "callNewApi"};
}

步骤2：实现约束验证器

import jakarta.validation.ConstraintValidator;
import jakarta.validation.ConstraintValidatorContext;
import java.lang.reflect.Field;

public class AtLeastOneEnabledValidator implements ConstraintValidator<AtLeastOneEnabled, Object> {
    private String[] fieldNames;

    @Override
    public void initialize(AtLeastOneEnabled constraintAnnotation) {
        this.fieldNames = constraintAnnotation.value();
    }

    @Override
    public boolean isValid(Object value, ConstraintValidatorContext context) {
        try {
            for (String fieldName : fieldNames) {
                Field field = value.getClass().getDeclaredField(fieldName);
                field.setAccessible(true);
                if ((Boolean) field.get(value)) {
                    return true;
                }
            }
            return false;
        } catch (NoSuchFieldException | IllegalAccessException e) {
            throw new IllegalArgumentException("Invalid field name in @AtLeastOneEnabled", e);
        }
    }
}

步骤3：在配置属性类上使用注解

@ConfigurationProperties(prefix = "employeeEngine")
@Validated
@AtLeastOneEnabled(
        value = {"callLegacy", "callNewApi"},
        message = "callLegacy={callLegacy}, callNewApi={callNewApi}: at least one must be enabled"
)
public class EmployeeEngineProperties {
    private boolean callLegacy;
    private boolean callNewApi;

    // Getters and Setters
}

3. 获取属性值用于日志或异常消息 #

在@ConfigurationProperties类中可以直接访问属性值，拼接到日志或异常消息里：

• 日志记录：在验证方法中直接打印当前属性值，如上面示例中的LOGGER.error语句。
• 自定义异常消息：如果需要抛出自定义异常而非JSR-380默认异常，可以在验证方法中主动抛出：

@AssertTrue(message = "")
public boolean isAtLeastOneEnabled() {
    boolean isValid = callLegacy || callNewApi;
    if (!isValid) {
        String errorMsg = String.format("Invalid config: callLegacy=%b, callNewApi=%b - at least one must be enabled", callLegacy, callNewApi);
        LOGGER.error(errorMsg);
        throw new IllegalArgumentException(errorMsg);
    }
    return isValid;
}

另外，在业务类中注入EmployeeEngineProperties后，也可以直接获取属性值用于日志：

import org.springframework.stereotype.Service;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Service
public class BusinessService {
    private static final Logger LOGGER = LoggerFactory.getLogger(BusinessService.class);
    private final EmployeeEngineProperties properties;

    // 构造注入
    public BusinessService(EmployeeEngineProperties properties) {
        this.properties = properties;
    }

    public void processEmployeeData() {
        LOGGER.info("Using config: callLegacy={}, callNewApi={}", properties.isCallLegacy(), properties.isCallNewApi());
        // 业务逻辑
    }
}

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