Java验证码(图片、字符串)生成工具

深碍√TFBOYSˉ_ 2024-04-06 13:07 126阅读 0赞

验证码生成工具

本工具可以生成:

  • 数字+字符
  • 纯数字
  • 纯字符

验证码样式:

  • 字符串
  • base64 字符图片验证码

主要方法:

  • generateCaptchaImage:获取图片验证码
  • generateCaptchaImageVerifyCode:获取图片验证码:(更多自定义参数)
  • getVerifyCode:获取验证码
  • getStringVerifyCode:获取默认长度验证码
  • getNumberVerifyCode:获取默认长度纯数字验证码

  • getStringAndNumberVerifyCode:获取默认长度,数字加字符

    @Slf4j
    public class VerifyCodeUtils {

    1. // 加载字体并缓存
    2. private static volatile Font cacheFont = null;
    3. //默认宽度
    4. private static final Integer imgWidth = 150;
    5. //默认高度
    6. private static final Integer imgHeight = 50;
    7. //随机字符串和数字
    8. private static final String STRING_NUMBER_VERIFY_CODE = "123456789ABCDEFGHJKLNPQRSTUVXYZ";
    9. //随机字符串
    10. private static final String STRING_VERIFY_CODE = "ABCDEFGHIJKLMNPOQRSTUVWXYZ";
    11. //随机数
    12. private static Random random = new Random();
    13. //默认验证码长度
    14. private static int DEFAULT_VERIFY_CODE_LENGTH = 4;
    15. //验证码最大长度
    16. private static int MAX_VERIFY_CODE_LENGTH = 6;
    17. //默认干扰线系数
    18. private static float DEFAULT_INTERFERE_RATE = 0.1f;
    19. //默认噪声系数
    20. private static float DEFAULT_NOISE_RATE = 0.3f;
  1.     /**
  2.      * 纯数字验证码
  3.      * @param length 4-6位，默认4位
  4.      * @return
  5.      */
  6.     private static String generateNumberVerifyCode(int length) {
  8.         String code;
  9.         if (length == 6){
  11.             code = String.valueOf(ThreadLocalRandom.current().nextInt(0, 999999));
  12.         }else if (length == 5){
  14.             code = String.valueOf(ThreadLocalRandom.current().nextInt(0, 99999));
  15.         }else {
  17.             code = String.valueOf(ThreadLocalRandom.current().nextInt(0, 9999));
  18.         }
  19.         if (code.length() == length) {
  21.             return code;
  22.         } else {
  24.             StringBuilder str = new StringBuilder();
  25.             for(int i = 0; i < length - code.length(); ++i) {
  27.                 str.append("0");
  28.             }
  29.             return str + code;
  30.         }
  31.     }
  33.     /**
  34.      * 生成随机验证码
  35.      * @param length
  36.      * @param sources
  37.      * @return
  38.      */
  39.     private static String generateVerifyCode(int length, String sources) {
  41.         if (sources == null || sources.length() == 0) {
  43.             sources = STRING_NUMBER_VERIFY_CODE;
  44.         }
  45.         int codeLen = sources.length();
  46.         Random rand = new Random();
  47.         StringBuilder verifyCode = new StringBuilder(length);
  48.         for (int i = 0; i < length; i++) {
  50.             verifyCode.append(sources.charAt(rand.nextInt(codeLen - 1)));
  51.         }
  52.         return verifyCode.toString();
  53.     }
  55.     /**
  56.      * 默认长度4，数字加字符串
  57.      * @return
  58.      */
  59.     public static String getStringAndNumberVerifyCode() {
  61.         return generateVerifyCode(DEFAULT_VERIFY_CODE_LENGTH, STRING_NUMBER_VERIFY_CODE);
  62.     }
  64.     /**
  65.      * 默认长度4，获取纯数字验证码
  66.      * @return
  67.      */
  68.     public static String getNumberVerifyCode() {
  70.         return generateNumberVerifyCode(DEFAULT_VERIFY_CODE_LENGTH);
  71.     }
  73.     /**
  74.      * 默认长度4，字符串
  75.      * @return
  76.      */
  77.     public static String getStringVerifyCode() {
  79.         return generateVerifyCode(DEFAULT_VERIFY_CODE_LENGTH, STRING_VERIFY_CODE);
  80.     }
  82.     /**
  83.      * 获取验证码
  84.      * @param length 验证码长度 最长不超过6位 ，默认4位
  85.      * @param type 验证码类型 0-数字+字符,1-纯数字，2-纯字符 默认0
  86.      * @return
  87.      */
  88.     public static String getVerifyCode(int length, int type) {
  90.         if (length == 0){
  92.             length = DEFAULT_VERIFY_CODE_LENGTH;
  93.         }
  94.         if (length < DEFAULT_VERIFY_CODE_LENGTH){
  96.             throw new DescribeException("length不能小于"+DEFAULT_VERIFY_CODE_LENGTH, ServerCodeEnum.PARAM_ERROR.getCode());
  97.         }
  98.         if (length > MAX_VERIFY_CODE_LENGTH){
  100.             throw new DescribeException("length不能大于"+MAX_VERIFY_CODE_LENGTH,ServerCodeEnum.PARAM_ERROR.getCode());
  101.         }
  102.         if (type == 1){
  104.             return generateNumberVerifyCode(length);
  105.         }
  106.         if (type == 2){
  108.             return generateVerifyCode(length, STRING_VERIFY_CODE);
  109.         }
  110.         return generateVerifyCode(length, STRING_NUMBER_VERIFY_CODE);
  111.     }
  113.     /**
  114.      * 返回base64图片验证码
  115.      * @param code 验证码
  116.      * @param imgWidth 宽度
  117.      * @param imgHeight 高度
  118.      * @return
  119.      */
  120.     public static String generateCaptchaImageVerifyCode(String code, Integer imgWidth, Integer imgHeight){
  122.         if (imgWidth == null){
  124.             imgWidth = VerifyCodeUtils.imgWidth;
  125.         }
  126.         if (imgHeight == null){
  128.             imgHeight = VerifyCodeUtils.imgHeight;
  129.         }
  130.         return generateCaptchaImage(imgWidth, imgHeight, code,DEFAULT_INTERFERE_RATE , DEFAULT_NOISE_RATE);
  131.     }
  133.     /**
  134.      * 返回base64图片验证码
  135.      * @param code 验证码
  136.      * @param imgWidth 宽度
  137.      * @param imgHeight 高度
  138.      * @param interfereRate 干扰性系数0.0-1.0
  139.      * @param noiseRate 噪声系数 0.0-1.0
  140.      * @return
  141.      */
  142.     public static String generateCaptchaImage(String code, int imgWidth, int imgHeight,float interfereRate, float noiseRate){
  144.         return generateCaptchaImage(imgWidth, imgHeight, code, interfereRate, noiseRate);
  145.     }
  147.     /**
  148.      * 生成验证码图片
  149.      * @param imgWidth 宽度
  150.      * @param imgHeight 高度
  151.      * @param code 验证码
  152.      * @param interfereRate 干扰系数 0.1-1
  153.      * @param noiseRate 噪声系数 0.1-1
  154.      */
  155.     private static String generateCaptchaImage(int imgWidth, int imgHeight, String code, float interfereRate, float noiseRate){
  157.         String base64Img = null;
  158.         try {
  160.             int length = code.length();
  161.             BufferedImage image = new BufferedImage(imgWidth, imgHeight, BufferedImage.TYPE_INT_RGB);
  162.             Random rand = new Random();
  163.             Graphics2D graphics2D = image.createGraphics();
  164.             graphics2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
  165.             // 设置边框色
  166.             graphics2D.setColor(Color.GRAY);
  167.             graphics2D.fillRect(0, 0, imgWidth, imgHeight);
  168.             // 设置背景色
  169.             Color c = new Color(235, 235, 235);
  170.             graphics2D.setColor(c);
  171.             graphics2D.fillRect(0, 1, imgWidth, imgHeight - 2);
  172.             //绘制干扰
  173.             interfere(image, graphics2D, imgWidth, imgHeight, interfereRate, noiseRate);
  174.             //使图片扭曲
  175.             shear(graphics2D, imgWidth, imgHeight, c);
  176.             //字体颜色
  177.             graphics2D.setColor(getRandColor(30, 100));
  178.             //字体大小
  179.             int fontSize = imgHeight >= 50 ?  imgHeight - 8 : imgHeight >= 30 ? imgHeight - 6 : imgHeight - 4;
  180.             //字体 Fixedsys/Algerian
  181.             Font font = new Font("Fixedsys", Font.ITALIC, fontSize);
  182.             graphics2D.setFont(font);
  183.             char[] chars = code.toCharArray();
  184.             for (int i = 0; i < length; i++) {
  186.                 //设置旋转
  187.                 AffineTransform affine = new AffineTransform();
  188.                 //控制在-0.3-0.3
  189.                 double theta = ((Math.PI / 4 * rand.nextDouble())*0.3) * (rand.nextBoolean() ? 1 : -1);
  190.                 affine.setToRotation(theta, (imgWidth / length) * i + fontSize / 2, imgHeight / 2);
  191.                 graphics2D.setTransform(affine);
  192.                 int x = ((imgWidth - 10) / length) * i + 4;
  193.                 //文字居中
  194.                 FontMetrics fm = graphics2D.getFontMetrics();
  195.                 int stringAscent = fm.getAscent();
  196.                 int stringDescent = fm.getDescent ();
  197.                 int y = imgHeight / 2 + (stringAscent - stringDescent) / 2;
  198.                 graphics2D.drawChars(chars, i, 1, x, y);
  199.             }
  200.             graphics2D.dispose();
  201.             ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
  202.             ImageIO.write(image, "jpg", outputStream);
  203.             Base64.Encoder encoder = Base64.getEncoder();
  204.             base64Img = encoder.encodeToString(outputStream.toByteArray());
  205.             base64Img = base64Img.replaceAll("\n", "").replaceAll("\r", "");
  206.         }catch (Exception e){
  208.             log.error("生成图片验证码异常：", e);
  209.         }
  210.        return base64Img;
  211.     }
  214.     /**
  215.      * 绘制干扰线和噪点
  216.      * @param image 图像
  217.      * @param graphics2D 二维图
  218.      * @param imgWidth 宽度
  219.      * @param imgHeight 高度
  220.      * @param interfereRate 干扰线率 0.1-1
  221.      * @param noiseRate 噪声率 0.1-1
  222.      */
  223.     private static void interfere(BufferedImage image,Graphics2D graphics2D, int imgWidth, int imgHeight, float interfereRate, float noiseRate){
  225.         Random random = new Random();
  226.         graphics2D.setColor(getRandColor(160, 200));
  227.         int line = (int) (interfereRate * 100);
  228.         for (int i = 0; i < line; i++) {
  230.             int x = random.nextInt(imgWidth - 1);
  231.             int y = random.nextInt(imgHeight - 1);
  232.             int xl = random.nextInt(6) + 1;
  233.             int yl = random.nextInt(12) + 1;
  234.             graphics2D.drawLine(x, y, x + xl + 40, y + yl + 20);
  235.         }
  236.         int area = (int) (noiseRate * imgWidth * imgHeight)/10;
  237.         for (int i = 0; i < area; i++) {
  239.             int x = random.nextInt(imgWidth);
  240.             int y = random.nextInt(imgHeight);
  241.             int rgb = getRandomIntColor();
  242.             image.setRGB(x, y, rgb);
  243.         }
  244.     }
  246.     /**
  247.      * 获取随机颜色
  248.      * @param fc
  249.      * @param bc
  250.      * @return
  251.      */
  252.     private static Color getRandColor(int fc, int bc) {
  254.         if (fc > 255) {
  256.             fc = 255;
  257.         }
  258.         if (bc > 255) {
  260.             bc = 255;
  261.         }
  262.         int r = fc + random.nextInt(bc - fc);
  263.         int g = fc + random.nextInt(bc - fc);
  264.         int b = fc + random.nextInt(bc - fc);
  265.         return new Color(r, g, b);
  266.     }
  268.     /**
  269.      * 获取rgb
  270.      * @return
  271.      */
  272.     private static int getRandomIntColor() {
  274.         int[] rgb = getRandomRgb();
  275.         int color = 0;
  276.         for (int c : rgb) {
  278.             color = color << 8;
  279.             color = color | c;
  280.         }
  281.         return color;
  282.     }
  284.     /**
  285.      * 获取随机rgb颜色
  286.      * @return
  287.      */
  288.     private static int[] getRandomRgb() {
  290.         int[] rgb = new int[3];
  291.         for (int i = 0; i < 3; i++) {
  293.             rgb[i] = random.nextInt(255);
  294.         }
  295.         return rgb;
  296.     }
  298.     /**
  299.      * 使图片扭曲
  300.      * @param g
  301.      * @param w1
  302.      * @param h1
  303.      * @param color
  304.      */
  305.     private static void shear(Graphics g, int w1, int h1, Color color) {
  307.         distortionX(g, w1, h1, color);
  308.         distortionY(g, w1, h1, color);
  309.     }
  311.     /**
  312.      * 使图片x轴扭曲
  313.      * @param g
  314.      * @param w1
  315.      * @param h1
  316.      * @param color
  317.      */
  318.     private static void distortionX(Graphics g, int w1, int h1, Color color) {
  320.         int period = random.nextInt(4);
  321.         boolean borderGap = true;
  322.         int frames = 2;
  323.         int phase = random.nextInt(4);
  324.         for (int i = 0; i < h1; i++) {
  326.             double d = (double) (period >> 1) * Math.sin((double) i / (double) period + (6.2831853071795862D * (double) phase) / (double) frames);
  327.             g.copyArea(0, i, w1, 1, (int) d, 0);
  328.             if (borderGap) {
  330.                 g.setColor(color);
  331.                 g.drawLine((int) d, i, 0, i);
  332.                 g.drawLine((int) d + w1, i, w1, i);
  333.             }
  334.         }
  335.     }
  337.     /**
  338.      * 使图片y轴扭曲
  339.      * @param g
  340.      * @param w1
  341.      * @param h1
  342.      * @param color
  343.      */
  344.     private static void distortionY(Graphics g, int w1, int h1, Color color) {
  346.         int period = random.nextInt(20) + 10;
  347.         boolean borderGap = true;
  348.         int frames = 20;
  349.         int phase = 8;
  350.         for (int i = 0; i < w1; i++) {
  352.             double d = (double) (period >> 1) * Math.sin((double) i / (double) period + (6.2831853071795862D * (double) phase) / (double) frames);
  353.             g.copyArea(i, 0, 1, h1, 0, (int) d);
  354.             if (borderGap) {
  356.                 g.setColor(color);
  357.                 g.drawLine(i, (int) d, i, 0);
  358.                 g.drawLine(i, (int) d + h1, i, h1);
  359.             }
  361.         }
  362.     }
  364.     /**
  365.      * 创建字体
  366.      * @param style 字体样式
  367.      * @param size  字体大小
  368.      * @return 字体
  369.      */
  370.     private static Font createFont(int style, int size) {
  372.         if (cacheFont != null) {
  374.             return cacheFont.deriveFont(style, size);
  375.         } else {
  377.             cacheFont = loadFont();
  378.             return cacheFont;
  379.         }
  380.     }
  382.     /**
  383.      * 加载字体，解决Centos 7.2 以后，使用OpenJDK11 生成不了验证码问题
  384.      * @return 生成验证码的字体
  385.      */
  386.     private static Font loadFont() {
  389.         if (StringUtils.startsWithIgnoreCase(System.getProperty("os.name"), "windows")) {
  391.             // windows 操作系统直接返回即可
  392.             return new Font("Fixedsys", Font.BOLD, 0);
  393.         } else {
  395.             // linux 操作系统字体需要特殊处理
  396.             try {
  398.                 InputStream inputStream = null;
  399.                 Resource fontFile = new DefaultResourceLoader().getResource("classpath:ALGER.TTF");
  400.                 try {
  402.                     // 加载字体配置文件
  403.                     Resource fontProperties = new DefaultResourceLoader().getResource("classpath:fontconfig.properties");
  404.                     System.setProperty("sun.awt.fontconfig", fontProperties.getURL().getPath());
  405.                     inputStream = fontFile.getInputStream();
  406.                     return Font.createFont(Font.TRUETYPE_FONT, inputStream);
  407.                 } catch (Exception e) {
  409.                     log.error("Create Font Error", e);
  410.                 } finally {
  412.                     IOUtils.closeQuietly(inputStream);
  413.                 }
  414.             } catch (Exception e) {
  416.                 log.error("Load Font Error", e);
  417.             }
  418.             return null;
  419.         }
  420.     }
  422.     /**
  423.      * 生成验证码
  424.      * @param code
  425.      * @param imgWidth
  426.      * @param imgHeight
  427.      * @return
  428.      */
  429.     private static String generateCaptchaImage(String code, Integer imgWidth, Integer imgHeight) {
  431.         if (StringUtils.isBlank(code)) {
  433.             return null;
  434.         }
  435.         imgWidth = imgWidth == null ? VerifyCodeUtils.imgWidth : imgWidth;
  436.         imgHeight = imgHeight == null ? VerifyCodeUtils.imgHeight: imgHeight;
  437.         Integer codeLength = code.length();
  438.         BufferedImage bufferedImg = null;
  439.         String base64Img = null;
  440.         try {
  442.             int x = 0;
  443.             // 每个字符的宽度
  444.             x = imgWidth / (codeLength + 1);
  445.             int fontHeight = 0;
  446.             // 字体的高度
  447.             fontHeight = imgHeight - 10;
  448.             float codeY;
  449.             codeY = (float) (imgHeight - 10.1);
  450.             // 生成一张图片
  451.             bufferedImg = new BufferedImage(imgWidth, imgHeight, BufferedImage.TYPE_INT_RGB);
  452.             Graphics2D graph = bufferedImg.createGraphics();
  453.             // 填充图片颜色
  454.             graph.setColor(Color.WHITE);
  455.             graph.fillRect(0, 0, imgWidth, imgHeight);
  456.             // 创建字体
  457.             Font font = new Font("Fixedsys", Font.TRUETYPE_FONT, fontHeight);
  458.             graph.setFont(font);
  459.             Random random = new Random();
  460.             // 随机画干扰的圈圈
  461.             int red = 0;
  462.             int green = 0;
  463.             int blue = 0;
  464.             for (int i = 0; i < 10; i++) {
  466.                 int xs = random.nextInt(imgWidth);
  467.                 int ys = random.nextInt(imgHeight);
  468.                 int xe = random.nextInt(imgWidth / 16);
  469.                 int ye = random.nextInt(imgHeight / 16);
  470.                 red = random.nextInt(255);
  471.                 green = random.nextInt(255);
  472.                 blue = random.nextInt(255);
  473.                 graph.setColor(new Color(red, green, blue));
  474.                 graph.drawOval(xs, ys, xe, ye);
  475.             }
  476.             // 画随机线
  477.             for (int i = 0; i < 20; i++) {
  479.                 int xs = random.nextInt(imgWidth);
  480.                 int ys = random.nextInt(imgHeight);
  481.                 int xe = xs + random.nextInt(imgWidth / 16);
  482.                 int ye = ys + random.nextInt(imgHeight / 16);
  483.                 red = random.nextInt(255);
  484.                 green = random.nextInt(255);
  485.                 blue = random.nextInt(255);
  486.                 graph.setColor(new Color(red, green, blue));
  487.                 graph.drawLine(xs, ys, xe, ye);
  488.             }
  490.             // 产生随机的颜色值，让输出的每个字符的颜色值都将不同。
  491.             for (int i = 0; i < codeLength; i++) {
  493.                 red = random.nextInt(225);
  494.                 green = random.nextInt(225);
  495.                 blue = random.nextInt(225);
  496.                 graph.setColor(new Color(red, green, blue));
  497.                 String c = String.valueOf(code.charAt(i));
  498.                 graph.drawString(c, (float) (i + 0.5) * x, codeY);
  499.             }
  500.             ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
  501.             ImageIO.write(bufferedImg, "jpg", outputStream);
  502.             Base64.Encoder encoder = Base64.getEncoder();
  503.             base64Img = encoder.encodeToString(outputStream.toByteArray());
  504.             base64Img = base64Img.replaceAll("\n", "").replaceAll("\r", "");
  505.         } catch (Exception e) {
  507.             log.error("生成验证码异常：", e);
  508.         }
  509. //        return "data:image/jpg;base64," + base64Img;
  510.         return base64Img;
  511.     }
  512. }

发表评论

表情：
评论列表 （有 0 条评论，126人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java生成图片验证码

    功能介绍：自定义图片尺寸和字符长度，随机背景颜色和字符颜色，随机字符偏移角度，字符平滑边缘，干扰线，噪点，背景扭曲。 VerifyCodeUtils类，生成图片流，然后不同框

    素颜马尾好姑娘i素颜马尾好姑娘i/ 0 赞/ 393 阅读