快速校驗非法字符工具

基於hibernate validator實現快速校驗非法字符提示工具

非空校驗註解器

IfNotNullRegex.java

/**
 * 如果不爲空的攔截驗證
 */
@Target({ ElementType.FIELD })
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = IfNotNullRegexConstraintValidator.class)
public @interface IfNotNullRegex {

    /**
     * 默認錯誤文案
     * @return
     */
    String message() default "非法參數";

    /**
     * 不爲空場景下的正則
     * @return
     */
    String[] regex();

    /**
     * 匹配結果爲 matcher類型 顯示對客文案
     * @return
     */
    boolean[] matcher();

    /**
     * 正則提示的對客文案
     * @return
     */
    String[] regexMsg() default "";

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

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

}

自定義非空校驗註解實現

IfNotNullRegexConstraintValidator.java

import com.google.common.collect.Lists;
import org.hibernate.validator.engine.ConstraintValidatorContextImpl;
import org.hibernate.validator.engine.PathImpl;
import org.springframework.util.ReflectionUtils;

import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
import java.lang.reflect.Field;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * 如果不爲空註解參數實現
 */
public class IfNotNullRegexConstraintValidator implements
                                              ConstraintValidator<IfNotNullRegex, String> {

    /**
     * 正則表達式
     */
    private String[]  regex;

    /**
     * 正則表達式匹配期望結果
     */
    private boolean[] matcher;

    /**
     * 表達式對應的文案
     */
    private String[]  msg;

    /**
     * 合法字符校驗器
     */
    private LegalCharValidBuilder.LegalCharValid legalCharValid = LegalCharValidBuilder.instance().build();

    @Override
    public void initialize(IfNotNullRegex ifNotNull) {
        regex = ifNotNull.regex();
        msg = ifNotNull.regexMsg();
        matcher = ifNotNull.matcher();
        Assert.isTrue(regex.length == ifNotNull.matcher().length, "參數非法");
        // 填充正則消息
        if (regex.length != ifNotNull.regexMsg().length) {
            msg = new String[regex.length];
            fillErrorMsg(ifNotNull.regexMsg(), ifNotNull.message());
        }
    }

    @Override
    public boolean isValid(String str, ConstraintValidatorContext constraintValidatorContext) {
        if (StringUtil.isEmpty(str)) {
            return true;
        }
        boolean flag;
        // 錯誤消息集合
        List<String> errMsgList = Lists.newArrayList();
        for (int i = 0; i < regex.length; i++) {
            flag = str.matches(regex[i]);
            // 如果符合期望匹配就拋出異常
            flag = (flag == matcher[i]);
            if (flag) {
                constraintValidatorContext.disableDefaultConstraintViolation();
                constraintValidatorContext.buildConstraintViolationWithTemplate(msg[i])
                    .addConstraintViolation();
                errMsgList.add(msg[i]);
            }
        }
        // 錯誤消息不爲空  構建錯誤信息數組
        if (!CollectionUtils.isEmpty(errMsgList)) {
            // 校驗非法字符
            Map<Character, Set<Integer>> result = legalCharValid.findUnValidChar(str);
            if (!CollectionUtils.isEmpty(result)) {
                throw new UnLegalCheckException(errMsgList.get(0), errMsgList,
                    getProperties(constraintValidatorContext), result);
            }
            return false;
        }
        return true;
    }

    /**
     * 使用默認的錯誤文案填充正則對應的錯誤碼
     * @param sourceArr
     * @param defaultMsg
     * @return
     */
    private void fillErrorMsg(String[] sourceArr, String defaultMsg) {
        int sourlen = sourceArr.length;
        for (int i = 0; i < msg.length; i++) {
            if (i < sourlen) {
                msg[i] = sourceArr[i];
            } else {
                msg[i] = defaultMsg;
            }
        }
    }

    /**
     * 獲取驗證的字段
     * @param constraintValidatorContext
     * @return
     */
    private String getProperties(ConstraintValidatorContext constraintValidatorContext) {
        try {
            final String BASE_PATH_FIELD = "basePath";
            Field field = ReflectionUtils.findField(ConstraintValidatorContextImpl.class,
                BASE_PATH_FIELD);
            field.setAccessible(true);
            PathImpl path = (PathImpl) field.get(constraintValidatorContext);
            return path.getLeafNode().asString();
        } catch (Exception e) {
            return "";
        }
    }
}

合法字符校驗器

LegalCharValidBuilder.java

/**
 * 合法字符校驗構造器
 */
public class LegalCharValidBuilder {

    /**
     * 基礎合法字符集
     */
    private String  baseLegalChar      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890";

    /**
     * 擴展合法字符集
     */
    private String  extLegalChar       = " /?:()_.,'+";

    /**
     * 是否跳過首字符合法校驗
     */
    private boolean skipFirstCharValid = false;

    /**
     * 實例創建
     * @return
     */
    public static LegalCharValidBuilder instance() {
        return new LegalCharValidBuilder();
    }

    /**
     * 構造器
     * @return
     */
    public LegalCharValid build() {
        return new LegalCharValid(baseLegalChar, extLegalChar, skipFirstCharValid);
    }

    public LegalCharValidBuilder setBaseLegalChar(String baseLegalChar) {
        this.baseLegalChar = baseLegalChar;
        return this;
    }

    public LegalCharValidBuilder setExtLegalChar(String extLegalChar) {
        this.extLegalChar = extLegalChar;
        return this;
    }

    public LegalCharValidBuilder setSkipFirstCharValid(boolean skipFirstCharValid) {
        this.skipFirstCharValid = skipFirstCharValid;
        return this;
    }

    /**
     * 合法字符校驗
     */
    public class LegalCharValid {

        /**
         * 基礎合法字符
         */
        private final String  BASE_LEGAL_CHAR;

        /**
         * 全部合法字符
         */
        private final String  TOTAL_LEGA_CHAR;

        /**
         * 是否跳過首字母校驗
         */
        private final boolean SKIP_FIRST_CHAR_VALID;

        /**
         * 二分查找合法字符容量
         */
        private int           binaryLegalCapacity = 2000;

        /**
         * 合法的ascii數組集合(升序排序)
         */
        private int[]         LEGAL_ASCII_ARR;

        LegalCharValid(String baseLegalChar, String extLegalChar, boolean skipFirstCharValid) {
            BASE_LEGAL_CHAR = baseLegalChar;
            TOTAL_LEGA_CHAR = baseLegalChar + extLegalChar;
            SKIP_FIRST_CHAR_VALID = skipFirstCharValid;
            LEGAL_ASCII_ARR = new int[TOTAL_LEGA_CHAR.length()];
            char[] arr = TOTAL_LEGA_CHAR.toCharArray();
            int i = 0;
            for (char c : arr) {
                LEGAL_ASCII_ARR[i++] = c;
            }
            // 生成ascii 碼 升序排序
            Arrays.sort(LEGAL_ASCII_ARR);
        }

        /**
         * 查找字符串中的非法字符
         * <pre>
         *   findUnValidCharByNormal("aha~") = {~=[3]}
         *   findUnValidCharByNormal("aha~，~") = {~=[3,5],，=[4]}
         * </pre>
         * @param str
         * @return
         */
        public Map<Character, Set<Integer>> findUnValidChar(String str) {
            Map<Character, Set<Integer>> unValid;
            if (TOTAL_LEGA_CHAR.length() >= binaryLegalCapacity) {
                unValid = findUnValidCharByBinarySearch(str);
            } else {
                unValid = findUnValidCharByNormal(str);
            }
            // 查找首字母是否合法
            if (!SKIP_FIRST_CHAR_VALID && !validCharLegal(str.charAt(0))) {
                char first = str.charAt(0);
                Set<Integer> indexes = unValid.getOrDefault(first, Sets.newHashSet(0));
                indexes.add(0);
                unValid.put(first, indexes);
            }
            return unValid;
        }

        /**
         * 根據基礎合法字符集校驗字符是否合法
         * <pre>
         *     validCharLegal('.') = false
         *     validCharLegal('a') = true
         *     validCharLegal('0') = true
         * </pre>
         * @param first
         * @return
         */
        private boolean validCharLegal(char first) {
            for (char legal : BASE_LEGAL_CHAR.toCharArray()) {
                if (legal == first) {
                    return true;
                }
            }
            return false;
        }

        /**
         * 二分查找非法字符
         * <pre>
         *   findUnValidCharByNormal("aha~") = {~=[3]}
         *   findUnValidCharByNormal("aha~，~") = {~=[3,5],，=[4]}
         * </pre>
         * @param str
         * @return
         */
        public Map<Character, Set<Integer>> findUnValidCharByBinarySearch(String str) {
            Map<Character, Set<Integer>> map = Maps.newHashMap();
            if (StringUtil.isEmpty(str)) {
                return map;
            }
            int i = 0;
            for (char c : str.toCharArray()) {
                int index = Arrays.binarySearch(LEGAL_ASCII_ARR, c);
                // 如果在合法字符庫中未找到 就把當前的index下標放到map中
                if (index < 0) {
                    Set<Integer> indexes = map.getOrDefault(c, Sets.newHashSet(i));
                    indexes.add(i);
                    map.put(c, indexes);
                }
                i++;
            }

            return map;
        }

        /**
         * 遍歷查找非法字符
         * <pre>
         *   findUnValidCharByNormal("aha~") = {~=[3]}
         *   findUnValidCharByNormal("aha~，~") = {~=[3,5],，=[4]}
         * </pre>
         * @param str
         * @return
         */
        public Map<Character, Set<Integer>> findUnValidCharByNormal(String str) {
            Map<Character, Set<Integer>> map = Maps.newHashMap();
            int i = 0;
            char[] arr = str.toCharArray();
            for (char c : arr) {
                boolean find = false;
                for (char s : TOTAL_LEGA_CHAR.toCharArray()) {
                    if (c == s) {
                        find = true;
                        break;
                    }
                }
                if (!find) {
                    Set<Integer> indexes = map.getOrDefault(c, Sets.newHashSet(i));
                    indexes.add(i);
                    map.put(c, indexes);
                }
                i++;
            }
            return map;
        }
    }
}

自定義非法字符異常

UnLegalCheckException.java

/**
 * 非合法字符校驗異常類
 */
public class UnLegalCheckException extends RuntimeException {

    /**
     * 錯誤碼
     */
    private String                       errorCode;

    /**
     * 錯誤消息集合
     */
    private List<String>                 errorMsgs;

    /**
     * 非法字符集合
     */
    private Map<Character, Set<Integer>> unLegalMap;

    /**
     * 校驗字段名字
     */
    private String                       checkField;

    /**
     * 構造函數
     * @param errorCode 錯誤碼
     * @param errorMsg 錯誤消息
     * @param field 校驗字段
     * @param map 非法字符
     */
    public UnLegalCheckException(String errorCode, String errorMsg, List<String> errorMsgs,
                                 String field, Map<Character, Set<Integer>> map) {
        super(errorMsg);
        this.errorCode = errorCode;
        this.errorMsgs = errorMsgs;
        this.checkField = field;
        this.unLegalMap = map;
    }

    /**
     * 構造函數
     * @param errorMsg 錯誤消息
     * @param errorMsgs 錯誤消息集合(json)
     * @param field  校驗字段
     * @param map 非法字符
     */
    public UnLegalCheckException(String errorMsg, List<String> errorMsgs, String field,
                                 Map<Character, Set<Integer>> map) {
        super(errorMsg);
        this.checkField = field;
        this.errorMsgs = errorMsgs;
        this.unLegalMap = map;
    }

    /**
     * 構造函數
     * @param cause 異常信息
     * @param errorMsg 錯誤消息
     * @param map 非法字符
     */
    public UnLegalCheckException(Throwable cause, String errorMsg, Map<Character, Set<Integer>> map) {
        super(errorMsg, cause);
        this.unLegalMap = map;
    }

    public String getErrorCode() {
        return errorCode;
    }
    
    public void setErrorCode(String errorCode) {
        this.errorCode = errorCode;
    }

    public Map<Character, Set<Integer>> getUnLegalMap() {
        return unLegalMap;
    }
    
    public void setUnLegalMap(Map<Character, Set<Integer>> unLegalMap) {
        this.unLegalMap = unLegalMap;
    }
    
    public String getCheckField() {
        return checkField;
    }

    public void setCheckField(String checkField) {
        this.checkField = checkField;
    }

    public List<String> getErrorMsgs() {
        return errorMsgs;
    }

    public void setErrorMsgs(List<String> errorMsgs) {
        this.errorMsgs = errorMsgs;
    }
}

測試校驗類

UserInfo.java

import lombok.Data;
import lombok.ToString;
import org.apache.commons.lang3.StringUtils;
import org.hibernate.validator.constraints.Length;
import org.hibernate.validator.constraints.NotEmpty;
/**
 * 信息test
 */
@Data
@ToString
public class UserInfo {

    private static final long serialVersionUID = 7383672481338516001L;

    /**
     * 姓名
     */
    @NotEmpty(message = "請填寫姓名")
    @IfNotNullRegex(regex = { ".*[\\u4E00-\\u9FA5\u3002\uFF1F\uFF01\uFF0C\u3001\uFF1B\uFF1A\u300C\u300D\u300E\u300F\u2018\u2019\u201C\u201D\uFF08\uFF09\u3014\u3015\u3010\u3011\u2014\u2026\u2013\uFF0E\u300A\u300B\u3008\u3009].*",
                              "^[a-zA-Z0-9/\\?:\\(\\)\\.\\,\\' \\+]*$",
                              "^[a-zA-Z0-9]{1}.*",
                              "\\d+"},
            matcher = { true,false,false,true },
            regexMsg = {"姓名不能xxx標點符號",
                    "姓名不xxx符號",
                    "姓名xxx符號",
                    "姓名xxx"})
    private String            name;
}

單元測試

unitTest.java

import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.Validator;
import javax.validation.ValidatorFactory;
import com.alibaba.fastjson.JSON;

import org.hibernate.validator.HibernateValidator;
public class UnitTest {

	public static void main(String[] args){
		UserInfo user = new UserInfo();
		user.setName("haha@");
		try{
		createValidator(true).validate(user);
		}catch(ValidationException e){
		if(e.getCause() instanceof UnLegalCheckException){
		UnLegalCheckException unLegal = (UnLegalCheckException) e.getCause();
		// 輸出校驗的非法字符信息
		System.out.println(JSON.toJSONString(unLegal));
		// 輸出所有的錯誤提示信息
		 System.out.println(JSON.toJSONString(unLegal.getErrorMsgs()));
		}
		}
	}
    private static Validator createValidator(boolean isFast) {
        ValidatorFactory factory = Validation.byProvider(HibernateValidator.class).configure()
            .failFast(isFast).buildValidatorFactory();
        return factory.getValidator();
    }
}