基于阿里云平台的短信验证码服务API的使用

基于阿里云平台的短信验证码服务API的使用

第一步：登录阿里云平台

第二步：申请国内文本短信签名

如果是个人作业项目（如作者的签名），可以直接申请测试和学习用的测试签名，该签名的缺点是必须绑定测试手机号，才能向该手机号发送验证码，且测试手机号最多五个。

第三步：申请短信模板

第四步：进入AccessKey管理

第五步：点击开始使用子用户

第六步：创建用户组并创建用户

这一步会得到AccessKey（id，密码）下面会用到

第七步：编写代码

1. 创建一个springboot工程
2. 添加maven依赖

<dependency>
 <groupId>com.aliyun</groupId>
 <artifactId>aliyun-java-sdk-core</artifactId>
 <version>4.5.0</version>
</dependency>

3. 编写controller代码

   @Controller
   //跨域使用
   @CrossOrigin
   @Api(tags = "短信验证码接口")
   public class SmsController {
   
       @Autowired
       StringRedisTemplate stringRedisTemplate;
   
       /**
        * 发送手机验证码
        * @param phoneNumber 手机号码
        * @return 1表示成功，0表示失败
        */
       @ApiOperation("发送验证码")
       @RequestMapping("/sendSms/{phoneNumber}")
       @ResponseBody
       public String SmsTest(@PathVariable String phoneNumber){
           //发送短信
           String result = SendSMSUtil.sendSmsUtil(phoneNumber);
   
   
           if (result == null || !result.equals("OK")) {// 发送不成功
               return "0";
           }
   
           // 获取验证码
           int code = SendSMSUtil.getCode();
           Map<String,Object> map=new HashMap<>();
           // 将数据存入redis
           map.put(phoneNumber,code+"");
           //用phoneNumber来做键，可以做到唯一性
           stringRedisTemplate.opsForHash().putAll(phoneNumber,map);
           // 设置redis过期时间,这个时间是秒为单位的，我现在设置5分钟之内有效，过了就会自动删除
           stringRedisTemplate.expire(phoneNumber, 60*5, TimeUnit.SECONDS);
   
           return "OK";
   
       }
       /**
        * 校验验证码
        * @param phoneNumber
        * @param checkSMSCode
        * @return
        */
       @ApiOperation("校验验证码")
       @RequestMapping(value = "/checkSMSCode", method = RequestMethod.POST)
       @ResponseBody
       public String checkSMSCode(String phoneNumber,String checkSMSCode) {
   
           // 服务器放入的验证码
           Map<Object, Object> map=stringRedisTemplate.opsForHash().entries(phoneNumber);
           String serverCheckCode =(String) map.get(phoneNumber);
   
   
           if (serverCheckCode == null || serverCheckCode.equals("")) {
               return "CodeError";
           }
           // 验证码不匹配
           if (!checkSMSCode.equals(serverCheckCode)) {
               return "CodeError";
           }else {
               //如果验证成功就删除验证码
               stringRedisTemplate.opsForHash().delete(phoneNumber,phoneNumber);
           }
   
   
           return "OK";
   
       }
   
   }

config：

@Configurable
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

//    /**
//     * springboot1.x用这个来管理缓存
//     * 选择redis作为默认缓存工具
//     * @param redisTemplate
//     * @return
//     */
//    @Bean
//    public CacheManager cacheManager(RedisTemplate redisTemplate) {
//        RedisCacheManager rcm = new RedisCacheManager(redisTemplate);
//        return rcm;
//    }



    /**
     * Logger
     */
    private static final Logger lg = LoggerFactory.getLogger(RedisConfiguration.class);


    @Autowired
    private JedisConnectionFactory jedisConnectionFactory;

    @Bean
    @Override
    public KeyGenerator keyGenerator() {
        //  设置自动key的生成规则，配置spring boot的注解，进行方法级别的缓存
        // 使用：进行分割，可以很多显示出层级关系
        // 这里其实就是new了一个KeyGenerator对象，只是这是lambda表达式的写法，我感觉很好用，大家感兴趣可以去了解下
        return (target, method, params) -> {
            StringBuilder sb = new StringBuilder();
            sb.append(target.getClass().getName());
            sb.append(":");
            sb.append(method.getName());
            for (Object obj : params) {
                sb.append(":" + String.valueOf(obj));
            }
            String rsToUse = String.valueOf(sb);
            lg.info("自动生成Redis Key -> [{}]", rsToUse);
            return rsToUse;
        };
    }

    @Bean
    @Override
    public CacheManager cacheManager() {
        // 初始化缓存管理器，在这里我们可以缓存的整体过期时间什么的，我这里默认没有配置
        lg.info("初始化 -> [{}]", "CacheManager RedisCacheManager Start");
        RedisCacheManager.RedisCacheManagerBuilder builder = RedisCacheManager
                .RedisCacheManagerBuilder
                .fromConnectionFactory(jedisConnectionFactory);
        return builder.build();
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate(JedisConnectionFactory jedisConnectionFactory) {
        //设置序列化
        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);
        // 配置redisTemplate
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
        redisTemplate.setConnectionFactory(jedisConnectionFactory);
        RedisSerializer stringSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringSerializer); // key序列化
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer); // value序列化
        redisTemplate.setHashKeySerializer(stringSerializer); // Hash key序列化
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer); // Hash value序列化
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    @Override
    @Bean
    public CacheErrorHandler errorHandler() {
        // 异常处理，当Redis发生异常时，打印日志，但是程序正常走
        lg.info("初始化 -> [{}]", "Redis CacheErrorHandler");
        CacheErrorHandler cacheErrorHandler = new CacheErrorHandler() {
            @Override
            public void handleCacheGetError(RuntimeException e, Cache cache, Object key) {
                lg.error("Redis occur handleCacheGetError：key -> [{}]", key, e);
            }

            @Override
            public void handleCachePutError(RuntimeException e, Cache cache, Object key, Object value) {
                lg.error("Redis occur handleCachePutError：key -> [{}]；value -> [{}]", key, value, e);
            }

            @Override
            public void handleCacheEvictError(RuntimeException e, Cache cache, Object key)    {
                lg.error("Redis occur handleCacheEvictError：key -> [{}]", key, e);
            }

            @Override
            public void handleCacheClearError(RuntimeException e, Cache cache) {
                lg.error("Redis occur handleCacheClearError：", e);
            }
        };
        return cacheErrorHandler;
    }

    /**
     * 此内部类就是把yml的配置数据，进行读取，创建JedisConnectionFactory和JedisPool，以供外部类初始化缓存管理器使用
     * 不了解的同学可以去看@ConfigurationProperties和@Value的作用
     *
     */
    @ConfigurationProperties
    class DataJedisProperties{
        @Value("${spring.redis.host}")
        private  String host;
        @Value("${spring.redis.password}")
        private  String password;
        @Value("${spring.redis.port}")
        private  int port;
        @Value("${spring.redis.timeout}")
        private  int timeout;
        @Value("${spring.redis.jedis.pool.max-idle}")
        private int maxIdle;
        @Value("${spring.redis.jedis.pool.max-wait}")
        private long maxWaitMillis;

        @Bean
        JedisConnectionFactory jedisConnectionFactory() {
            lg.info("Create JedisConnectionFactory successful");
            JedisConnectionFactory factory = new JedisConnectionFactory();
            factory.setHostName(host);
            factory.setPort(port);
            factory.setTimeout(timeout);
            factory.setPassword(password);
            return factory;
        }
        @Bean
        public JedisPool redisPoolFactory() {
            lg.info("JedisPool init successful，host -> [{}]；port -> [{}]", host, port);
            JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
            jedisPoolConfig.setMaxIdle(maxIdle);
            jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);

            JedisPool jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout, password);
            return jedisPool;
        }
    }
}

util工具类：

import com.aliyuncs.DefaultAcsClient;
import com.aliyuncs.IAcsClient;
import com.aliyuncs.dysmsapi.model.v20170525.SendSmsRequest;
import com.aliyuncs.dysmsapi.model.v20170525.SendSmsResponse;
import com.aliyuncs.exceptions.ClientException;
import com.aliyuncs.http.MethodType;
import com.aliyuncs.profile.DefaultProfile;
import com.aliyuncs.profile.IClientProfile;

/**
 * 发送短信工具类
 */
public class SendSMSUtil {
    /**
     * 你的accessKeyId
     */
    private static final String accessKeyId="";
    /**
     * 你的accessKeySecret
     */
    private static final String accessKeySecret="";
    /**
     * 签名
     */
    private static final String signName="";//签名名称
    /**
     * 短信模板
     */
    private static final String templateCode="";//短信模板id
    /**
     * 验证码
     */
    private static int code;

    /**
     * @Descirption:发送手机验证码
     * @param phoneNumber：需要发送的手机号码
     * @return OK表示成功，失败则返回失败消息
     */
    public static String sendSmsUtil(String phoneNumber){
        //设置超时时间-可自行调整
        System.setProperty("sun.net.client.defaultConnectTimeout", "10000");
        System.setProperty("sun.net.client.defaultReadTimeout", "10000");

        // 初始化ascClient需要的几个参数

        // 短信API产品名称（短信产品名固定，无需修改）
        final String product = "Dysmsapi";
        // 短信API产品域名（接口地址固定，无需修改）
        final String domain = "dysmsapi.aliyuncs.com";

        // 初始化ascClient,暂时不支持多region（请勿修改）
        IClientProfile profile= DefaultProfile.getProfile("cn-hangzhou", accessKeyId, accessKeySecret);
        try {
            DefaultProfile.addEndpoint("cn-hangzhou", "cn-hangzhou", product, domain);
        } catch (ClientException e) {
            e.printStackTrace();
        }
        IAcsClient acsClient=new DefaultAcsClient(profile);

        // 组装请求对象
        SendSmsRequest request=new SendSmsRequest();
        //使用post提交
        request.setMethod(MethodType.POST);

        // 必填:待发送手机号。支持以逗号分隔的形式进行批量调用，批量上限为1000个手机号码,批量调用相对于单条调用及时性稍有延迟,
        // 验证码类型的短信推荐使用单条调用的方式；发送国际/港澳台消息时，接收号码格式为国际区号+号码，如“85200000000”
        request.setPhoneNumbers(phoneNumber);
        request.setSignName(signName);
        // 必填:短信模板-可在短信控制台中找到，发送国际/港澳台消息时，请使用国际/港澳台短信模版
        request.setTemplateCode(templateCode);

        //随机生成6位验证码
        code = (int) ((Math.random() * 9 + 1) * 100000);

        // 可选:模板中的变量替换JSON串,如模板内容为"亲爱的${name},您的验证码为${code}"时,此处的值为
        // 友情提示:如果JSON中需要带换行符,请参照标准的JSON协议对换行符的要求,比如短信内容中包含\r\n的情况在JSON中需要表示成\\r\\n,否则会导致JSON在服务端解析失败
        request.setTemplateParam("{code:"+code+"}");

        // 请求失败这里会抛ClientException异常
        SendSmsResponse sendSmsResponse = null;

        try {
            sendSmsResponse = acsClient.getAcsResponse(request);
        } catch (ClientException e) {
            e.printStackTrace();
            return "请求失败";
        }

        assert sendSmsResponse.getCode() != null;
        // 发送不成功
        if (sendSmsResponse.getCode() == null || !sendSmsResponse.getCode().equals("OK")) {
            return sendSmsResponse.getMessage();
        }

        // 请求成功
        return "OK";
    }

    public static int getCode(){
        return code;
    }
}

启动类：

@SpringBootApplication
@ComponentScan(basePackages = "xxxxxxxx")
public class ServiceVcodeApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceVcodeApplication.class, args);
    }
}

最后添加测试手机号：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zFPMo9Zx-1685977020060)(file:///C:/Users/hgy04/AppData/Local/Temp/msohtmlclip1/01/clip_image012.jpg)]

}

public static int getCode(){
    return code;
}

}

启动类：

```java
@SpringBootApplication
@ComponentScan(basePackages = "xxxxxxxx")
public class ServiceVcodeApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceVcodeApplication.class, args);
    }
}

最后添加测试手机号：

运行启动类进行测试，即可成功！