关于后端:说说验证码功能的实现

前言

大家好，我是 god23bin，明天说说验证码性能的实现，置信大家都常常接触到验证码的，毕竟平时上网也能遇到各种验证码，须要咱们输出验证码进行验证咱们是人类，而不是机器人。

验证码有多种类型，比方图片验证码、短信验证码和邮件验证码等等，虽说多种类型，图片也好，短信也好，邮件也好，都是承载验证码的载体，最次要的外围就是一个验证码的生成、存储和校验。

本篇文章就从这几个方面登程说说验证码，废话不多说，上面开始注释。

实现思路

验证码验证的性能，其实现思路还是挺简略的，不论是图片验证码、短信验证码还是邮件验证码，无非就以下几点：

1. 验证码实质就是一堆字符的组合（数字也好，英文字母也好），后端生成验证码，并存储到某个地位（比方存储到 Redis，并设置验证码的过期工夫）。
2. 返回验证码给前端页面、发送短信验证码给用户或者发送邮件验证码给用户。验证码能够是以文字显示或者图片显示。
3. 用户输出看到的验证码，并提交验证（验证也能够疏忽大小写，当然具体看需要）。
4. 后端将用户输出的验证码拿过去进行校验，比照用户输出的验证码是否和后端生成的统一，统一就验证胜利，否则验证失败。

验证码的生成

首先，须要晓得的就是验证码的生成，这就波及到生成验证码的算法，能够本人纯手写，也能够应用人家提供的工具，这里我就介绍上面 4 种生成验证码的形式。

1. 纯原生手写生成文本验证码

需要：随机产生一个 n 位的验证码，每位可能是数字、大写字母、小写字母。

实现：实质就是随机生成字符串，字符串可蕴含数字、大写字母、小写字母。

筹备一个蕴含数字、大写字母、小写字母的字符串，借助 Random 类，循环 n 次随机获取字符串的下标，就能拼接出一个随机字符组成的字符串了。

package cn.god23bin.demo.util;

import java.util.Random;

public class MyCaptchaUtil {

    /**
     * 生成 n 位验证码
     * @param n 位数
     * @return n 位验证码
     **/
    public static String generateCode(int n) {
        String chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        StringBuilder sb = new StringBuilder();
        Random random = new Random();
        for (int i = 0; i < n; i++) {int index = random.nextInt(chars.length());
            sb.append(chars.charAt(index));
        }
        return sb.toString();}
    
}

2. 纯原生手写生成图片验证码

实现：应用 Java 的 awt 和 swing 库来生成图片验证码。上面应用 BufferedImage 类创立一个指定大小的图片，而后随机生成 n 个字符，将其画在图片上，将生成的字符和图片验证码放到哈希表返回。后续咱们就能够拿到验证码的文本值，并且能够将图片验证码输入到指定的输入流中。

package cn.god23bin.demo.util;

import java.awt.*;
import java.awt.image.BufferedImage;
import java.util.HashMap;
import java.util.Map;

public class MyCaptchaUtil {

    /**
     * 生成 n 位的图片验证码
     * @param n 位数
     * @return 哈希表，code 获取文本验证码，img 获取 BufferedImage 图片对象
     **/
    public static Map<String, Object> generateCodeImage(int n) {
        int width = 100, height = 50;
        BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
        Graphics2D g = image.createGraphics();
        g.setColor(Color.LIGHT_GRAY);
        g.fillRect(0, 0, width, height);
        String chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        Random random = new Random();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < n; i++) {int index = random.nextInt(chars.length());
            char c = chars.charAt(index);
            sb.append(c);
            g.setColor(new Color(random.nextInt(255), random.nextInt(255), random.nextInt(255)));
            g.setFont(new Font("Arial", Font.BOLD, 25));
            g.drawString(Character.toString(c), 20 + i * 15, 25);
        }
        Map<String, Object> res = new HashMap<>();
        res.put("code", sb.toString());
        res.put("img", image);
        return res;
    }
    
}

咱们能够写一个获取验证码的接口，以二进制流输入返回给前端，前端能够间接应用 img 标签来显示咱们返回的图片，只需在 src 属性赋值咱们的获取验证码接口。

@RequestMapping("/captcha")
@RestController
public class CaptchaController {@GetMapping("/code/custom")
    public void getCode(HttpServletResponse response) {Map<String, Object> map = MyCaptchaUtil.generateCodeImage(5);
        System.out.println(map.get("code"));
        BufferedImage img = (BufferedImage) map.get("img");

        // 设置响应头，避免缓存
        response.setHeader("Cache-Control", "no-store, no-cache");
        response.setContentType("image/png");
        try {ImageIO.write(img, "png", response.getOutputStream());
        } catch (IOException e) {e.printStackTrace();
        }
    }

}

3. 应用 Hutool 工具生成图形验证码

引入依赖：能够独自引入验证码模块或者全副模块都引入

<!-- 验证码模块 -->
<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-captcha</artifactId>
    <version>5.8.15</version>
</dependency>

<!-- 全副模块都引入 -->
<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.8.15</version>
</dependency>

• 生成线段烦扰的验证码：

// 设置图形验证码的宽和高，同时生成了验证码，能够通过 lineCaptcha.getCode() 获取文本验证码
LineCaptcha lineCaptcha = CaptchaUtil.createLineCaptcha(200, 100);

• 生成圆圈烦扰的验证码：

// 设置图形验证码的宽、高、验证码字符数、烦扰元素个数
CircleCaptcha captcha = CaptchaUtil.createCircleCaptcha(200, 100, 4, 20);

• 生成扭曲烦扰的验证码：

// 定义图形验证码的宽、高、验证码字符数、烦扰线宽度
ShearCaptcha captcha = CaptchaUtil.createShearCaptcha(200, 100, 4, 4);

获取验证码接口：

@RequestMapping("/captcha")
@RestController
public class CaptchaController {@GetMapping("/code/hutool")
    public void getCodeByHutool(HttpServletResponse response) {LineCaptcha lineCaptcha = CaptchaUtil.createLineCaptcha(200, 100);
        System.out.println("线段烦扰的验证码：" + lineCaptcha.getCode());

        // 设置响应头，避免缓存
        response.setHeader("Cache-Control", "no-store, no-cache");
        response.setContentType("image/png");
        try {lineCaptcha.write(response.getOutputStream());
        } catch (IOException e) {e.printStackTrace();
        }
    }
}

4. 应用 Kaptcha 生成验证码

Kaptcha 是谷歌的一个生成验证码工具包，咱们简略配置其属性就能够实现验证码的验证性能。

引入依赖项：它只有一个版本：2.3.2

<dependency>
    <groupId>com.github.penggle</groupId>
    <artifactId>kaptcha</artifactId>
    <version>2.3.2</version>
</dependency>

简略看看 kaptcha 属性：

简略配置下 Kaptcha：

package cn.god23bin.demo.config;

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;

@Configuration
public class KaptchaConfig {
    /**
     * 配置生成图片验证码的 bean
     * @return
     */
    @Bean(name = "kaptchaProducer")
    public DefaultKaptcha getKaptchaBean() {DefaultKaptcha defaultKaptcha = new DefaultKaptcha();
        Properties properties = new Properties();
        properties.setProperty("kaptcha.border", "no");
        properties.setProperty("kaptcha.textproducer.font.color", "black");
        properties.setProperty("kaptcha.textproducer.char.space", "4");
        properties.setProperty("kaptcha.textproducer.char.length", "4");
        properties.setProperty("kaptcha.textproducer.char.string", "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");
        Config config = new Config(properties);
        defaultKaptcha.setConfig(config);
        return defaultKaptcha;
    }
}

也是和 Hutool 一样，很简略就能生成验证码了。如下：

// 生成文字验证码
String text = kaptchaProducer.createText();
// 生成图片验证码
BufferedImage image = kaptchaProducer.createImage(text);

获取验证码接口：

@RequestMapping("/captcha")
@RestController
public class CaptchaController {

    @Autowired
    private Producer kaptchaProducer;

    @GetMapping("/code/kaptcha")
    public void getCodeByKaptcha(HttpServletResponse response) {
        // 生成文字验证码
        String text = kaptchaProducer.createText();
        System.out.println("文字验证码：" + text);
        // 生成图片验证码
        BufferedImage image = kaptchaProducer.createImage(text);

        // 设置响应头，避免缓存
        response.setHeader("Cache-Control", "no-store, no-cache");
        response.setContentType("image/jpeg");
        try {ImageIO.write(image, "jpg", response.getOutputStream());
        } catch (IOException e) {e.printStackTrace();
        }
    }

}

验证码的存储与校验

下面的验证码的生成，就仅仅是生成验证码，并没有将验证码存储在后端，所以当初咱们须要做的是：将验证码存储起来，便于后续的校验比照。

那么存储到什么中央呢？如果你没接触过 Redis，那么第一次的想法可能就是存储到关系型数据库中，比方 MySQL。想当年，我最开始的想法就是这样哈哈哈。

不过，目前用得最多的就是将验证码存储到 Redis 中，益处就是缩小了数据库的压力，放慢了验证码的读取效率，还能轻松设置验证码的过期工夫。

简略配置 Redis

引入 Redis 依赖项：

咱们应用 Spring Data Redis，它提供了 RedisTemplate 和 StringRedisTemplate 模板类，简化了咱们应用 Java 进行 Redis 的操作。

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

简略配置下 Redis：

spring:
  redis:
    host: localhost
    port: 6379
    database: 1
    timeout: 5000

@Configuration
public class RedisConfig extends CachingConfigurerSupport {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        // 大多数状况，都是选用 <String, Object>
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);

        // 应用 JSON 的序列化对象，对数据 key 和 value 进行序列化转换
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        // ObjectMapper 是 Jackson 的一个工作类，作用是将 JSON 转成 Java 对象，即反序列化。或将 Java 对象转成 JSON，即序列化
        ObjectMapper mapper = new ObjectMapper();
        // 设置序列化时的可见性，第一个参数是抉择序列化哪些属性，比方时序列化 setter? 还是 filed? 第二个参数是抉择哪些修饰符权限的属性来序列化，比方 private 或者 public，这里的 any 是指对所有权限润饰的属性都可见(可序列化)
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        jackson2JsonRedisSerializer.setObjectMapper(mapper);
        // 设置 RedisTemplate 模板的序列化形式为 jacksonSeial
        template.setDefaultSerializer(jackson2JsonRedisSerializer);
        return template;
    }
    
}

将验证码存储到 Redis

将验证码存储到 Redis 设置 5 分钟的过期工夫，Redis 是 Key Value 这种模式存储的，所以须要约定好 Key 的命名规定。

命名的时候，为了辨别为每个用户生成的验证码，所以须要一个标识，刚好能够通过以后申请的 HttpSession 中的 SessionID 作为惟一标识，拼接到 Key 的名称中。

当然，也不肯定应用 SessionID 作为惟一标识，如果能晓得其余的，也能够用其余的作为标识，比方拼接用户的手机号。

实现：

@RequestMapping("/captcha")
@RestController
public class CaptchaController {

    @Autowired
    private Producer kaptchaProducer;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @GetMapping("/code")
    public void getCode(HttpServletRequest request, HttpServletResponse response) {
        // 生成文字验证码
        String text = kaptchaProducer.createText();
        System.out.println("文字验证码：" + text);
        // 生成图片验证码
        BufferedImage image = kaptchaProducer.createImage(text);

        // 存储到 Redis 设置 5 分钟的过期工夫
        // 约定好存储的 Key 的命名规定，这里应用 code_sessionId_type_1 示意图形验证码
        // Code_sessionId_Type_1：分为 3 局部，code 表明是验证码，sessionId 表明是给哪个用户的验证码，type_n 表明验证码类型，n 为 1 示意图形验证码，2 示意短信验证码，3 示意邮件验证码
        String key = "code_" + request.getSession().getId() + "_type_1";
        redisTemplate.opsForValue().set(key, text, 5, TimeUnit.SECONDS);

        response.setHeader("Cache-Control", "no-store, no-cache");
        response.setContentType("image/jpeg");
        try {ImageIO.write(image, "jpg", response.getOutputStream());
        } catch (IOException e) {e.printStackTrace();
        }
    }

}

下面代码中有一个额定的设计就是，因为发送的验证码有多种类型（图形验证码、短信验证码、邮件验证码），所以加多了一个 type_n 来标识以后存储的验证码是什么类型的，不便当前呈现问题疾速定位。

实际上，这里的命名规定，能够依据你的具体需要来定制，又比如说，登录的时候须要验证码、注册的时候也须要验证码、批改用户明码的时候也须要验证码，为了便于呈现问题进行定位，也能够持续加多一个标识 when_n，n 为 1 示意注册、n 为 2 示意登录，以此类推。

校验

咱们模仿登录的时候进行验证码的校验，应用一个 LoginDTO 对象来接管前端的登录相干的参数。

package cn.god23bin.demo.model.domain.dto;

import lombok.Data;

@Data
public class LoginDTO {
    private String username;
    private String password;
    /**
     * 验证码
     */
    private String code;
}

写一个登录接口，登录的过程中，校验用户输出的验证码。

@RequestMapping("/user")
@RestController
public class UserController {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @PostMapping("/login")
    public Result<String> login(@RequestBody LoginDTO loginDTO, HttpServletRequest request) {if (!"root".equals(loginDTO.getUsername()) || !"123456".equals(loginDTO.getPassword())) {return Result.fail("登录失败！账号或明码不正确！");
        }
        // 校验用户输出的验证码
        String code = loginDTO.getCode();
        String codeInRedis = (String) redisTemplate.opsForValue().get("code_" + request.getSession().getId() + "_type_1");
        if (!code.equals(codeInRedis)) {return Result.fail("验证码不正确！");
        }
        return Result.ok("登录胜利！");
    }
}

至此，便实现了验证码性能的实现。

获取验证码的平安设计

验证码性能的实现当初是 OK 的，但还有一点须要留神，那就是避免验证码被随便调用获取，或者被大量调用。如果不做限度，那么谁都能调用，就十分大的可能会被攻打了。

咱们下面实现的验证码性能是 图形验证码 ，是校验用户从图形验证码中看到后输出的数字字母组合跟后端生成的组合是否是统一的。对于图形验证码，到这里就能够了，不必限度（当然想限度也能够）。 然而对于短信验证码，就还不能够。咱们须要额定思考一些防刷机制，以保障系统的安全性和可靠性（因为发短信是要钱的啊！）。

对于短信来说，一种常见的攻击方式是「短信轰炸」，攻击者通过主动批量提交手机号码、模仿 IP 等伎俩，对系统进行大规模的短信申请，从而耗费资源或烦扰失常业务。为了应答这种状况，咱们须要设计一些防刷机制。

防刷机制

目前我理解到的防刷机制有上面几种，如果你有别的办法，欢送评论说进去噢！

1. 图形验证码或者滑动验证：发送短信前先应用图形验证码或者滑动进行验证，验证胜利能力调用发送短信验证码的接口。
2. 工夫限度：从用户点击发送短信验证码开始，前端进行一个 60 秒的倒数，在这 60 秒之内，用户无奈提交发送信息的申请的，这样就限度了发送短信验证码的接口的调用次数。不过这种形式，如果被攻击者晓得了发送短信的接口，那也是会被刷的。
3. 手机号限度：对应用同一个手机号码进行注册或者其余发送短信验证码的操作的时候，零碎能够对这个手机号码进行限度，例如，一天只能发送 5 条短信验证码，超出限度则做出提醒（如：零碎忙碌，请稍后再试）。然而，这也只可能防止人工手动刷短信而已，对于批量应用不同手机号码来刷短信的机器，同样是会被刷。
4. IP 地址限度：记录申请的 IP 地址，并对同一 IP 地址的申请进行限度，比方限度某个 IP 地址在肯定工夫内只能发送特定数量的验证码。同样，也是能够被轰炸的。

至于这些机制的实现，有机会再写写，你感兴趣的话能够本人去操作试试！

总结

本篇文章就说了验证码性能的实现思路和实现，包含验证码的生成、存储、展现和校验。

• 生成验证码能够手写也能够借助工具。
• 存储个别是存储在 Redis 中的，当然你想存储在 MySQL 中也不是不能够，就是须要本人去实现诸如过期工夫的性能。
• 展现能够通过文本展现或者图片展现，咱们能够返回一个二进制流给前端，前端通过 img 标签的 src 属性去申请咱们的接口。
• 校验就拿到用户输出的验证码，和后端生成的验证码进行比对，雷同就验证胜利，否则失败。

最初咱们也说了验证码的防刷机制，这是须要思考的，这里的防刷机制对于应用大量不同手机号、不同 IP 地址是没成果的，仍旧能够暴刷。所以这部分内容还是有待钻研的。也欢送大家在评论区说出你的认识！

最初的最初

心愿各位屏幕前的 靓仔靓女们 给个三连！你轻轻地点了个赞，那将在我的心里世界削减一颗亮堂而夺目的星！

咱们下期再见！