入参校验自定义枚举

范围输入检查，输入的值只能是建议输入的值

@RangeInputCheck(message = "字段状态必须在（1=Java，2=Python，3=Go）内", ranges = {"1", "2", "3"})

package com.abi.common.constant;

import javax.validation.Constraint;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
import javax.validation.Payload;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Objects;
import java.util.function.Predicate;

/**
 * 范围输入检查，输入的值只能是建议输入的值
 */
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = RangeInputCheck.RangeInputCheckValidator.class)
public @interface RangeInputCheck {

    String message() default "";

    String[] ranges() default {};

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

    Class<? extends Payload>[] payload() default {};

    class RangeInputCheckValidator implements ConstraintValidator<RangeInputCheck, Object> {

        protected Predicate<Object> predicate = value -> false;

        @Override
        public void initialize(RangeInputCheck constraintAnnotation) {
            predicate = value -> {

                // 空不做验证，如果空值需要被验证，可用其他注解
                if (value == null) {
                    return true;
                }

                String[] ranges = constraintAnnotation.ranges();
                List<String> rangeList = Arrays.asList(ranges);

                if (value instanceof Integer) {
                    return rangeList.contains(String.valueOf(value));
                }

                if (value instanceof String) {
                    return rangeList.contains(value);
                }

                if (value instanceof Collection<?>) {
                    return ((Collection<?>) value).stream()
                            .filter(Objects::nonNull)
                            .map(String::valueOf)
                            .allMatch(rangeList::contains);
                }

                return false;
            };
        }

        @Override
        public boolean isValid(Object o, ConstraintValidatorContext constraintValidatorContext) {
            return predicate.test(o);
        }

    }

}

* 一般用在集合属性上，泛型为一个对象
* 检查对象指定的属性，要么一个有值，要么必须全部有值

package com.abi.common.constant;

import org.springframework.util.StringUtils;

import javax.validation.Constraint;
import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
import javax.validation.Payload;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.Collection;
import java.util.function.Predicate;
import java.util.stream.Stream;

/**
 * 一般用在集合属性上，泛型为一个对象
 * 检查对象指定的属性，要么一个有值，要么必须全部有值
 */
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = RangeInputPropertyCheck.RangeInputPropertyCheckValidator.class)
public @interface RangeInputPropertyCheck {

    String message() default "";

    String[] properties() default {};

    boolean onlyAllHasText() default false;

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

    Class<? extends Payload>[] payload() default {};

    class RangeInputPropertyCheckValidator implements ConstraintValidator<RangeInputPropertyCheck, Object> {

        protected Predicate<Object> predicate = value -> false;

        @Override
        public void initialize(RangeInputPropertyCheck constraintAnnotation) {
            predicate = value -> {

                // 空不做验证，如果空值需要被验证，可用其他注解
                if (value == null) {
                    return true;
                }

                String[] properties = constraintAnnotation.properties();
                boolean onlyAllHasText = constraintAnnotation.onlyAllHasText();
                Stream<String> propertiesStream = Arrays.stream(properties);

                if (value instanceof Collection<?>) {
                    for (Object o : (Collection<?>) value) {
                        if (onlyAllHasText) {
                            if (this.getStream(propertiesStream, o.getClass(), o)
                                    .noneMatch(str -> StringUtils.hasText((CharSequence) str))) {
                                return false;
                            }
                        } else {
                            if (!getStream(propertiesStream, o.getClass(), o)
                                    .allMatch(str -> StringUtils.hasText((CharSequence) str))) {
                                return false;
                            }
                        }

                    }
                }

                return true;
            };
        }

        public Stream<Object> getStream(Stream<String> propertiesStream, Class<?> aClass, Object o) {
            return propertiesStream
                    .map(property -> {
                        Field declaredField;
                        try {
                            declaredField = aClass.getDeclaredField(property);
                            declaredField.setAccessible(true);
                            return declaredField.get(o);
                        } catch (NoSuchFieldException | IllegalAccessException e) {
                            throw new RuntimeException(e);
                        }
                    });
        }

        @Override
        public boolean isValid(Object o, ConstraintValidatorContext constraintValidatorContext) {
            return predicate.test(o);
        }

    }


}

请自由扩展!