Hibernate @Embeddable 组合字段加载后验证策略

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

@Target({ElementType.TYPE}) // 作用于类/接口/枚举
@Retention(RetentionPolicy.RUNTIME) // 运行时保留
@Constraint(validatedBy = ValidDataCombinationValidator.class) // 指定验证器
@Documented
public @interface ValidDataCombination {
    String message() default "数据类型与值不匹配或组合无效"; // 默认错误消息

    Class<?>[] groups() default {}; // 允许分组验证

    Class<? extends Payload>[] payload() default {}; // 允许携带额外信息
}

import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;

public class ValidDataCombinationValidator implements ConstraintValidator<ValidDataCombination, MyEmbeddable> {

    @Override
    public void initialize(ValidDataCombination constraintAnnotation) {
        // 可以在这里初始化验证器，例如获取注解中的参数
    }

    @Override
    public boolean isValid(MyEmbeddable embeddable, ConstraintValidatorContext context) {
        if (embeddable == null) {
            return true; // 如果embeddable对象为null，则不进行验证，或者根据业务逻辑返回false
        }

        MyType type = embeddable.getType();
        String value = embeddable.getValue(); // 假设value是String类型

        // 核心组合验证逻辑
        if (type == null || value == null || value.trim().isEmpty()) {
            // 基础非空检查，或者根据业务决定是否允许null/空
            return false;
        }

        switch (type) {
            case URL:
                // 假设有一个简单的URL验证逻辑
                if (!value.startsWith("http://") && !value.startsWith("https://")) {
                    // 自定义错误消息，指向特定字段
                    context.disableDefaultConstraintViolation();
                    context.buildConstraintViolationWithTemplate("URL格式不正确，必须以http://或https://开头")
                           .addPropertyNode("value") // 指向错误的字段
                           .addConstraintViolation();
                    return false;
                }
                break;
            case EMAIL:
                // 假设有一个简单的邮箱验证逻辑
                if (!value.contains("@") || !value.contains(".")) {
                    context.disableDefaultConstraintViolation();
                    context.buildConstraintViolationWithTemplate("邮箱格式不正确，缺少@或.")
                           .addPropertyNode("value")
                           .addConstraintViolation();
                    return false;
                }
                break;
            case PHONE:
                // 假设电话号码是纯数字
                if (!value.matches("\d+")) {
                    context.disableDefaultConstraintViolation();
                    context.buildConstraintViolationWithTemplate("电话号码必须是纯数字")
                           .addPropertyNode("value")
                           .addConstraintViolation();
                    return false;
                }
                break;
            default:
                // 对于未知类型，可以默认返回true或false
                break;
        }
        return true; // 所有验证通过
    }
}

import javax.persistence.Embeddable;
import javax.validation.constraints.NotNull;

@Embeddable
@ValidDataCombination // 应用自定义类级别约束
public class MyEmbeddable {

    public enum MyType {
        URL, EMAIL, PHONE, OTHER
    }

    @NotNull
    private MyType type;

    @NotNull
    private String value; // 简化示例，使用String作为value类型

    // 无参构造函数是Hibernate必需的
    public MyEmbeddable() {}

    public MyEmbeddable(MyType type, String value) {
        this.type = type;
        this.value = value;
    }

    // Getters and Setters
    public MyType getType() {
        return type;
    }

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

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "MyEmbeddable{" +
               "type=" + type +
               ", value='" + value + ''' +
               '}';
    }
}

import javax.persistence.Embedded;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.validation.Valid; // 导入@Valid

@Entity
public class MyEntity {
    @Id
    @GeneratedValue
    private Long id;

    private String name;

    @Embedded
    @Valid // 关键：确保验证级联到MyEmbeddable对象
    private MyEmbeddable data;

    // Getters and Setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public MyEmbeddable getData() {
        return data;
    }

    public void setData(MyEmbeddable data) {
        this.data = data;
    }
}

import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.Validator;
import javax.validation.ValidatorFactory;
import java.util.Set;

public class ValidationService {

    private final Validator validator;

    public ValidationService() {
        ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
        this.validator = factory.getValidator();
    }

    public <T> Set<ConstraintViolation<T>> validate(T object) {
        return validator.validate(object);
    }

    public static void main(String[] args) {
        ValidationService service = new ValidationService();

        // 模拟一个加载后的MyEntity实例
        MyEmbeddable validEmbeddable = new MyEmbeddable(MyEmbeddable.MyType.URL, "https://www.example.com");
        MyEntity entity1 = new MyEntity();
        entity1.setName("Test 1");
        entity1.setData(validEmbeddable);

        Set<ConstraintViolation<MyEntity>> violations1 = service.validate(entity1);
        System.out.println("Entity 1 Violations: " + violations1.isEmpty()); // 预期为true (无违规)

        MyEmbeddable invalidEmbeddable = new MyEmbeddable(MyEmbeddable.MyType.URL, "not-a-url");
        MyEntity entity2 = new MyEntity();
        entity2.setName("Test 2");
        entity2.setData(invalidEmbeddable);

        Set<ConstraintViolation<MyEntity>> violations2 = service.validate(entity2);
        System.out.println("Entity 2 Violations: " + violations2.isEmpty()); // 预期为false (有违规)
        violations2.forEach(v -> System.out.println("  " + v.getPropertyPath() + ": " + v.getMessage()));
        // 预期输出：data.value: URL格式不正确，必须以http://或https://开头
    }
}