Java 验证码生成的两种方式【开箱即用】

最新推荐文章于 2024-05-31 14:02:53 发布
最新推荐文章于 2024-05-31 14:02:53 发布
阅读量1.2k 收藏 12
点赞数 18
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43108153/article/details/136492231
版权

小伙伴们好，欢迎关注，一起学习，无限进步

文章目录

通用公共配置

公共依赖

SpringBoot项目

<!-- redis 缓存 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<!-- pool 对象池，springboot2.x以后用得是lettuce,添加连接池依赖 -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>

<!-- 方法二需要用到的jar包 -->
<dependency>
    <groupId>com.github.penggle</groupId>
    <artifactId>kaptcha</artifactId>
    <version>2.3.2</version>
</dependency>

配置 application.yml 文件

spring:
  # redis 配置
  redis:
    # 地址
    host: localhost
    # 端口，默认为6379
    port: 6379
    # 数据库索引
    database: 0
    # 密码
    password:
    # 连接超时时间
    timeout: 10s
    lettuce:
      pool:
        # 连接池中的最小空闲连接
        min-idle: 0
        # 连接池中的最大空闲连接
        max-idle: 8
        # 连接池的最大数据库连接数
        max-active: 8
        # #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1ms

公共常量

/**
 * 公共常量
 */
public class ConstantCode {

    /**
     * 系统缓存常量
     */
    public static final String KAPTCHA_KEY = "ss:kaptcha";
    public static final Long REDIS_EXP_TIME = 60 * 60L;
    public static final Long KAPTCHA_EXP_TIME = 60 * 3L;

    /**
     * 验证码宽高常量
     */
    public static final Integer WIDTH = 200;
    public static final Integer HEIGHT = 55;

    /**
     * 图片后缀名称
     */
    public static final String IMG_JPG = "jpg";
    public static final String IMG_PNG = "png";
    public static final String IMG_JPEG = "jpeg";

}

Redis 序列化配置

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {
    
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        // 为了自己开发方便，一般直接使用 <String, Object>
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(factory);

        // Json序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // String 的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();

        return template;
    }
}

Redis 工具类

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.Collection;
import java.util.concurrent.TimeUnit;

/**
 * Redis工具类
 */
@Component
@SuppressWarnings("all")
public class RedisUtils {

    /**
     * 日志对象
     */
    private static Logger logger = LoggerFactory.getLogger(RedisUtils.class);

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key      缓存的键值
     * @param value    缓存的值
     * @param timeout  时间
     * @param timeUnit 时间颗粒度
     */
    public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit) {
        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }

    /**
     * 获得缓存的基本对象。
     *
     * @param key 缓存键值
     * @return 缓存键值对应的数据
     */
    public <T> T getCacheObject(final String key) {
        ValueOperations<String, T> operation = redisTemplate.opsForValue();
        return operation.get(key);
    }

    /**
     * 获得缓存的基本对象列表
     *
     * @param pattern 字符串前缀
     * @return 对象列表
     */
    public Collection<String> keys(final String pattern) {
        return redisTemplate.keys(pattern);
    }

    /**
     * 删除集合对象
     *
     * @param collection 多个对象
     * @return
     */
    public long deleteObject(final Collection collection) {
        return redisTemplate.delete(collection);
    }

    /**
     * 指定缓存失效时间
     *
     * @param key  键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            logger.error("RedisUtils expire(String key,long time) failure." + e.getMessage());
            return false;
        }
    }

    /**
     * 根据key 获取过期时间
     *
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            logger.error("RedisUtils hasKey(String key) failure." + e.getMessage());
            return false;
        }
    }

    /**
     * 删除缓存
     *
     * @param key 可以传一个值 或多个
     */
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    //============================String=============================

    /**
     * 普通缓存获取
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     *
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            logger.error("RedisUtils set(String key,Object value) failure." + e.getMessage());
            return false;
        }
    }

    /**
     * 普通缓存放入并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            logger.error("RedisUtils set(String key,Object value,long time) failure." + e.getMessage());
            return false;
        }
    }
}

通用返回结果封装

import org.springframework.http.HttpStatus;
import org.springframework.util.StringUtils;
import java.util.HashMap;

/**
 * 操作消息提醒
 */
public class Result extends HashMap<String, Object> {
    private static final long serialVersionUID = 1L;

    /**
     * 状态码
     */
    public static final String CODE_TAG = "code";

    /**
     * 返回内容
     */
    public static final String MSG_TAG = "msg";

    /**
     * 数据对象
     */
    public static final String DATA_TAG = "data";

    /**
     * 初始化一个新创建的 AjaxResult 对象，使其表示一个空消息。
     */
    public Result() {
    }

    /**
     * 初始化一个新创建的 AjaxResult 对象
     *
     * @param code 状态码
     * @param msg  返回内容
     */
    public Result(int code, String msg) {
        super.put(CODE_TAG, code);
        super.put(MSG_TAG, msg);
    }

    /**
     * 初始化一个新创建的 AjaxResult 对象
     *
     * @param code 状态码
     * @param msg  返回内容
     * @param data 数据对象
     */
    public Result(int code, String msg, Object data) {
        super.put(CODE_TAG, code);
        super.put(MSG_TAG, msg);
        if (!StringUtils.isEmpty(data)) {
            super.put(DATA_TAG, data);
        }
    }

    /**
     * 返回成功消息
     *
     * @return 成功消息
     */
    public static Result success() {
        return Result.success("操作成功");
    }

    /**
     * 返回成功数据
     *
     * @return 成功消息
     */
    public static Result success(Object data) {
        return Result.success("操作成功", data);
    }

    /**
     * 返回成功消息
     *
     * @param msg 返回内容
     * @return 成功消息
     */
    public static Result success(String msg) {
        return Result.success(msg, null);
    }

    /**
     * 返回成功消息
     *
     * @param msg  返回内容
     * @param data 数据对象
     * @return 成功消息
     */
    public static Result success(String msg, Object data) {
        return new Result(HttpStatus.OK.value(), msg, data);
    }

    /**
     * 返回错误消息
     *
     * @return
     */
    public static Result error() {
        return Result.error("操作失败");
    }

    /**
     * 返回错误消息
     *
     * @param msg 返回内容
     * @return 警告消息
     */
    public static Result error(String msg) {
        return Result.error(msg, null);
    }

    /**
     * 返回错误消息
     *
     * @param msg  返回内容
     * @param data 数据对象
     * @return 警告消息
     */
    public static Result error(String msg, Object data) {
        return new Result(HttpStatus.INTERNAL_SERVER_ERROR.value(), msg, data);
    }

    /**
     * 返回错误消息
     *
     * @param code 状态码
     * @param msg  返回内容
     * @return 警告消息
     */
    public static Result error(int code, String msg) {
        return new Result(code, msg, null);
    }

    /**
     * 方便链式调用
     *
     * @param key   键
     * @param value 值
     * @return 数据对象
     */
    @Override
    public Result put(String key, Object value) {
        super.put(key, value);
        return this;
    }
}

方法一：Graphics2D 画图实现

使用 jdk 画图 Graphics2D 生成验证码

1、验证码工具类

import java.awt.*;
import java.awt.image.BufferedImage;
import java.util.Random;

/**
 * 验证码工具类
 */
public class VerifyCodeUtils {

    /**
     * 传入BufferedImage对象，并将生成好的验证码保存到BufferedImage中
     */
    public static String drawRandomText(BufferedImage bufferedImage, int width, int height) {
        Graphics2D graphics = (Graphics2D) bufferedImage.getGraphics();
        // 验证码背景色
        graphics.setColor(new Color(255, 255, 255));
        // 填充线条背景
        graphics.fillRect(0, 0, width, height);
        graphics.setFont(new Font("宋体,楷体,微软雅黑", Font.BOLD, 35));
        // 数字和字母的组合
        String baseNumLetter = "ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
        StringBuilder builder = new StringBuilder();
        // 旋转原点的 x 坐标
        int x = 40;
        String ch;
        Random random = new Random();
        for (int i = 0; i < 4; i++) {
            graphics.setColor(getRandomColor());
            //设置字体旋转角度,角度小于30度
            int degree = random.nextInt() % 30;
            int dot = random.nextInt(baseNumLetter.length());
            ch = baseNumLetter.charAt(dot) + "";
            builder.append(ch);
            //正向旋转
            graphics.rotate(degree * Math.PI / 180, x, 45);
            graphics.drawString(ch, x, 45);
            //反向旋转
            graphics.rotate(-degree * Math.PI / 180, x, 45);
            // 字母间距记录
            x += 35;
        }
        // 画干扰线
        for (int i = 0; i < 6; i++) {
            // 设置随机颜色
            graphics.setColor(getRandomColor());
            // 随机画线
            graphics.drawLine(random.nextInt(width), random.nextInt(height), random.nextInt(width), random.nextInt(height));
        }
        // 添加噪点
        for (int i = 0; i < 30; i++) {
            int x1 = random.nextInt(width);
            int y1 = random.nextInt(height);
            graphics.setColor(getRandomColor());
            graphics.fillRect(x1, y1, 2, 2);
        }
        return builder.toString();
    }

    /**
     * 随机取色
     */
    private static Color getRandomColor() {
        Random ran = new Random();
        return new Color(ran.nextInt(256), ran.nextInt(256), ran.nextInt(256));
    }
}

2、Controller 控制层

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.FastByteArrayOutputStream;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.imageio.ImageIO;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.Base64;
import java.util.UUID;

@RestController
public class VerificationController {

    @Autowired
    private RedisUtils redisUtils;

    /**
     * 验证码生成工具，返回图片信息
     * 适合学习练手使用，redis 呢能存在一个
     * @param response
     * @throws IOException
     */
    @GetMapping("/getImageCode")
    public void getImageCode(HttpServletResponse response) throws IOException {
        // 禁止缓存
        response.setDateHeader("Expires", 0);
        response.setHeader("Cache-Control", "no-store, no-cache, must-revalidate");
        response.addHeader("Cache-Control", "post-check=0, pre-check=0");
        response.setHeader("Pragma", "no-cache");
        // 设置响应格式为png图片
        response.setContentType("image/png");
        // 生成图片验证码
        BufferedImage image = new BufferedImage(ConstantCode.WIDTH, ConstantCode.HEIGHT, BufferedImage.TYPE_INT_RGB);
        String randomText = VerifyCodeUtils.drawRandomText(image, ConstantCode.WIDTH, ConstantCode.HEIGHT);
        // 存入redis
        redisUtils.set(ConstantCode.KAPTCHA_KEY, randomText, ConstantCode.KAPTCHA_EXP_TIME);
        ServletOutputStream out = response.getOutputStream();
        ImageIO.write(image, ConstantCode.IMG_JPG, out);
        out.flush();
        out.close();
    }

    /**
     * 验证码 Base64
     * 可生成多个
     * @return
     */
    @GetMapping("/getCaptchaInfo")
    public Result getCaptchaInfo() {
        Result success = Result.success();
        // 生成图片验证码
        BufferedImage image = new BufferedImage(ConstantCode.WIDTH, ConstantCode.HEIGHT, BufferedImage.TYPE_INT_RGB);
        String uuid = UUID.randomUUID().toString().replace("-", "");
        // 验证码key
        String verifyKey = ConstantCode.KAPTCHA_KEY + uuid;
        String randomText = VerifyCodeUtils.drawRandomText(image, ConstantCode.WIDTH, ConstantCode.HEIGHT);
        // 存入redis
        redisUtils.set(verifyKey, randomText, ConstantCode.KAPTCHA_EXP_TIME);
        // 转换流信息写出
        FastByteArrayOutputStream os = new FastByteArrayOutputStream();
        try {
            ImageIO.write(image, "jpg", os);
        } catch (IOException e) {
            return Result.error(e.getMessage());
        }
        success.put("uuid", uuid);
        success.put("img", Base64.getEncoder().encodeToString(os.toByteArray()));
        return success;
    }
}

方法二：kaptcha 依赖实现

1、验证码配置

import com.google.code.kaptcha.impl.DefaultKaptcha;
import com.google.code.kaptcha.util.Config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.Properties;
import static com.google.code.kaptcha.Constants.*;

/**
 * 验证码配置
 */
@Configuration
public class CaptchaConfig {
    @Bean(name = "captchaProducer")
    public DefaultKaptcha getKaptchaBean() {
        DefaultKaptcha defaultKaptcha = new DefaultKaptcha();
        Properties properties = new Properties();
        // 是否有边框 默认为true 我们可以自己设置yes，no
        properties.setProperty(KAPTCHA_BORDER, "yes");
        // 验证码文本字符颜色 默认为Color.BLACK
        properties.setProperty(KAPTCHA_TEXTPRODUCER_FONT_COLOR, "black");
        // 验证码图片宽度 默认为200
        properties.setProperty(KAPTCHA_IMAGE_WIDTH, "160");
        // 验证码图片高度 默认为50
        properties.setProperty(KAPTCHA_IMAGE_HEIGHT, "60");
        // 验证码文本字符大小 默认为40
        properties.setProperty(KAPTCHA_TEXTPRODUCER_FONT_SIZE, "38");
        // KAPTCHA_SESSION_KEY
        properties.setProperty(KAPTCHA_SESSION_CONFIG_KEY, "kaptchaCode");
        // 验证码文本字符长度 默认为5
        properties.setProperty(KAPTCHA_TEXTPRODUCER_CHAR_LENGTH, "4");
        // 验证码文本字体样式 默认为new Font("Arial", 1, fontSize), new Font("Courier", 1, fontSize)
        properties.setProperty(KAPTCHA_TEXTPRODUCER_FONT_NAMES, "Arial,Courier");
        // 图片样式 水纹com.google.code.kaptcha.impl.WaterRipple 鱼眼com.google.code.kaptcha.impl.FishEyeGimpy 阴影com.google.code.kaptcha.impl.ShadowGimpy
        properties.setProperty(KAPTCHA_OBSCURIFICATOR_IMPL, "com.google.code.kaptcha.impl.ShadowGimpy");
        Config config = new Config(properties);
        defaultKaptcha.setConfig(config);
        return defaultKaptcha;
    }

    @Bean(name = "captchaProducerMath")
    public DefaultKaptcha getKaptchaBeanMath() {
        DefaultKaptcha defaultKaptcha = new DefaultKaptcha();
        Properties properties = new Properties();
        // 是否有边框 默认为true 我们可以自己设置yes，no
        properties.setProperty(KAPTCHA_BORDER, "yes");
        // 边框颜色 默认为Color.BLACK
        properties.setProperty(KAPTCHA_BORDER_COLOR, "105,179,90");
        // 验证码文本字符颜色 默认为Color.BLACK
        properties.setProperty(KAPTCHA_TEXTPRODUCER_FONT_COLOR, "blue");
        // 验证码图片宽度 默认为200
        properties.setProperty(KAPTCHA_IMAGE_WIDTH, "160");
        // 验证码图片高度 默认为50
        properties.setProperty(KAPTCHA_IMAGE_HEIGHT, "60");
        // 验证码文本字符大小 默认为40
        properties.setProperty(KAPTCHA_TEXTPRODUCER_FONT_SIZE, "35");
        // KAPTCHA_SESSION_KEY
        properties.setProperty(KAPTCHA_SESSION_CONFIG_KEY, "kaptchaCodeMath");
        // 验证码文本生成器 注意：KaptchaTextCreator的路径
        properties.setProperty(KAPTCHA_TEXTPRODUCER_IMPL, "com.test.demo.KaptchaTextCreator");
        // 验证码文本字符间距 默认为2
        properties.setProperty(KAPTCHA_TEXTPRODUCER_CHAR_SPACE, "3");
        // 验证码文本字符长度 默认为5
        properties.setProperty(KAPTCHA_TEXTPRODUCER_CHAR_LENGTH, "6");
        // 验证码文本字体样式 默认为new Font("Arial", 1, fontSize), new Font("Courier", 1, fontSize)
        properties.setProperty(KAPTCHA_TEXTPRODUCER_FONT_NAMES, "Arial,Courier");
        // 验证码噪点颜色 默认为Color.BLACK
        properties.setProperty(KAPTCHA_NOISE_COLOR, "white");
        // 干扰实现类
        properties.setProperty(KAPTCHA_NOISE_IMPL, "com.google.code.kaptcha.impl.NoNoise");
        // 图片样式 水纹com.google.code.kaptcha.impl.WaterRipple 鱼眼com.google.code.kaptcha.impl.FishEyeGimpy 阴影com.google.code.kaptcha.impl.ShadowGimpy
        properties.setProperty(KAPTCHA_OBSCURIFICATOR_IMPL, "com.google.code.kaptcha.impl.ShadowGimpy");
        Config config = new Config(properties);
        defaultKaptcha.setConfig(config);
        return defaultKaptcha;
    }
}

2、验证码文本生成器

import com.google.code.kaptcha.text.impl.DefaultTextCreator;
import java.util.Random;

/**
 * 验证码文本生成器
 */
public class KaptchaTextCreator extends DefaultTextCreator {
    private static final String[] CNUMBERS = "0,1,2,3,4,5,6,7,8,9,10".split(",");

    @Override
    public String getText() {
        Integer result = 0;
        Random random = new Random();
        int x = random.nextInt(10);
        int y = random.nextInt(10);
        StringBuilder suChinese = new StringBuilder();
        int randomoperands = (int) Math.round(Math.random() * 2);
        if (randomoperands == 0) {
            result = x * y;
            suChinese.append(CNUMBERS[x]);
            suChinese.append("*");
            suChinese.append(CNUMBERS[y]);
        } else if (randomoperands == 1) {
            if (!(x == 0) && y % x == 0) {
                result = y / x;
                suChinese.append(CNUMBERS[y]);
                suChinese.append("/");
                suChinese.append(CNUMBERS[x]);
            } else {
                result = x + y;
                suChinese.append(CNUMBERS[x]);
                suChinese.append("+");
                suChinese.append(CNUMBERS[y]);
            }
        } else if (randomoperands == 2) {
            if (x >= y) {
                result = x - y;
                suChinese.append(CNUMBERS[x]);
                suChinese.append("-");
                suChinese.append(CNUMBERS[y]);
            } else {
                result = y - x;
                suChinese.append(CNUMBERS[y]);
                suChinese.append("-");
                suChinese.append(CNUMBERS[x]);
            }
        } else {
            result = x + y;
            suChinese.append(CNUMBERS[x]);
            suChinese.append("+");
            suChinese.append(CNUMBERS[y]);
        }
        suChinese.append("=?@" + result);
        return suChinese.toString();
    }
}

3、测试正码生成

import com.google.code.kaptcha.Producer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.FastByteArrayOutputStream;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.Base64;
import java.util.UUID;

/**
 * 验证码操作处理
 */
@RestController
public class CaptchaController {
    @Resource(name = "captchaProducer")
    private Producer captchaProducer;

    @Resource(name = "captchaProducerMath")
    private Producer captchaProducerMath;

    @Autowired
    private RedisUtils redisUtils;

    /**
     * 文本验证码
     *
     * @return
     */
    @GetMapping("/captchaCharImage")
    public Result getCharCode() {
        Result ajax = Result.success();
        // 生成验证码
        String capText = captchaProducerMath.createText();
        String capStr = capText.substring(0, capText.lastIndexOf("@"));
        String code = capText.substring(capText.lastIndexOf("@") + 1);
        BufferedImage image = captchaProducerMath.createImage(capStr);
        // 保存验证码信息
        String uuid = UUID.randomUUID().toString().replace("-", "");
        String verifyKey = ConstantCode.KAPTCHA_KEY + uuid;
        redisUtils.set(verifyKey, code, ConstantCode.KAPTCHA_EXP_TIME);
        // 转换流信息写出
        FastByteArrayOutputStream os = new FastByteArrayOutputStream();
        try {
            ImageIO.write(image, "jpg", os);
        } catch (IOException e) {
            return Result.error(e.getMessage());
        }
        ajax.put("uuid", uuid);
        ajax.put("img", Base64.getEncoder().encodeToString(os.toByteArray()));
        return ajax;
    }

    /**
     * 生成验证码
     */
    @GetMapping("/captchaMathImage")
    public Result getMathCode() {
        Result ajax = Result.success();
        // 生成验证码
        String capText = captchaProducer.createText();
        BufferedImage image = captchaProducerMath.createImage(capText);

        // 保存验证码信息
        String uuid = UUID.randomUUID().toString().replace("-", "");
        String verifyKey = ConstantCode.KAPTCHA_KEY + uuid;
        redisUtils.set(verifyKey, capText, ConstantCode.KAPTCHA_EXP_TIME);
        // 转换流信息写出
        FastByteArrayOutputStream os = new FastByteArrayOutputStream();
        try {
            ImageIO.write(image, "jpg", os);
        } catch (IOException e) {
            return Result.error(e.getMessage());
        }
        ajax.put("uuid", uuid);
        ajax.put("img", Base64.getEncoder().encodeToString(os.toByteArray()));
        return ajax;
    }
}
师小师
关注
  • 18
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java生成图片验证码工具类源码
10-24
源码提供了一个生成图片验证码的工具类，适用于各种需要验证码的场景，如用户注册、登录等。该工具类使用随机字符生成验证码，并支持自定义验证码长度和字体样式。生成的验证码图片背景透明，线条清晰，可轻松辨认。本源码包含了工具类源码及调用示例，可供开发者参考使用，集成到您的项目中。
浅析Java验证码生成库JCaptcha
09-01
Java验证码生成库JCaptcha是一个广泛使用的开源库，用于在Java应用程序中创建安全的、难以破解的验证码。验证码（CAPTCHA）的主要目的是防止自动化程序（如机器人或爬虫）进行恶意操作，例如注册虚假账户或进行大量...
Java io生成验证码及easy-captcha实现验证码功能
qq_57570052的博客
07-24 560
要使用 EasyCaptcha，首先你需要添加 EasyCaptcha 的依赖到你的项目中。EasyCaptcha 是一个简单易用的 Java 验证码生成工具，它提供了简单的 API 来生成和验证各种类型的验证码。EasyCaptcha 还提供了一些其他的配置选项，例如自定义验证码的宽度、高度、字体、干扰线等等。用户输入验证码后，你可以通过比较用户输入的验证码和生成的验证码的值来验证其正确性。一旦你添加了 EasyCaptcha 的依赖，你就可以开始使用它了。在 Gradle 中，你可以在。
Java使用Hutool工具类轻松生成验证码
最新发布
阿木木AEcru的博客
05-31 1528
本文使用Hutool工具类实现了验证码生成。验证码是一种广泛应用于网络服务中的安全机制，用于验证用户身份，防止恶意软件和自动化脚本的滥用。
二维码一键生成java版本，源码已经给出
weixin_51497782的博客
01-28 1069
一键生成前端验证二维码，傻瓜式操作，不懂代码逻辑也可以用，java语言
java实现图片验证码全套实现方式
热门推荐
起而行动，方能平定心中的惶恐
05-05 2万+
##百度网盘demo提取地址: https://pan.baidu.com/s/1dF81khNhttps://github.com/rundreamstop/graphic-validate-code##java引用的包 ##控制器代码 ##CaptchaFactory实现代码
Java案例----生成随机验证码
weixin_65237252的博客
01-08 4300
Java生成随机的验证码，登录系统必备的验证手段。
Java：开发验证码
m0_68783582的博客
05-18 213
/大写字符（A 65 - Z 65+25） （0 - 25） + 65。//小写字符（a 97 - z 97+25） （0 - 25） + 97。1.定义一个方法返回一个随机验证码：要返回值类型声明：String 要申明形参：int n。System.out.println("随机验证码是：" + code);//3.生成一个随机字符：英文大写 小写 数字（0 1 2）//2.定义一个for循环，循环n次，依次生成随机字符。//3.定义一个字符串变量记录生成的随机字符。数字、大写字母、小写字母。
java生成随机图片验证码
08-25
Java生成随机图片验证码是指使用Java语言生成随机图片验证码的技术。该技术广泛应用于Web开发中，用于验证用户身份，防止机器人攻击和泄露用户信息。下面将详细介绍Java生成随机图片验证码的知识点。 一、验证码的...
Java随机生成手机短信验证码的方法
09-03
在Java编程中，生成手机短信验证码是一个常见的任务，主要用于身份验证和安全目的。验证码通常是一串随机的数字或字母组合，用户需要在限定时间内输入到系统中以完成验证。下面我们将详细探讨如何使用Java实现这一...
Java生成图形验证码工具类
08-31
主要介绍了Java生成图形验证码工具类,本文思路明确介绍的非常详细，需要的朋友可以参考下
java实现验证码
01-25
java封装实现验证码工具类，可以直接使用，生成验证码
java 随机生成6位短信验证码实例代码
08-25
在Java编程中，生成短信验证码是一项常见的安全措施，主要用于验证用户身份，比如在注册、登录或修改重要信息时。本文将详细讲解如何在Java中生成6位数字的短信验证码，并结合一个具体的实例来演示发送短信验证码的...
【JavaEE进阶】实现验证码
m0_71731682的博客
01-21 1403
Kaptcha是Google的⼀个⾼度可配置的实⽤验证码⽣成⼯具.代码:代码链接项目地址下⾯简单介绍下插件的使⽤接口一：⽣成验证码请求：响应：图片内容浏览器给服务器发送⼀个 GET /admin/captcha 这样的请求,服务器返回⼀个图⽚,浏览器显⽰在⻚⾯上接口二：校验验证码是否正确请求:/admin/checkcaptcha:⽤⼾输⼊的验证码响应：true根据⽤⼾输⼊的验证码,校验验证码是否正确true:验证成功.false:验证失败。
java生成图片验证码,前端回显
qq_42289887的博客
03-14 508
【代码】java生成图片验证码,前端回显。
Kaptcha——图片验证码生成工具
weixin_61974247的博客
08-19 1291
Kaptcha 是一个Google开源、可自由配置的图片验证码生成工具，可以根据属性来设置自己想要的基本意义上的验证码
Java实现验证码
weixin_44273367的博客
08-16 286
drawString(String text,横坐标,纵坐标) 绘制文字。创建方法：new BufferedImage(图片的类型，宽，高)9）登录时将用户填写的验证码和Session中的验证码进行比较。drawLine(横坐标,纵坐标,横坐标,纵坐标) 绘制线条。BufferedImage 缓冲图片（保存在内存中的图片）涉及的知识点：图形的绘制，Session会话的使用，JS。fillRect(横坐标,纵坐标,宽,高) 填充矩形。4）使用绘图对象绘制随机的字母或数字。1）选取4个随机的字母或数字。
随机生成验证码——Java
m0_67428547的博客
11-26 2154
在日常生活中，我们总是能用到各种各样的验证码，本文就是介绍生成验证码的方法。
后端Java验证码实现
总结复盘，才能不迷失自己！
06-30 466
java验证码
Java中字符串两种生成方式的区别。
06-12
在Java中，字符串有两种生成方式：直接赋值和通过构造方法生成。它们之间的区别如下： 1. 直接赋值方式：使用双引号括起来的字符串，例如："Hello World"。这种方式会在Java的字符串常量池中创建字符串对象，如果常量池中已经存在相同的字符串对象，那么直接返回该对象的引用。因此，如果使用多个字符串常量来表示相同的字符串，它们实际上都是同一个对象。 2. 构造方法方式：使用String类的构造方法，例如：new String("Hello World")。这种方式会在堆中创建一个新的字符串对象，即使该字符串与常量池中的某个字符串值相同，它也会被创建为一个新的对象。因此，如果使用多个构造方法来表示相同的字符串，它们实际上是不同的对象。 需要注意的是，由于字符串常量池是存储在方法区中的，因此在多个线程共享字符串常量池时需要考虑线程安全问题。而使用字符串构造方法生成的字符串对象则不会存在线程安全问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

师小师

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值