Java短信验证码

Java__攻城狮

已于 2024-09-09 01:07:43 修改

阅读量1.3k

点赞数 35

分类专栏：微服务文章标签： java 开发语言云计算微服务服务器

于 2024-09-09 01:04:40 首次发布

本文链接：https://blog.youkuaiyun.com/m0_75165868/article/details/142027263

版权

微服务专栏收录该内容

4 篇文章

订阅专栏

想利用java给用户发送短信的话，需要我们与电信、移动、联通三大巨头合作（其实还有广电，但是比较少用），让它帮你发信息，当然直接与它合作显然是不现实的，所以我们要借助第三方的短信平台来替我们发信息。比较有名的短信平台，比如阿里云、腾讯云.....等都可以。短信平台就相当于我们与三大运行商的中介。

1 短信模板

短信模板内容不是随便想写什么就写什么的，每个短信模板都是要由国家工信部进行审核的。

短信模板包含两部分：

短信签名：【XXXXX】
短信正文：您的注册短信验证码为：1234

下面是腾讯云给的标准：(短信模板标准)

1、短信签名

签名内容不能含有黄赌毒、宗教和党政等信息。

签名必须能辨别所属公司或个人或者业务信息，不支持中性化签名。例如：xx工作日记、xx的心情、xx语言开发、xx业务测试、xx学习教程、xx个人日记等。即使所申请签名内容与支持的签名类型的名称相同但为中性，亦不支持。

国内短信签名由【】和签名内容组成，格式为【签名内容】。签名内容要求长度为2 - 12个字，由中英文、数字组成，内容不包含【】。建议国内短信签名内容尽量使用中文。

国际/港澳台短信签名由[]和签名内容组成，格式为[签名内容]。签名内容要求2 - 15个字，内容不包含[]。

2、短信正文

还有很多细节，大家可以按需自行翻阅文档。

2 开发思路

参考文章：dogbin丶

发送短信是一个比较慢的过程，因为需要用到第三方服务（阿里云短信服务），因此我们使用RabbitMq来做异步处理，前端点击获取验证码后，后端做完校验限流后直接返回发送成功。

发送短信的服务是需要收费的，而且我们也不允许用户恶意刷接口，所以需要有一个接口限流方案。

3 具体实现

至于RabbitMq怎么用，我这边就不再讲解了，因为这部分内容也挺多的,当然不用rabbitmq这类中间件，也完全可以实现短信开发功能，但是不推荐哦，因为这可能导致用户体验不好。（大伙如果不会可以先学学，因为其实RabbitMq用处还是挺多的）。

maven依赖

         <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>com.aliyun</groupId>
            <artifactId>dysmsapi20170525</artifactId>
            <version>3.0.0</version>
        </dependency>

1、接收短信请求的接口

@RestController
@RequestMapping("/user")
public class UserController {
   
    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private RabbitTemplate rabbitTemplate;

@GetMapping("/getCode")
    public String getCode(String phone){
        String regex="^(13[0-9]|14[01456879]|15[0-35-9]|16[2567]|17[0-8]|18[0-9]|19[0-35-9])\\d{8}$";
//判断手机号是否合法
        if(Pattern.matches(regex,phone)){
            //判断该手机号一分钟内是否重复提交申请,请求记录保存在redis里面
            String key="SMS::request"+phone;
               //为空说明一分钟内没有请求
           if(redisUtil.getCacheObject(key)==null){
               //将请求记录保存在redisz中，redisUtil是一个工具类
               redisUtil.setCacheObject(key,"",60, TimeUnit.SECONDS);
               //交换机名
               String exchange="user.exchange"; 
                //发送到rabbit交换机中
               rabbitTemplate.convertAndSend(exchange,"",phone);
               return "验证码已发送";
           }else {
               return "一分钟内已申请过验证码，请稍后再申请";
           }
        }else {
            System.out.println("手机号格式不正确！");
            return "手机号格式不正确！";
        }

    }
}

最终将短信放到rabbit里面等待处理。

user.exchange是一个rabbitmq的交换机

2 rabbit接收发送短信请求

@Component
public class PhoneCodeController {
    @Autowired
    private SMSUtils smsUtils;
    @RabbitListener(queues = "phoneCode")
    public void getCode(String phone){
        try {
            //随机生成4位数字验证码
            String code = (int)((Math.random()*9+1)*1000)+"";
            //发送验证码
            smsUtils.sendMessage(phone, "阿里云短信测试", "SMS_154950909", code);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

@RabbitListener(queues = "phoneCode")监听交换机，发送给队列的信息

注意队列和交换机关系要绑定好。（不知道怎么绑定的，可以先学一下rabbitmq）

3 发送短信的工具类

@Component
public class SMSUtils {
    @Autowired
    private RedisUtil redisUtil;
    /**
     * 阿里云登录id
     */
    private final static String ACCESS_KEY_ID = "。。。。。。。。";
 
    /**
     * 阿里云登录密码
     */
    private final static String ACCESS_KEY_SECRET = "。。。。。。。。。";
 
    /**
     * 初始化登录阿里云的Client
     *
     * @param accessKeyId
     * @param accessKeySecret
     * @return Client
     */
    public static com.aliyun.dysmsapi20170525.Client createClient(String accessKeyId, String accessKeySecret) throws Exception {
        com.aliyun.teaopenapi.models.Config config = new com.aliyun.teaopenapi.models.Config()
        .setAccessKeyId(accessKeyId)
        .setAccessKeySecret(accessKeySecret);
        // 可指定登录的服务器地址，可参考 https://api.aliyun.com/product/Dysmsapi
        config.endpoint = "dysmsapi.aliyuncs.com";
        return new com.aliyun.dysmsapi20170525.Client(config);
    }
 
    /**
     * 发送短信方法
     * @param phoneNumbers 手机号
     * @param signName 签名
     * @param templateCode  模板编号
     * @param code 模板参数
     * @throws Exception
     */
    public  void sendMessage(String phoneNumbers, String signName, String templateCode, String code) throws Exception {
        System.out.println(11);
        //hashmap转化位json
        HashMap<String, String> map = new HashMap<>();
        map.put("code", code);
        String jsonCode = JSONUtil.toJsonStr(map);


        com.aliyun.dysmsapi20170525.Client client = SMSUtils.createClient(ACCESS_KEY_ID, ACCESS_KEY_SECRET);
        com.aliyun.dysmsapi20170525.models.SendSmsRequest sendSmsRequest = new com.aliyun.dysmsapi20170525.models.SendSmsRequest()
        .setPhoneNumbers(phoneNumbers)
        .setSignName(signName)
        .setTemplateCode(templateCode)
        .setTemplateParam(jsonCode);
        SendSmsResponse sendSmsResponse = client.sendSmsWithOptions(sendSmsRequest, new RuntimeOptions());

        if(sendSmsResponse.getBody().code.equals("OK")){
            System.out.println("短信发送成功");
           //短信验证码存储在redis,五分钟过期
            redisUtil.setCacheObject("phone::code"+phoneNumbers,code,5,TimeUnit.MINUTES);


        }else {
            System.out.println(sendSmsResponse.getBody().message);
            System.out.println("短信发送失败");
        }

    }
 

 
}

ACCESS_KEY_ID和ACCESS_KEY_SECRET需要更换为自己的哦，获取方式如下

点击创建

4 还有一些工具类如下

package org.example.common.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;

import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * spring redis 工具类
 *
 * @author ruoyi
 **/
@SuppressWarnings(value = {"unchecked", "rawtypes"})
@Component
public class RedisUtil {
    @Autowired
    public RedisTemplate redisTemplate;

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

    /**
     * 缓存基本的对象，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     Redis键
     * @param timeout 超时时间
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout) {
        return expire(key, timeout, TimeUnit.SECONDS);
    }

    /**
     * 设置有效时间
     *
     * @param key     Redis键
     * @param timeout 超时时间
     * @param unit    时间单位
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout, final TimeUnit unit) {
        return redisTemplate.expire(key, timeout, unit);
    }

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

    /**
     * 删除单个对象
     *
     * @param key
     */
    public boolean deleteObject(final String key) {
        return redisTemplate.delete(key);
    }

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

    /**
     * 缓存List数据
     *
     * @param key      缓存的键值
     * @param dataList 待缓存的List数据
     * @return 缓存的对象
     */
    public <T> long setCacheList(final String key, final List<T> dataList) {
        Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
        return count == null ? 0 : count;
    }

    /**
     * 获得缓存的list对象
     *
     * @param key 缓存的键值
     * @return 缓存键值对应的数据
     */
    public <T> List<T> getCacheList(final String key) {
        return redisTemplate.opsForList().range(key, 0, -1);
    }

    /**
     * 缓存Set
     *
     * @param key     缓存键值
     * @param dataSet 缓存的数据
     * @return 缓存数据的对象
     */
    public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet) {
        BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
        Iterator<T> it = dataSet.iterator();
        while (it.hasNext()) {
            setOperation.add(it.next());
        }
        return setOperation;
    }

    /**
     * 获得缓存的set
     *
     * @param key
     * @return
     */
    public <T> Set<T> getCacheSet(final String key) {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 缓存Map
     *
     * @param key
     * @param dataMap
     */
    public <T> void setCacheMap(final String key, final Map<String, T> dataMap) {
        if (dataMap != null) {
            redisTemplate.opsForHash().putAll(key, dataMap);
        }
    }

    /**
     * 获得缓存的Map
     *
     * @param key
     * @return
     */
    public <T> Map<String, T> getCacheMap(final String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 往Hash中存入数据
     *
     * @param key   Redis键
     * @param hKey  Hash键
     * @param value 值
     */
    public <T> void setCacheMapValue(final String key, final String hKey, final T value) {
        redisTemplate.opsForHash().put(key, hKey, value);
    }

    /**
     * 获取Hash中的数据
     *
     * @param key  Redis键
     * @param hKey Hash键
     * @return Hash中的对象
     */
    public <T> T getCacheMapValue(final String key, final String hKey) {
        HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
        return opsForHash.get(key, hKey);
    }

    /**
     * 删除Hash中的数据
     *
     * @param key
     * @param hKey
     */
    public void delCacheMapValue(final String key, final String hKey) {
        HashOperations hashOperations = redisTemplate.opsForHash();
        hashOperations.delete(key, hKey);
    }

    /**
     * 获取多个Hash中的数据
     *
     * @param key   Redis键
     * @param hKeys Hash键集合
     * @return Hash对象集合
     */
    public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys) {
        return redisTemplate.opsForHash().multiGet(key, hKeys);
    }

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

5 application.yml

server:
  port: 9005
spring:
  application:
    name: my-consumer
  rabbitmq:
    host: 47.122.62.29 # 你的虚拟机IP
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: lsw # 用户名
    password: 123456 # 密码