Spring Boot中如何使用Enum类返回校验注解的提示信息？

Great question! The core issue here is that Java annotation attributes require compile-time constant expressions, and accessing an Enum's instance field like MyEnum.EMAIL.messageCode isn't a compile-time constant—it's resolved at runtime. That's why IDEA throws the "Attribute value must be constant" error.

Since you must use an Enum, here are a few solid solutions tailored to different scenarios:

Solution 1: Custom Validation Annotation + Validator (Most Direct Approach) #

Create a custom annotation that accepts your Enum as a parameter, then build a validator that pulls the message code from the Enum when validation fails. This keeps your Enum as the single source of truth.

Step 1: Define the Custom Annotation #

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

@Target({ElementType.FIELD, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = EmailWithEnumValidator.class)
public @interface EmailWithEnumMessage {
    // Required boilerplate for validation annotations
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};

    // Allow specifying which Enum instance to use for the message
    MyEnum messageSource() default MyEnum.EMAIL;
}

Step 2: Build the Validator #

This validator reuses the standard EmailValidator for actual email validation, then replaces the error message with the value from your Enum:

import jakarta.validation.ConstraintValidator;
import jakarta.validation.ConstraintValidatorContext;
import org.hibernate.validator.internal.constraintvalidators.bv.EmailValidator;

public class EmailWithEnumValidator implements ConstraintValidator<EmailWithEnumMessage, String> {
    private final EmailValidator emailValidator = new EmailValidator();
    private MyEnum targetEnum;

    @Override
    public void initialize(EmailWithEnumMessage annotation) {
        this.targetEnum = annotation.messageSource();
    }

    @Override
    public boolean isValid(String email, ConstraintValidatorContext context) {
        boolean isValid = emailValidator.isValid(email, context);
        
        if (!isValid) {
            // Disable the default error message and use our Enum's value instead
            context.disableDefaultConstraintViolation();
            context.buildConstraintViolationWithTemplate(targetEnum.messageCode)
                   .addConstraintViolation();
        }
        
        return isValid;
    }
}

Step 3: Use the Custom Annotation in Your Request Class #

public class VerifyAccountRequest {
    @EmailWithEnumMessage(messageSource = MyEnum.EMAIL)
    private String email;
}

Solution 2: Message Interpolation (For Spring/Hibernate Validator Users) #

If you're using Spring Validation or Hibernate Validator, you can leverage message interpolation to resolve Enum values dynamically. This lets you keep using the standard @Email annotation while pulling messages from your Enum.

Step 1: Update the Annotation to Use a Placeholder #

public class VerifyAccountRequest {
    // Use a custom placeholder that your interpolator will resolve
    @Email(message = "{enum.message.email}")
    private String email;
}

Step 2: Create a Custom Message Interpolator #

This class will intercept the placeholder and fetch the corresponding value from your Enum:

import jakarta.validation.MessageInterpolator;
import org.hibernate.validator.messageinterpolation.ResourceBundleMessageInterpolator;

public class EnumMessageInterpolator implements MessageInterpolator {
    private final MessageInterpolator delegate = new ResourceBundleMessageInterpolator();

    @Override
    public String interpolate(String messageTemplate, Context context) {
        // Check if the template is our custom Enum placeholder
        if (messageTemplate.equals("{enum.message.email}")) {
            return MyEnum.EMAIL.messageCode;
        }
        // Fall back to default interpolation for other messages
        return delegate.interpolate(messageTemplate, context);
    }

    @Override
    public String interpolate(String messageTemplate, Context context, java.util.Locale locale) {
        return interpolate(messageTemplate, context);
    }
}

Step 3: Register the Interpolator in Spring #

If you're using Spring, configure the validator to use your custom interpolator:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;

@Configuration
public class ValidationConfig {
    @Bean
    public LocalValidatorFactoryBean validator() {
        LocalValidatorFactoryBean factory = new LocalValidatorFactoryBean();
        factory.setMessageInterpolator(new EnumMessageInterpolator());
        return factory;
    }
}

Solution 3: Static Constants in Enum (Quick Hack, If Permitted) #

If you can modify your Enum to include static constants for the message codes, you can reference those directly in the annotation (since static final fields are compile-time constants):

public enum MyEnum {
    EMAIL(EMAIL_MESSAGE_CODE, "info"),
    ;

    public static final String EMAIL_MESSAGE_CODE = "2";
    public String messageCode;
    public String info;

    MyEnum(String messageCode, String info) {
        this.messageCode = messageCode;
        this.info = info;
    }
}

Then use it like this:

public class VerifyAccountRequest {
    @Email(message = MyEnum.EMAIL_MESSAGE_CODE)
    private String email;
}

This is the simplest approach but couples the static constant to the Enum instance—use it only if you don't mind this tight coupling.

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