一，自定義註解中元註解

1，保留位置：Retention

2，作用目標：Targer

[email protected](ElementType.TYPE)   //介面、類、列舉、註解
    2.2 @Target(ElementType.FIELD) //欄位、列舉的常量
    2.3 @Target(ElementType.METHOD) //方法
    2.4 @Target(ElementType.PARAMETER) //方法引數
    2.5 @Target(ElementType.CONSTRUCTOR)  //建構函式
    2.6 @Target(ElementType.LOCAL_VARIABLE)//區域性變數
    2.7 @Target(ElementType.ANNOTATION_TYPE)//註解
    2.8 @Target(ElementType.PACKAGE) ///包 

3，@Document

    註解將被包含在javadoc中

4，@Inherited

    子類可以繼承父類中的該註解

舉個例子：

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.PARAMETER})
public @interface InEnum {
    Class<? extends Enum> source();
String key() default "";
    boolean useGet() default false;
}

@Retention(RetentionPolicy.RUNTIME
 
)
@Target({ElementType.FIELD, ElementType.PARAMETER})
public @interface InEnumStr {
    Class<? extends Enum> source();
String key();
    boolean useGet() default false;
String split();
}

二，自定義校驗器

1.校驗結果

public class ValidateResult {

    private int code;
    private boolean valid = false;
    private 
 
FailedReason failedReason;
    public static final ValidateResult SUCCESS = new ValidateResult(true);
    private ValidateResult() {

    }

    private ValidateResult(boolean valid) {
        this.valid = valid;
}

    private ValidateResult(boolean valid, int code, FailedReason failedReason) {
        this.valid = valid;
        this.code = code;
        this.failedReason = failedReason;
}

    public static ValidateResult ERROR(int code, FailedReason failedReason) {
        return new ValidateResult(false, code, failedReason);
}

    public boolean isValid() {
        return valid;
}

    public FailedReason getFailedReason() {
        return failedReason;
}

    public int getCode() {
        return code;
}

    public void setCode(int code) {
        this.code = code;
}
}

public class FailedReason {

    private String fieldName;
    private Object fieldValue;
    private String reason;
    private String notice;
    public FailedReason() {
    }

    public FailedReason(String fieldName, String reason) {
        this.fieldName = fieldName;
        this.reason = reason;
}

    public FailedReason(String fieldName, Object fieldValue, String reason) {
        this.fieldName = fieldName;
        this.fieldValue = fieldValue;
        this.reason = reason;
}

    public FailedReason(String fieldName, Object fieldValue, String reason, String notice) {
        this.fieldName = fieldName;
        this.fieldValue = fieldValue;
        this.reason = reason;
        this.notice = notice;
}

    public String getFieldName() {
        return fieldName;
}

    public FailedReason setFieldName(String fieldName) {
        this.fieldName = fieldName;
        return this;
}

    public Object getFieldValue() {
        return fieldValue;
}

    public void setFieldValue(Object fieldValue) {
        this.fieldValue = fieldValue;
}

    public String getReason() {
        return reason;
}

    public FailedReason setReason(String reason) {
        this.reason = reason;
        return this;
}

    public String getNotice() {
        return notice;
}

    public FailedReason setNotice(String notice) {
        this.notice = notice;
        return this;
}

    @Override
public String toString() {
        return JSONObject.toJSONString(this);
}
}

2.支援型別

public class SupportEnumType {
    public static final Logger LOGGER = LoggerFactory.getLogger(SupportEnumType.class);
    static final Set<Class> set = new HashSet<>();
    static {
        set.add(Integer.TYPE);
set.add(Integer.class);
set.add(int.class);
set.add(Long.TYPE);
set.add(Long.class);
set.add(long.class);
set.add(Double.TYPE);
set.add(Double.class);
set.add(double.class);
set.add(Float.TYPE);
set.add(Float.class);
set.add(float.class);
set.add(String.class);
}

    public static boolean support(Class clazz) {
        return set.contains(clazz);
}

    public static Method getMethod(Class clazz, String methodName) {
        try {
            Method method = clazz.getDeclaredMethod(methodName);
            return method;
} catch (Exception e) {
            try {
                Method method = clazz.getMethod(methodName);
                return method;
} catch (Exception ex) {
            }
            LOGGER.error("列舉類{}中，方法{}不存在", clazz.getCanonicalName(), methodName);
LOGGER.error("列舉值獲取異常", e);
}
        return null;
}
}

3.匹配值

public enum MEMBER_TYPE_ENUM {
    PERSON(1, "個人使用者"),
SELLER(2, "商家使用者"),
ENTERPRISE(3, "企業使用者");
MEMBER_TYPE_ENUM(int code, String desc) {
        this.code = code;
        this.desc = desc;
}

    private int code;
    private String desc;
    public int code() {
        return this.code;
}

    public String desc() {
        return this.desc;
}

    public static boolean validate(int code){
        for(MEMBER_TYPE_ENUM item : MEMBER_TYPE_ENUM.values()){
            if(code == item.code()){
                return true;
}
        }
        return false;
}

    public static MEMBER_TYPE_ENUM convert(int code){
        for(MEMBER_TYPE_ENUM item : MEMBER_TYPE_ENUM.values()){
            if(code == item.code()){
                return item;
}
        }
        return null;
}
}

4.校驗器

@Component
public class InEnumValidator extends AbstractAnnotationValidator<InEnum> {

    public static final Logger LOGGER = LoggerFactory.getLogger(InEnumValidator.class);
    static Set<Class> set = new HashSet<>();
@Override
public ValidateResult validate(InEnum inEnum, String paramName, Object paramValue) {
        if (paramValue == null) {
            return ValidateResult.SUCCESS;
}
        if (!SupportEnumType.support(paramValue.getClass())) {
            LOGGER.warn("不支援的型別:{}", paramValue.getClass());
}

        Class<? extends Enum> clazz = inEnum.source();
StringBuilder sb = new StringBuilder();
        boolean validate = false;
String key = inEnum.key();
        if (StringUtils.isNotEmpty(key)) {
            boolean useGetter = inEnum.useGet();
Method method = null;
            if (useGetter) {
                String methodName = "get" + key.substring(0, 1).toUpperCase() + key.substring(1);
method = SupportEnumType.getMethod(clazz, methodName);
} else {
                method = SupportEnumType.getMethod(clazz, key);
}
            if (method == null) {
                throw new RuntimeException("載入列舉校驗器失敗");
}

            for (Object obj : clazz.getEnumConstants()) {
                try {
                    Object value = method.invoke(obj);
sb.append(value).append(",");
                    if (!validate) {
                        boolean result = paramValue.equals(value);
                        if (result) {
                            validate = true;
}
                    }
                } catch (Exception e) {
                    throw new RuntimeException("列舉校驗器執行失敗");
}
            }
        } else {
            Field[] fields = clazz.getFields();
            for (Field field : fields) {
                sb.append(field.getName()).append(",");
                if (field.getName().equals(paramValue)) {
                    validate = true;
                    break;
}
            }
        }

        if (sb.length() > 0) {
            sb.deleteCharAt(sb.length() - 1);
}
        if (!validate) {
            String msg = "引數驗證不通過, " + paramName + "無效的值, 可接受的取值有:" + sb;
            return ValidateResult.ERROR(this.getErrorCode(), new FailedReason(paramName, paramValue, msg, ""));
}
        return ValidateResult.SUCCESS;
}

    @Override
public void afterPropertiesSet() throws Exception {
        register(InEnum.class, this);
}

}

public abstract class AbstractAnnotationValidator<T> implements InitializingBean {

    @Resource
private ValidateProperty validateProperty;
    private static final ConcurrentHashMap<Class<? extends Annotation>, AbstractAnnotationValidator> VALIDATOR_MAP = new ConcurrentHashMap<>();
    protected void register(Class<? extends Annotation> annotationType, AbstractAnnotationValidator validator) {
        VALIDATOR_MAP.putIfAbsent(annotationType, validator);
}

    public abstract ValidateResult validate(T t, String paramName, Object paramValue);
    public static AbstractAnnotationValidator getValidator(Annotation annotation) {
        if (annotation != null) {
            return getValidator(annotation.annotationType());
}
        return null;
}

    public static AbstractAnnotationValidator getValidator(Class<? extends Annotation> annotationType) {
        return VALIDATOR_MAP.get(annotationType);
}

    public static Set<Class<? extends Annotation>> getValidatorAnnotationSet() {
        return VALIDATOR_MAP.keySet();
}

    public boolean isValidAnnotation(Class<? extends Annotation> annotationType) {
        return VALIDATOR_MAP.containsKey(annotationType);
}

    public static boolean hasValidator(Annotation annotation) {
        return VALIDATOR_MAP.containsKey(annotation.annotationType());
}

    public int getErrorCode() {
        return validateProperty.getErrorCode();
}
}

5.校驗器使用

public class TestQueryRequest extends DateRequest {
    
    @ApiModelProperty(value = "1:個人使用者 2:商家使用者 3:企業使用者")
    @InEnum(source = MEMBER_TYPE_ENUM.class, key = "code", useGet = false)
    private Integer memberType;
    public String getMemberTypeStr() {
        return memberTypeStr;
}

    public void setMemberTypeStr(String memberTypeStr) {
        this.memberTypeStr = memberTypeStr;
}

}