腾讯云 短信整合Spring Boot项目 完整demo

腾讯云 短信整合Spring Boot项目 完整demo（包含redis）

写项目前请阅读官方文档及申请账号，签名，模板等。

代码如下 复制就能使用：
pom.xml

<!-- 腾讯云短信平台-->
<dependency>
     <groupId>com.github.qcloudsms</groupId>
     <artifactId>qcloudsms</artifactId>
     <version>1.0.6</version>
</dependency>

工具类

public class SmsUtil {

	private static final String URL_SMS = "https://yun.tim.qq.com/v5/tlssmssvr/sendsms?sdkappid=%s&random=%s";
	private static final int APP_ID = 应用APP ID;
	private static final String APP_KEY = "应用APP KEY";
	private static final String SING = "签名的名称 不是ID";
	private static final String TEMPLATE_CODE = "模板的ID";

	public static R sendSingleSms(String mobile, RedisHelper<String, String> redisHelper) {

		String smsCode = "";//发送的验证码
		Random random = new Random();
		int x = random.nextInt(899999) + 100000;
		smsCode = x + "";
		String[] params = new String[2];
		params[1] = "1";
		params[0] = smsCode;
		SmsSingleSenderResult result = null;
		if (redisHelper.valueGet(mobile) != null) {
			return R.error("校验码获取失败,发送间隔为60s");
		} else {
			try {
				SmsSingleSender ssender = new SmsSingleSender(APP_ID, APP_KEY);
				result = ssender.sendWithParam("86", mobile, Math.toIntExact(Long.valueOf(TEMPLATE_CODE)), params, SING, "", "");
			} catch (HTTPException e) {
				// HTTP响应码错误
				e.printStackTrace();
			} catch (JSONException e) {
				// json解析错误
				e.printStackTrace();
			} catch (IOException e) {
				// 网络IO错误
				e.printStackTrace();
			}
			if (result.result == 0) {
				//缓存验证码
				redisHelper.valueSet(mobile, smsCode, 60, TimeUnit.SECONDS);
				return R.ok("校验码已发送，请注意查收");
			} else {
				return R.error("校验码发送失败，请重新发送");
			}
		}
	}

redis代码（接口）

/**
 * K 指以hash结构操作时 键类型
 * T 为数据实体 应实现序列化接口,并定义serialVersionUID * RedisTemplate 提供了五种数据结构操作类型 hash / list / set / zset / value
 * 方法命名格式为 数据操作类型 + 操作 如 hashPut 指以hash结构(也就是map)想key添加键值对 
 */
public interface RedisHelper<HK, T> {
	/**
     * 字符串方式缓存
     * @param key
     * @param value
     * @param timeout
     * @param unit
     */
    public T valueGet(String key);
	/**
     * 字符串方式缓存
     * @param key
     * @param value
     * @param timeout
     * @param unit
     */
    public void valueSet(String key, T value, int timeout, TimeUnit unit) ;
    /**
     * Hash结构 添加元素 * @param key key * @param hashKey hashKey * @param domain 元素
     */
    void hashPut(String key, HK hashKey, T domain);

    /**
     * Hash结构 获取指定key所有键值对 * @param key * @return
     */
    Map<HK, T> hashFindAll(String key);

    /**
     * Hash结构 获取单个元素 * @param key * @param hashKey * @return
     */
    T hashGet(String key, HK hashKey);

    void hashRemove(String key, HK hashKey);

    /**
     * List结构 向尾部(Right)添加元素 * @param key * @param domain * @return
     */
    Long listPush(String key, T domain);

    /**
     * List结构 向头部(Left)添加元素 * @param key * @param domain * @return
     */
    Long listUnshift(String key, T domain);

    /**
     * List结构 获取所有元素 * @param key * @return
     */
    List<T> listFindAll(String key);

    /**
     * List结构 移除并获取数组第一个元素 * @param key * @return
     */
    T listLPop(String key);

    /**
     * 对象的实体类
     * @param key
     * @param domain
     * @return
     */
    void valuePut(String key, T domain);

    /**
     * 获取对象实体类
     * @param key
     * @return
     */
    T getValue(String key);

    void remove(String key);

    /**
     * 设置过期时间 * @param key 键 * @param timeout 时间 * @param timeUnit 时间单位
     */
    boolean expirse(String key, long timeout, TimeUnit timeUnit);
}

redis代码（接口实现）

@Service("RedisHelper")
public class RedisHelperImpl<HK, T> implements RedisHelper<HK, T> {
    // 在构造器中获取redisTemplate实例, key(not hashKey) 默认使用String类型
    private RedisTemplate<String, T> redisTemplate;
    // 在构造器中通过redisTemplate的工厂方法实例化操作对象
    private HashOperations<String, HK, T> hashOperations;
    private ListOperations<String, T> listOperations;
    private ZSetOperations<String, T> zSetOperations;
    private SetOperations<String, T> setOperations;
    private ValueOperations<String, T> valueOperations;

    // IDEA虽然报错,但是依然可以注入成功, 实例化操作对象后就可以直接调用方法操作Redis数据库
    @Autowired
    public RedisHelperImpl(RedisTemplate<String, T> redisTemplate) {
        this.redisTemplate = redisTemplate;
        this.hashOperations = redisTemplate.opsForHash();
        this.listOperations = redisTemplate.opsForList();
        this.zSetOperations = redisTemplate.opsForZSet();
        this.setOperations = redisTemplate.opsForSet();
        this.valueOperations = redisTemplate.opsForValue();
    }

    /**
     * 字符串方式缓存
     * @param key
     * @param value
     * @param timeout
     * @param unit
     */
    public void valueSet(String key, T value, int timeout,TimeUnit unit) {
    	valueOperations.set(key,  value, timeout, unit);
    }

    /**
     * 字符串方式缓存
     * @param key
     * @param value
     * @param timeout
     * @param unit
     */
    public T valueGet(String key) {
    	return valueOperations.get(key);
    }
    @Override
    public void hashPut(String key, HK hashKey, T domain) {
        hashOperations.put(key, hashKey, domain);
    }

    @Override
    public Map<HK, T> hashFindAll(String key) {
        return hashOperations.entries(key);
    }

    @Override
    public T hashGet(String key, HK hashKey) {
        return hashOperations.get(key, hashKey);
    }

    @Override
    public void hashRemove(String key, HK hashKey) {
        hashOperations.delete(key, hashKey);
    }

    @Override
    public Long listPush(String key, T domain) {
        return listOperations.rightPush(key, domain);
    }

    @Override
    public Long listUnshift(String key, T domain) {
        return listOperations.leftPush(key, domain);
    }

    @Override
    public List<T> listFindAll(String key) {
        if (!redisTemplate.hasKey(key)) {
            return null;
        }
        return listOperations.range(key, 0, listOperations.size(key));
    }

    @Override
    public T listLPop(String key) {
        return listOperations.leftPop(key);
    }

    @Override
    public void valuePut(String key, T domain) {
        valueOperations.set(key, domain);
    }

    @Override
    public T getValue(String key) {
        return valueOperations.get(key);
    }

    @Override
    public void remove(String key) {
        redisTemplate.delete(key);
    }

    @Override
    public boolean expirse(String key, long timeout, TimeUnit timeUnit) {
        return redisTemplate.expire(key, timeout, timeUnit);
    }
	
}

redis代码（配置类）

@Configuration
@EnableCaching
public class RedisConfiguration extends CachingConfigurerSupport {
    /**
     * 自定义生成key的规则
     */
    @Override
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object o, Method method, Object... objects) {
                //格式化缓存key字符串
                StringBuilder sb = new StringBuilder();
                //追加类名
                sb.append(o.getClass().getName());
                //追加方法名
                sb.append(method.getName());
                //遍历参数并且追加
                for (Object obj : objects) {
                    sb.append(obj.toString());
                }
                System.out.println("调用Redis缓存Key : " + sb.toString());
                return sb.toString();
            }
        };
    }
    
    /**
     * 采用RedisCacheManager作为缓存管理器
     * @param connectionFactory
     */
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        RedisCacheManager redisCacheManager = RedisCacheManager.create(connectionFactory);
        return  redisCacheManager;
    }

    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
        解决键、值序列化问题
        StringRedisTemplate template = new StringRedisTemplate(factory);
        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);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

redis连接配置(application.yml)

spring
	redis:
	      host: 
	      # Redis服务器连接端口
	      port: 6379
	      jedis:
	        pool:
	          #连接池最大连接数（使用负值表示没有限制）
	          max-active: 100
	          # 连接池中的最小空闲连接
	          max-idle: 10
	          # 连接池最大阻塞等待时间（使用负值表示没有限制）
	          max-wait: 100000
	      # 连接超时时间（毫秒）
	      timeout: 5000
	      #默认是索引为0的数据库
	      database: 0
	      password: 

获取短信验证码接口代码

	@PostMapping(value = "getCaptchas.do" , produces = "application/json;charset=UTF-8")
	public  R getCaptchas(@RequestBody Map<String, Object> params, HttpServletRequest request) {
		Map<String,Object> resultList = new HashMap<String, Object>();

		if(!StringUtils.isNotEmpty(params.get("phone").toString())){
			return R.error("请输入手机号码");
		}
		//判断用户信息是否存在
		resultList.put("phone", params.get("phone").toString());
		List<UserDO> memberList = service.list(UserDO.class, resultList);
		if(!(memberList != null && memberList.size() > 0)){
			return R.error("用户信息不存在");
		}

		return SmsUtil.sendSingleSms(params.get("phone").toString(),redisHelper);
	}

希望帮助到大家！谢谢阅读！