VerificationCodeUtil

因最近系统等保三级改造中使用到了随机生成高强度密码(包含大写、小写英文字母、数字、特殊字符且不少于八位)并发送短信至客户手机，博猪基于apache-common-lang3二次包装了一个工具类。

Maven依赖

<dependency>  
    <groupId>org.apache.commons</groupId>  
    <artifactId>commons-lang3</artifactId>  
    <version>3.3.9</version>  
</dependency>

JAVA工具类

import org.apache.commons.lang3.RandomStringUtils;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @ClassName     VerificationCode
 * @Description   密码、验证码工具类
 * @Author        will
 * @Date          2022/8/17 9:33
 * @Company       北京惠科互联科技有限公司
 */
public final class VerificationCodeUtil {
    private VerificationCodeUtil(){}

    /**
     * 默认特殊字符
     */
    private final static char[] DEFAULT_SYMBOL = {'!', '@', '#', '$', '%', '^', '&', '*'};

    /**
     * 生成指定长度的随机数
     * @param len           生成长度
     * @return
     */
    public static String generatorNumber(int len) {
        return generatorNumber(len, false);
    }

    /**
     * 生成指定长度的随机大写字母
     * @param len           生成长度
     * @return
     */
    public static String generatorUpperCase(int len) {
        return generatorUpperCase(len, false);
    }

    /**
     * 生成指定长度的随机小写字母
     * @param len           生成长度
     * @return
     */
    public static String generatorLowerCase(int len) {
        return generatorLowerCase(len, false);
    }

    /**
     * 生成指定长度的随机特殊字符
     * @param len               生成长度
     * @param shuffleFlag       二次打乱标识 true-需要二次打乱，false-默认生成
     * @return
     */
    public static String generatorNotDefaultSymbol(int len, boolean shuffleFlag) {
        return generatorSymbol(len, false, false);
    }

    /**
     * 生成指定长度的随机默认特殊字符
     * @param len                生成长度
     * @return
     */
    public static String generatorDefaultSymbol(int len) {
        return generatorSymbol(len, true, false);
    }

    /**
     * 生成指定长度的随机数
     * @param len           生成长度
     * @param shuffleFlag   二次打乱标识 true-需要二次打乱，false-默认生成
     * @return
     */
    public static String generatorNumber(int len, boolean shuffleFlag) {
        String randomNumeric = RandomStringUtils.randomNumeric(len);
        if (shuffleFlag) {
            return shuffleRandomStr(randomNumeric);
        }
        return randomNumeric;
    }

    /**
     * 生成指定长度的大写字母
     * @param len           生成长度
     * @param shuffleFlag   二次打乱标识 true-需要二次打乱，false-默认生成
     * @return
     */
    public static String generatorUpperCase(int len, boolean shuffleFlag) {
        String randomStr = RandomStringUtils.random(len, 65, 90, true, true);
        if(shuffleFlag) {
            return shuffleRandomStr(randomStr);
        }
        return randomStr;
    }


    /**
     * 生成指定长度的小写字母
     * @param len           生成长度
     * @param shuffleFlag   二次打乱标识 true-需要二次打乱，false-默认生成
     * @return
     */
    public static String generatorLowerCase(int len, boolean shuffleFlag) {
        String randomStr = RandomStringUtils.random(len, 97, 122, true, true);
        if(shuffleFlag) {
            return shuffleRandomStr(randomStr);
        }
        return randomStr;
    }

    /**
     * 生成指定长度的特殊字符
     *
     * @param len                生成长度
     * @param defaultSymbolFlag  是否使用默认特殊字符标识（默认即常用特殊字符键盘SHIFT+【1-0】)，true-默认使用/false-不使用默认字符即随机生成
     * @param shuffleFlag        二次打乱标识 true-需要二次打乱，false-默认生成
     * @return
     */
    public static String generatorSymbol(int len, boolean defaultSymbolFlag, boolean shuffleFlag) {
        String randomStr = null;
        if (defaultSymbolFlag) {
            randomStr = RandomStringUtils.random(len, DEFAULT_SYMBOL);
        } else {
            randomStr = RandomStringUtils.random(len, 33, 47, false, false);
        }
        if (shuffleFlag) {
            return shuffleRandomStr(randomStr);
        }
        return randomStr;
    }

    /**
     *  根据自定义字符串生成随机数
     * @param len             生成长度
     * @param shuffleFlag     二次打乱标识 true-需要二次打乱，false-默认生成
     * @param chars           字符串可变参数
     * @return
     */
    public static String generatorCustom(int len, boolean shuffleFlag, char... chars) {
        String randomStr = RandomStringUtils.random(len, chars);
        if (shuffleFlag) {
            return shuffleRandomStr(randomStr);
        }
        return randomStr;
    }

    /**
     * 生成随机字符串
     * @param upperCount         大写字符串数量
     * @param lowerCount         小写字符串数量
     * @param numberCount        数字字符串数量
     * @param symbolCount        特殊字符串数量
     * @param defaultSymbolFlag  是否使用默认特殊字符标识（默认即常用特殊字符键盘SHIFT+【1-0】)，true-默认使用/false-不使用默认字符即随机生成
     * @param shuffleFlag        二次打乱标识 true-需要二次打乱，false-默认生成
     * @return
     */
    public static String generatorRandomStr(int upperCount, int lowerCount
            , int numberCount, int symbolCount, boolean defaultSymbolFlag , boolean shuffleFlag) {
        final int zero = 0;
        if (zero >= upperCount && zero >= lowerCount && zero >= numberCount && zero >= symbolCount) {
            throw new VerificationCodeException("生成密码长度不能为空！");
        }
        String upperRandomStr = generatorUpperCase(upperCount);
        String lowerRandomStr = generatorLowerCase(lowerCount);
        String numberRandomStr = generatorNumber(numberCount);
        String symbolRandomStr = "";
        if (symbolCount > 0) {
            symbolRandomStr = generatorSymbol(symbolCount, defaultSymbolFlag, false);
        }
        String randomStr = upperRandomStr
                .concat(lowerRandomStr)
                .concat(numberRandomStr)
                .concat(symbolRandomStr);
        if (shuffleFlag) {
            return shuffleRandomStr(randomStr);
        }
        return randomStr;
    }

    /**
     * 生成随机字符串
     * @param partCount         每种类型数量
     * @param containSymbolFlag 是否包含特殊字符
     * @param defaultSymbolFlag 是否使用默认特殊字符标识（默认即常用特殊字符键盘SHIFT+【1-0】)，true-默认使用/false-不使用默认字符即随机生成
     * @param shuffleFlag       二次打乱标识 true-需要二次打乱，false-默认生成
     * @return
     */
    public static String generatorRandomStr(int partCount, boolean containSymbolFlag, boolean defaultSymbolFlag, boolean shuffleFlag) {
        final int zero = 0;
        if (zero >= partCount) {
            throw new VerificationCodeException("生成密码长度不能为空！");
        }
        String randomStr = "";
        if (containSymbolFlag) {
            randomStr = generatorRandomStr(partCount, partCount, partCount, partCount, defaultSymbolFlag, false);
        } else {
            randomStr = generatorRandomStr(partCount, partCount, partCount, 0, false, false);
        }
        if (shuffleFlag) {
            return shuffleRandomStr(randomStr);
        }
        return randomStr;
    }

    /**
     * 生成随机字符串
     * @param partCount         大写、小写字母、数字数量
     * @param symbolCount       特殊字符数量
     * @param defaultSymbolFlag 是否使用默认特殊字符标识（默认即常用特殊字符键盘SHIFT+【1-0】)，true-默认使用/false-不使用默认字符即随机生成
     * @param shuffleFlag       二次打乱标识 true-需要二次打乱，false-默认生成
     * @return
     */
    public static String generatorRandomStr(int partCount, int symbolCount, boolean defaultSymbolFlag, boolean shuffleFlag) {
        final int zero = 0;
        if (zero >= partCount) {
            throw new VerificationCodeException("生成密码长度不能为空！");
        }
        String randomStr = generatorRandomStr(partCount, partCount, partCount, symbolCount, defaultSymbolFlag, false);
        if (shuffleFlag) {
            return shuffleRandomStr(randomStr);
        }
        return randomStr;
    }

    /**
     * 生成随机字符串，特殊字符使用默认特殊字符
     * @param partCount         大写、小写字母、数字数量
     * @param symbolCount       特殊字符数量
     * @param shuffleFlag       二次打乱标识 true-需要二次打乱，false-默认生成
     * @return
     */
    public static String generatorRandomStr(int partCount, int symbolCount, boolean shuffleFlag) {
        final int zero = 0;
        if (zero >= partCount) {
            throw new VerificationCodeException("生成密码长度不能为空！");
        }
        String randomStr = generatorRandomStr(partCount, partCount, partCount, symbolCount, true, false);
        if (shuffleFlag) {
            return shuffleRandomStr(randomStr);
        }
        return randomStr;
    }

    /**
     * 生成随机字符串，特殊字符使用默认特殊字符,生成后会二次打乱
     * @param partCount         大写、小写字母、数字数量
     * @param symbolCount       特殊字符数量
     * @return
     */
    public static String generatorRandomStr(int partCount, int symbolCount) {
        final int zero = 0;
        if (zero >= partCount) {
            throw new VerificationCodeException("生成密码长度不能为空！");
        }
        return generatorRandomStr(partCount, partCount, partCount, symbolCount, true, true);
    }

    /**
     * 生成指定长度随机字符串，且特殊字符固定，类型数量固定，如有多余则自动补足数字类型
     * @param len                   随机字符串长度
     * @param symbolCount           固定特殊字符串
     * @param defaultSymbolFlag     是否使用默认特殊字符
     * @param shuffleFlag           二次打乱标识 true-需要二次打乱，false-默认生成
     * @return
     */
    public static String generatorDefaultRandomStr(int len, int symbolCount, boolean defaultSymbolFlag, boolean shuffleFlag) {
        //生成类型数量
        int typeNum = 3;
        int excludeSymbolCount = len - symbolCount;
        int count = (symbolCount > 0) ? excludeSymbolCount / typeNum : len / typeNum;
        int numberCount = 0;
        /**
         * 如果是类型的倍数则平均分，如果不是则补足一个大写字母
         */
        if (len % typeNum == 0) {
            numberCount = count;
        } else {
            numberCount += count + excludeSymbolCount % typeNum;
        }
        return generatorRandomStr(count, count, numberCount, symbolCount, defaultSymbolFlag, shuffleFlag);
    }

    /**
     * 生成指定长度随机字符串，且特殊字符固定一位，默认使用固定字符串，默认二次打乱，类型数量固定，如有多余则自动补足数字类型
     * @param len                   随机字符串长度
     * @return
     */
    public static String generatorDefaultRandomStr(int len) {
        return generatorDefaultRandomStr(len, 1, true, true);
    }

    /**
     * 生成八位随机字符串，且特殊字符固定一位，默认使用固定字符串，默认二次打乱，类型数量固定，如有多余则自动补足数字类型
     * @return
     */
    public static String generatorDefaultRandomStr() {
        return generatorDefaultRandomStr(8, 1, true, true);
    }

    /**
     * 二次打乱字符串
     * @param randomStr   随机字符串
     * @return
     */
    private static String shuffleRandomStr(String randomStr) {
        List<Character> numberList = randomStr.chars().mapToObj(c -> (char) c).collect(Collectors.toList());
        Collections.shuffle(numberList);
        return numberList
                .stream()
                .collect(StringBuilder::new, StringBuilder::append, StringBuilder::append).toString();
    }


    /**
     * 异常信息
     */
    private static class VerificationCodeException extends RuntimeException{
        public VerificationCodeException(String message) {super(message);}

        public VerificationCodeException(String message,Throwable throwable) {
            super(message, throwable);
        }

    }

}