用户注册，后端信息校验，springboot

用户信息校验，保存

1、判断userCode是否存在
2、判断密码强度
密码校验规则：数字和字母、大写字母、特殊符号
配置不同校验强度，返回校验结果
3、判断手机号
4、判断邮箱
5、判断身份证号

    public UserVO save1(UserAddVO addVO,SysUser sysUser){
        //判断userCode是否存在
        UserQueryVO userQueryVO=new UserQueryVO();
        userQueryVO.setUserCode(addVO.getUserCode());
        List<UserVO> userVOList = queryAll(userQueryVO);
        if(!userVOList.isEmpty()){
            throw new BusinessException("userCode已存在");
        }
        //判断密码强度
        PasswordStrengthVO passwordStrengthVO = passwordStrengthCheck(addVO.getUserPwd());
        if(!passwordStrengthVO.isResult()){
            throw new BusinessException("密码强度不合规定，请重新设置");
        }
        //判断手机号
        if(StringUtils.isNotBlank(addVO.getUserMobile())) {
            boolean checkPhone = RegUtils.checkPhone(addVO.getUserMobile());
            if(!checkPhone){
                throw new BusinessException("手机号不正确");
            }
        }
        //判断邮箱
        if(StringUtils.isNotBlank(addVO.getUserEmail())){
            boolean b = RegUtils.checkEmail(addVO.getUserEmail());
            if(!b){
                throw new BusinessException("邮箱不正确");
            }
        }
        //判断身份证号
        if(StringUtils.isNotBlank(addVO.getUserIcid())){
            if(!RegUtils.checkIdCard(addVO.getUserIcid())){
                throw new BusinessException("身份证号不正确");
            }
        }

        UserBO userBO = new UserBO();
        BeanUtils.copyProperties(addVO,userBO);
        boolean save = userDao.save(userBO);

        UserVO userVO = new UserVO();
        BeanUtils.copyProperties(userBO,userVO);
        return userVO;
    }

  /**
     * 正则-密码强度-基础要求, 必须字母+数字，长度检测不在此处
     */
    public static final String REGEX_PASSWORD_STRENGTH_BASIC = "^(?![0-9]+$)(?![a-zA-Z]+$).{1,}$";
    /**
     * 正则-密码强度-至少一位大写字母
     */
    public static final String REGEX_PASSWORD_STRENGTH_UPPER_CHAR = "^(?=.*[A-Z]).+$";
    /**
     * 正则-密码强度-至少一位符号
     */
    public static final String REGEX_PASSWORD_STRENGTH_CHARS = "^(?=.*[`~!@#$%^&*()_\\-+=<>?:\"{}|,./;'\\[\\]·~！@#￥%……&*（）——\\-+={}|《》？：“”【】、；‘'，。、]).+$";
    //密码强度检查
    public PasswordStrengthVO passwordStrengthCheck1(String password){
        PasswordStrengthVO resultVO=new PasswordStrengthVO();
        //长度检查
        if(password.length()<oamConfig.getPasswordLength()){
             resultVO.setResult(false);
             resultVO.setTip("密码长度不够");
             return resultVO;
        }
        //密码检查，字母和数字、大写字符、特殊符号
        boolean basicMatches = Pattern.compile(REGEX_PASSWORD_STRENGTH_BASIC).matcher(password).matches();
        boolean upperCharMatches = Pattern.compile(REGEX_PASSWORD_STRENGTH_UPPER_CHAR).matcher(password).matches();
        boolean charsMatches = Pattern.compile(REGEX_PASSWORD_STRENGTH_CHARS).matcher(password).matches();

        //密码强度设置，根据配置
        String passwordStrength = oamConfig.getPasswordStrength();
        if(PASSWORD_STRENGTH_WEAK.equals(passwordStrength)){
            //如果配置为弱检查，不检查，直接通过
//            resultVO.setResult(true);
            resultVO.setLevel(0);
        }else if(PASSWORD_STRENGTH_NORMAL.equals(passwordStrength)){
            //如果普通强度，字母和数字
            resultVO.setLevel(1);
            if(!basicMatches){
                resultVO.setResult(basicMatches);
                resultVO.setTip("密码必须包含字母和数字");
                return resultVO;
            }
        }else {
            resultVO.setLevel(2);
            //强检查，字母和数字、大写字母、特殊符号
            if(!basicMatches){
                resultVO.setResult(basicMatches);
                resultVO.setTip("密码必须包含字母和数字");
                return resultVO;
            }

            if(!upperCharMatches){
                resultVO.setResult(upperCharMatches);
                resultVO.setTip("密码必须包含至少一个大写字母");
                return resultVO;
            }

            if(!charsMatches){
                resultVO.setResult(charsMatches);
                resultVO.setTip("密码必须包含至少一个特殊符号");
                return resultVO;
            }
        }
        resultVO.setResult(true);
        return resultVO;
    }

/**
 * 正则表达式工具
 */
public class RegUtils {

    /**
     * 校验手机号是否合法
     * 参考：https://blog.csdn.net/u011415782/article/details/85601655
     * @param phone
     * @return
     */
    public static boolean checkPhone(String phone) {
        String reg = "^[1](([3][0-9])|([4][5-9])|([5][0-3,5-9])|([6][5,6])|([7][0-8])|([8][0-9])|([9][1,8,9]))[0-9]{8}$";
        return phone.matches(reg);
    }

    /**
     * 校验邮箱是否合法
     * 参考：https://www.cnblogs.com/lst619247/p/9289719.html
     * @param email
     * @return
     */
    public static boolean checkEmail(String email) {
        String reg = "^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\\.[a-zA-Z0-9_-]+)+$";
        return email.matches(reg);
    }

    /**
     * 校验身份证号是否合法
     * 参考：https://blog.csdn.net/qiphon3650/article/details/95541641
     * @param idCard
     * @return
     */
    public static boolean checkIdCard(String idCard) {
        String reg = "^[1-9]\\d{5}(18|19|20|(3\\d))\\d{2}((0[1-9])|(1[0-2]))(([0-2][1-9])|10|20|30|31)\\d{3}[0-9Xx]$";
        return idCard.matches(reg);
    }
}