@AutoConfiguration // 这是一个自动配置类
public class ValidatorConfig {

    @Bean
    public Validator validator(MessageSource messageSource) {
        LocalValidatorFactoryBean factoryBean = new LocalValidatorFactoryBean();
        
        // 【核心一】关联 Spring 的 MessageSource
        // 告诉校验器：不要用你自己的默认 message，
        // 去 Spring 的 i18n 资源文件(messages_zh_CN.properties)里找
        factoryBean.setValidationMessageSource(messageSource);
        
        // 【核心二】设置实现提供者
        factoryBean.setProviderClass(HibernateValidator.class);

        // ... 设置 fail_fast ...
        
        factoryBean.afterPropertiesSet();
        return factoryBean.getValidator();
    }
}

// 位于 ValidatorConfig.java 的 @Bean 方法中
Properties properties = new Properties();
// 【核心三】设置“快速失败”为 true
properties.setProperty("hibernate.validator.fail_fast", "true");
factoryBean.setValidationProperties(properties);

package org.dromara.demo.controller;

import jakarta.validation.constraints.*; // 导入 jakarta.validation 包
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.dromara.common.core.domain.R;
import org.dromara.common.doc.annotation.SaIgnore;
import org.springframework.validation.annotation.Validated; // 导入 Spring 的 @Validated
import org.springframework.web.bind.annotation.*;

/**
 * Validation 校验框架实战
 */
@SaIgnore // 忽略权限认证，方便测试
@Slf4j
@RestController
@RequestMapping("/validate")
// @Validated // 暂不开启，场景二再开启
public class ValidateController {

    /**
     * 模拟用于接收参数的 DTO
     * @Data (Lombok) 会自动生成 getter/setter
     */
    @Data
    static class Student {
        // ... 我们将在这里添加校验注解 ...
    }
    
    // ... 我们将在这里添加测试接口 ...
}

// ... 位于 ValidateController 内部 ...
@Data
static class Student {

    @NotBlank(message = "姓名不能为空")
    @Size(min = 2, max = 10, message = "姓名长度必须在 {min} 到 {max} 之间")
    private String name;
    
    @NotNull(message = "年龄不能为空")
    @Min(value = 1, message = "年龄必须大于等于 {value}")
    private Integer age;
    
    @NotBlank(message = "邮箱不能为空")
    @Email(message = "邮箱格式不正确")
    private String email;
    
    @Pattern(regexp = "^[a-zA-Z0-9_]+$", message = "英文名只能包含字母、数字、下划线")
    private String enName;
}

// ... 位于 ValidateController ...
    /**
     * 场景一：校验 Request Body (JSON)
     * @Validated 注解是关键
     */
    @PostMapping("/valid4")
    public R<Student> valid4(@Validated @RequestBody Student student) {
        log.info("校验通过，Student: {}", student);
        return R.ok(student);
    }

// ...
@Slf4j
@RestController
@RequestMapping("/validate")
@Validated // 【关键】将注解加在类上
public class ValidateController {
    // ...

// ...
    /**
     * 场景二：校验 Query 参数
     * 依赖类上的 @Validated 和参数上的 @NotBlank
     */
    @GetMapping("/valid2")
    public R<String> valid2(@NotBlank(message = "姓名不能为空") String name) {
        log.info("校验通过，name: {}", name);
        return R.ok(name);
    }
// ...

// 位于 ruoyi-admin/src/main/resources/i18n/messages_zh_CN.properties
// user.email.not.blank=邮箱不能为空

// 位于 ValidateController.Student
@Data
static class Student {
    // ...
        @NotBlank(message = "{user.email.not.blank}") // 使用 {} 包裹 i18n 键
        @Email(message = "{user.email.not.valid}") // 使用已存在的国际化键
        private String email;
    // ...
}

// AddGroup.java
public interface AddGroup {
}

// EditGroup.java
public interface EditGroup {
}

// QueryGroup.java
public interface QueryGroup {
}

// ... 位于 ValidateController 内部 ...
import org.dromara.common.core.validate.AddGroup;
import org.dromara.common.core.validate.EditGroup;
// ...
@Data
static class Student {
    
    // 1. id: 只有在 Edit 组时才校验
    @NotNull(message = "ID 不能为空", groups = EditGroup.class)
    private Long id;

    // 2. name: 只有在 Add 组时才校验 "必填"
    @NotBlank(message = "姓名不能为空", groups = AddGroup.class) 
    // Size 校验在 Add 和 Edit 时都生效
    @Size(min = 2, max = 10, message = "姓名长度...", groups = {AddGroup.class, EditGroup.class})
    private String name;
    
    // 3. age: 在 Add 组时必填
    @NotNull(message = "年龄不能为空", groups = AddGroup.class)
    @Min(value = 1, message = "...", groups = {AddGroup.class, EditGroup.class})
    private Integer age;
    
    // 4. email: 在 Add 和 Edit 组时，都必填
    @NotBlank(message = "邮箱不能为空", groups = {AddGroup.class, EditGroup.class})
    @Email(message = "...", groups = {AddGroup.class, EditGroup.class})
    private String email;
}

// ... 位于 ValidateController ...
    /**
     * 场景三：【新增】校验 (激活 AddGroup)
     */
    @PostMapping("/add")
    public R<Student> addStudent(
        // 激活 AddGroup.class
        @Validated(AddGroup.class) @RequestBody Student student
    ) {
        log.info("【Add】校验通过: {}", student);
        return R.ok(student);
    }

    /**
     * 场景四：【修改】校验 (激活 EditGroup)
     */
    @PutMapping("/edit")
    public R<Student> editStudent(
        // 激活 EditGroup.class
        @Validated(EditGroup.class) @RequestBody Student student
    ) {
        log.info("【Edit】校验通过: {}", student);
        return R.ok(student);
    }

@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class ValidatorUtils {

    // 1. 在类加载时，就从 Spring 容器中获取 ValidatorConfig 里配置好的校验器
    private static final Validator VALIDATOR = SpringUtils.getBean(Validator.class);

    /**
     * 校验对象
     *
     * @param obj    待校验对象
     * @param groups 待校验的校验组
     */
    public static void validate(Object obj, Class<?>... groups) {
        // 2. 调用校验器的 validate 方法
        Set<ConstraintViolation<Object>> violations = VALIDATOR.validate(obj, groups);
        
        // 3. 如果 violations 集合不为空，说明有错误
        if (!violations.isEmpty()) {
            // 4. 提取错误信息并抛出异常
            // ... (省略了提取 message 的逻辑)
            throw new ConstraintViolationException(message, violations);
        }
    }
}

// 在 MyServiceImpl.java 中
public void createStudent(Student student) {
    
    // 1. @Validated 在 Controller 已经校验了 AddGroup
    
    // 2. Service 层填充额外数据
    String extraInfo = otherService.getExtraInfo();
    student.setExtra(extraInfo); // 假设 extra 字段有 @NotBlank(groups = ServiceCheck.class)
    
    // 3. 【痛点】@Validated 在这里无效
    // 4. 【解决方案】在 Service 层手动调用 ValidatorUtils
    ValidatorUtils.validate(student, ServiceCheck.class); 
    
    // 5. 校验通过，安全入库
    mapper.insert(student);
}

// ... 位于 ValidateController.java ...

    /**
     * 场景五：手动校验 (ValidatorUtils)
     * 注意：@RequestBody 前面【没有】@Validated
     */
    @PostMapping("/valid7")
    public R<Student> valid7(@RequestBody Student student) {
        
        log.info("--- 1. 进入方法体，尚未校验 ---");
        
        // 我们手动调用 ValidatorUtils，并指定校验 AddGroup
        ValidatorUtils.validate(student, AddGroup.class);
        
        // 如果上面一行抛了异常，这里就不会执行
        log.info("--- 2. 手动校验 AddGroup 通过 ---");

        // 我们也可以一次校验多个分组
        // ValidatorUtils.validate(student, AddGroup.class, EditGroup.class);

        return R.ok(student);
    }
// ...

public enum UserTypeEnum {
    ADMIN("00", "管理员"),
    USER("01", "普通用户");
    
    @Getter
    private final String code;
    // ...
}

@EnumPattern(
    type = UserTypeEnum.class, // 1. 指定枚举类
    fieldName = "code",         // 2. 指定要匹配的字段名
    message = "用户类型不正确，必须是 00 或 01"
)
private String userType;

@Documented
@Target({METHOD, FIELD, ...}) // 声明可以用于字段、方法参数等
@Retention(RUNTIME) // 运行时保留，反射才能读到
@Constraint(validatedBy = {EnumPatternValidator.class}) // 【核心】指定校验逻辑实现类
public @interface EnumPattern {

    /**
     * 需要校验的枚举类型
     */
    Class<? extends Enum<?>> type();

    /**
     * 枚举类型校验值字段名称 (例如 "code")
     * 需确保该字段实现了 getter 方法 (例如 getCode())
     */
    String fieldName();

    String message() default "输入值不在枚举范围内";

    Class<?>[] groups() default {};
    // ...
}

public class EnumPatternValidator implements ConstraintValidator<EnumPattern, String> {

    private EnumPattern annotation; // 用于存储注解实例

    @Override
    public void initialize(EnumPattern annotation) {
        // 1. 校验器初始化时，把注解实例存起来
        this.annotation = annotation;
    }

    @Override
    public boolean isValid(String value, ConstraintValidatorContext constraintValidatorContext) {
        // value 是前端传入的字段值 (例如 "01")
        if (StringUtils.isNotBlank(value)) {
            
            // 2. 从注解中获取要匹配的字段名 (例如 "code")
            String fieldName = annotation.fieldName();
            
            // 3. 遍历枚举的所有实例 (例如 UserTypeEnum.ADMIN, UserTypeEnum.USER)
            for (Object e : annotation.type().getEnumConstants()) {
                
                // 4. 【核心】使用反射工具类，动态调用 getter
                // e.g., ReflectUtils.invokeGetter(UserTypeEnum.ADMIN, "code") 
                // 返回 "00"
                if (value.equals(ReflectUtils.invokeGetter(e, fieldName))) {
                    return true; // 匹配成功，校验通过
                }
            }
        }
        // 5. 如果值为空，或循环结束都没匹配到，校验失败
        return false;
    }
}

// 在 DTO 中使用
@DictPattern(
    dictType = "sys_user_status", // 1. 指定要查的字典类型
    message = "用户状态必须是字典 {dictType} 中的有效值"
)
private String status; // 前端传入 "0", "1"

@Constraint(validatedBy = DictPatternValidator.class) // 【核心】指定实现类
@Target({ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface DictPattern {

    /**
     * 字典类型，如 "sys_user_sex"
     */
    String dictType();

    String separator() default ","; // 支持 "0,1" 这种多选值的校验

    String message() default "字典值无效";
    // ...
}

public class DictPatternValidator implements ConstraintValidator<DictPattern, String> {

    private String dictType;
    private String separator;

    @Override
    public void initialize(DictPattern annotation) {
        // 1. 初始化时，存储字典类型
        this.dictType = annotation.dictType();
        this.separator = annotation.separator();
    }

    @Override
    public boolean isValid(String value, ConstraintValidatorContext context) {
        if (StringUtils.isBlank(dictType) || StringUtils.isBlank(value)) {
            // 注意：这里返回 false。如果允许为空，应使用 @DictPattern + @NotBlank(allowNull=true)
            return false;
        }
        
        // 2. 【核心】从 Spring 容器中“手动”获取 DictService
        // DictService 是 common-core 提供的、已实现字典缓存的服务
        DictService dictService = SpringUtils.getBean(DictService.class);
        
        // 3. 调用服务，查询字典（DictService 内部会走 Redis 缓存）
        // getDictLabel 会检查 value 是否存在于 dictType 中
        String dictLabel = dictService.getDictLabel(dictType, value, separator);
        
        // 4. 如果能查到 Label (不为空)，说明这个 value 是合法的
        return StringUtils.isNotBlank(dictLabel);
    }
}