手机验证发送及其验证(基于springboot+redis)保姆级

在Java开发中，发送手机验证码时需要考虑以下几个问题：

验证码的有效期：验证码应该有一定的有效期，一般设置为几分钟或者十几分钟。过期的验证码应该被认为是无效的，不能用于验证用户身份。
手机号码格式的校验：应该对用户输入的手机号码进行格式校验，确保其符合手机号码的格式要求。例如，手机号码应该是11位数字，以1开头，不含其他字符。
验证码的重复使用：应该限制验证码的重复使用，即同一个验证码不能被多次使用。否则可能导致用户的账号被恶意攻击者盗用。
手机号码的安全性：应该注意保护用户的手机号码安全，不要将用户的手机号码保存在明文格式，避免泄露用户的个人信息。
验证码的加密传输：在发送验证码过程中，应该使用加密传输方式，避免验证码被拦截或者窃取。
发送短信的限制：应该限制发送短信的频率和数量，避免过度发送短信给用户，影响用户体验。
发送短信的成本：需要考虑发送短信的成本，避免浪费资源。可以通过采用短信通道和短信模板的方式降低短信发送的成本。

腾讯云的短信服务（满足需求5和7）

1.进入腾讯云，然后登录
2.腾讯云好像改布局了，不能直接在云产品那边搜索，需要进入自己的控制台，然后搜索短信
在这里插入图片描述

3.完成创建短信签名、创建短信正文模板和创建应用，每一项右边都会出现详细说明
在这里插入图片描述 可以使用标准模板

4.需要记住以下几组数据

签名管理的签名内容
正文模板中的id
左侧应用管理->应用列表的 SDKAppId
最重要的一步，CAM 密钥查询：链接

pom文件添加

 <!--腾讯手机验证码-->
        <dependency>
            <groupId>com.tencentcloudapi</groupId>
            <artifactId>tencentcloud-sdk-java</artifactId>
            <!-- go to https://search.maven.org/search?q=tencentcloud-sdk-java and get the latest version. -->
            <!-- 请到https://search.maven.org/search?q=tencentcloud-sdk-java查询所有版本，最新版本如下 -->
            <version>3.1.703</version>
        </dependency>
        <!--redis依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!--mp-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.3</version>
        </dependency>
        <!--druid-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.23</version>
        </dependency>

配置redis的序列化规则(可读性)

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.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
 *
 * @author: zpy
 * @Description: rdeis序列化规则
 * @date 2023/2/28
 */
@Configuration
public class RedisConfiguration {
    @Bean
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
        RedisTemplate<String,Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        //创建一个json序列化对象
        GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        //设置value的序列化方式json
        redisTemplate.setValueSerializer(genericJackson2JsonRedisSerializer);
        //设置key序列化为String
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        //设置hash key序列化方式为String
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        //设置hash key序列化方式为json
        redisTemplate.setHashValueSerializer(genericJackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

application.yml配置

spring:
	#redis
  redis:
    database: 0
    host: #你的ip
    port: 6379
    password: #你的密码
    timeout: 3000
#开启mp的日志，输出到控制台
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    #逻辑删除字面值
  global-config:
    db-config:
      logic-delete-field: isDeleted
      logic-not-delete-value: 0
      logic-delete-value: 1

#短信验证参数
tencent:
  msm:
    id: AKIDfAUcAUcYMyOchw0ueBYlmvtgJm24uX0J
    #同上, 这个是secretkey
    secret: 密码
    #短信控制台页面->左侧应用管理->应用列表的 SDKAppId
    appId: 1400798952
    #短信控制台页面->左侧国内短信->签名管理 签名内容
    signName: 个人学习网页成果
    #短信控制台页面->左侧国内短信->正文模板管理 Id
    templateId: 1715747

配置个统一返回的类R（这个随便写的，不标准，测试方便用，可以用自己的）

import lombok.Data;
import java.util.HashMap;
import java.util.Map;

/**
 * 通用返回结果，服务端响应的数据最终都会封装成此对象
 * @param <T>
 */
@Data
public class R<T> {

    private Integer code; //编码：1成功，0和其它数字为失败

    private String msg; //提示信息

    private T data; //数据

    private Map map = new HashMap(); //动态数据

    private boolean flag;//标记符

    public R() {
    }

    public R(Integer code, String msg, T data, Map map, boolean flag) {
        this.code = code;
        this.msg = msg;
        this.data = data;
        this.map = map;
        this.flag = flag;
    }

    public static <T> R<T> success(T object) {
        R<T> r = new R<T>();
        r.data = object;
        r.code = 200;
        return r;
    }
    public static <T> R<T> success(String msg) {
        R<T> r = new R<T>();
        r.code = 200;
        r.msg = msg;
        r.flag = true;
        return r;
    }

    public static <T> R<T> error(String msg) {
        R r = new R();
        r.msg = msg;
        r.code = 300;
        r.flag = false;
        return r;
    }

    public R<T> add(String key, Object value) {
        this.map.put(key, value);
        return this;
    }


}

实体类

因为我需要把注册信息存到数据库，如果你只是来学习发送验证码可以忽略

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.io.Serializable;


/**
 * @author: zpy
 * @date: 2023/2/28 17:58
 */
@Data
@TableName("student")
public class StudentEntity implements Serializable {
    /**
     * 序列化ID
     */
    private static final long serialVersionUID = 1L;
    /**
     * 学生id,自增
     */
    @TableId(type = IdType.AUTO)
    private Long id;
    /**
     * 学校名称
     */
    private String school;
    /**
     * 专业班级
     */
    private String subject;
    /**
     * 学生姓名
     */
    private String name;
    /**
     * 电话号
     */
    private String phone;
    /**
     * 密码
     */
    private String password;
    /**
     * 逻辑删除，0是默认，1是删除
     */
    private Integer isDeleted;
    /**
     * 创建时间
     */
    private String gmtCreate;
    /**
     * 修改时间
     */
    private String gmtModified;
    @TableField(exist=false)
    /**
     * 验证码
     */
    private String code;

}

随机数工具类（网上随便找的）

import java.util.List;
import java.util.Random;

public class RandomUtil {

    private static final Random random = new Random();

    private static final DecimalFormat fourdf = new DecimalFormat("0000");

    private static final DecimalFormat sixdf = new DecimalFormat("000000");

    public static String getFourBitRandom() {
        return fourdf.format(random.nextInt(10000));
    }

    public static String getSixBitRandom() {
        return sixdf.format(random.nextInt(1000000));
    }
    /**
     * 给定数组，抽取n个数据
     * @param list
     * @param n
     */
    public static ArrayList getRandom(List list, int n) {

        Random random = new Random();
        HashMap<Object, Object> hashMap = new HashMap<Object, Object>();
        // 生成随机数字并存入HashMap
        for (int i = 0; i < list.size(); i++) {
            int number = random.nextInt(100) + 1;
            hashMap.put(number, i);
        }
        // 从HashMap导入数组
        Object[] robjs = hashMap.values().toArray();

        ArrayList r = new ArrayList();

        // 遍历数组并打印数据
        for (int i = 0; i < n; i++) {
            r.add(list.get((int) robjs[i]));
            System.out.print(list.get((int) robjs[i]) + "\t");
        }
        System.out.print("\n");
        return r;
    }
}

controller

这边有一个前端按钮，按一次就能发送验证码，和注册信息录入，前端页面自我想象即可

/**
 * @author: 赵鹏宇
 * @date: 2023/3/6 19:05
 * 注册
 */
@RestController
@RequestMapping("logon")
public class LogonController {
    @Autowired
    private RedisTemplate<String,String> redisTemplate;

    @Autowired
    private LogonService logonService;

    @Resource
    private StudentDao studentDao;


    /**
     * 发送验证码按钮
     */
    @PostMapping("{phoneNum}")
    public R<String> sendVerificationCode(@PathVariable String phoneNum){
        //从redis获取，取不到再腾讯云发送
        String code = redisTemplate.opsForValue().get(phoneNum);
        if (!Strings.isEmpty(code)){
            return R.success("已发送，请在手机查看验证码");
        }
        //生成随机数
        code = RandomUtil.getSixBitRandom();
        System.out.println("手机号："+phoneNum+"----验证码"+code);
        R<String> send = logonService.send(phoneNum, code);
        if (send.isFlag()){
            //发送成功就把验证码放在redis中,并设置时间5分钟
            redisTemplate.opsForValue().set(phoneNum,code,5, TimeUnit.MINUTES);
            return send;
        }
        return send;
    }

    /**
     * 注册按钮
     * 1.判断输入是否是空
     * 2.判断手机号是否重复
     * 3.验证码审核
     * 4.完成注册
     */
    @PostMapping()
    public R register(@RequestBody StudentEntity studentEntity){
        R<String> register = logonService.register(studentEntity);
        return register;
    }

}

mapper

import com.ace.qiyexuni.domain.StudentEntity;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;

/**
 *
 * @author: 赵鹏宇
 * @Description: 学生接口
 * @date 2023/2/28
 */
@Mapper
public interface StudentDao extends BaseMapper<StudentEntity> {
}

service层

public interface LogonService {
    /**
     * 发送验证码
     * @param phone
     * @param code
     * @return
     */
    R<String> send(String phone, String code);

    /**
     * 注册按钮
     * @param studentEntity
     */
    R<String> register(StudentEntity studentEntity);
}

serviceImpl层（满足需求1，3，6）

正常书写的话，短信验证码存储的key应该是“YZM156****4804”这种，value对应的随机验证码，由于我这个只是demo，写的并不规则，且这个并没有判断手机号每天可以发送几次
由于腾讯云默认同一个手机号30秒内不超过一条，1小时不超过5条，1天不超过10条
这边可以给个思路：
redis存入一个key为”DAY156****4804“，value默认为0，做一个计数器，手机号每发送成功一次就加1次，当达到你所规定的上限就不能发送了

/**
 *
 * @author: 赵鹏宇
 * @Description: 短信发送逻辑
 * @date 2023/2/28
 */
@Service
@Slf4j
public class LogonServiceImpl implements LogonService {
    @Resource
    private StudentDao studentDao;
    @Autowired
    private RedisTemplate<String,String> redisTemplate;
    @Override
    /**
     * 发送验证码
     */
    public R send(String phone, String code) {
        //判断手机是否为null
        if (Strings.isEmpty(phone)){
            return R.error("手机号为空");
        }
        //判断手机号是否存在
        LambdaQueryWrapper<StudentEntity> lambdaQueryWrapper = new LambdaQueryWrapper<StudentEntity>();
        lambdaQueryWrapper.eq(phone!=null,StudentEntity::getPhone,phone);
        Integer count = studentDao.selectCount(lambdaQueryWrapper);
        if (count==1){
            return R.error("手机号已存在，是否去登录？");
        }
        try {
            /* 必要步骤：
             * 实例化一个认证对象，入参需要传入腾讯云账户密钥对 secretId 和 secretKey
             * 本示例采用从环境变量读取的方式，需要预先在环境变量中设置这两个值
             * 您也可以直接在代码中写入密钥对，但需谨防泄露，不要将代码复制、上传或者分享给他人
             * CAM 密钥查询：https://console.cloud.tencent.com/cam/capi
             */
            Credential cred = new Credential(MsmConstantUtil.SECRET_ID, MsmConstantUtil.SECRET_KEY);
            // 实例化一个http选项，可选的，没有特殊需求可以跳过
            HttpProfile httpProfile = new HttpProfile();
            httpProfile.setEndpoint("sms.tencentcloudapi.com");
            // 实例化一个client选项，可选的，没有特殊需求可以跳过
            ClientProfile clientProfile = new ClientProfile();
            clientProfile.setHttpProfile(httpProfile);
            // 实例化要请求产品的client对象,clientProfile是可选的
            SmsClient client = new SmsClient(cred, "ap-beijing", clientProfile);
            // 实例化一个请求对象,每个接口都会对应一个request对象
            SendSmsRequest req = new SendSmsRequest();
            String[] phoneNumberSet1 = {phone};
            req.setPhoneNumberSet(phoneNumberSet1);
            req.setSmsSdkAppId(MsmConstantUtil.APP_ID);
            req.setSignName(MsmConstantUtil.SIGN_NAME);
            req.setTemplateId(MsmConstantUtil.TEMPLATE_ID);
            String[] templateParamSet1 = {code, "5"};
            req.setTemplateParamSet(templateParamSet1);
            // 返回的resp是一个SendSmsResponse的实例，与请求对象对应
            SendSmsResponse resp = client.SendSms(req);
            // 输出 JSON 格式的字符串回包
            System.out.println(SendSmsResponse.toJsonString(resp));
            return R.success("发送成功,有效期5分钟");
        } catch (TencentCloudSDKException e) {
            e.printStackTrace();
        }
        return R.error("发送失败");
    }
    /**
     *  注册按钮
     *  1.判断手机号是否重复
     *  2.验证码审核
     *  3.完成注册
     */
    @Override
    public R register(StudentEntity studentEntity) {
        //当前时间
        String now = DateUtil.now();
        studentEntity.setGmtCreate(now);
        studentEntity.setGmtModified(now);
        //判断验证码是否正确，验证码的key值
        String key = studentEntity.getPhone();
        boolean isKey = keyIsExists(key);
        if (!isKey){
            return R.error("请先发送验证码");
        }
        //key对应的value值
        String code = redisTemplate.boundValueOps(key).get();
        if (code.equals(null)){
            return R.error("未发送验证码");
        }
        if(studentEntity.getCode().equals(code)){
            R.success("验证码正确");
        }else {
            return R.error("验证码错误");
        }
        //添加到数据库表中
        int insert = studentDao.insert(studentEntity);
        System.out.println(insert);
        //删除redis的验证码
        boolean delete = deleteKey(key);
        System.out.println("是否删除成功："+delete);
        return R.success("注册成功");
    }
    /**
     * 判断key是否存在
     */
    public boolean keyIsExists(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 删除key
     * @param key
     */
    public boolean deleteKey(String key) {
        return redisTemplate.delete(key);
    }

}