应用接入阿里云短信服务

川长思鸟来 2022-02-20 16:19 566阅读 0赞

背景

  1.    在日常开发中，我们可能会遇到短信验证之类的需求，这也是我们使用各类app或系统中比较常见的。在对比了各个平台提供的短信服务后，从价格，稳定性，接入便捷性进行考虑，最终选择了阿里云所提供的[短信服务][Link 1]，之前在做课设的时候接入过，但是当时没有作总结，此次毕设也有该需求，在完成之后做以下总结。

开通应用

开通阿里云账号，选择短信服务，开通该应用

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nX2ppYXl1YW4_size_16_color_FFFFFF_t_70

作为第三方短信服务，阿里云提供了多种语言丰富的sdk支持，能够很方便的帮助我们集成常用的接口，加快开发速度。

选择sdk参考，安装java sdk，阿里云官方推荐通过maven形式引入依赖，仓库坐标如下。（原本官方提供的是4.1.0版本，貌似有bug，在开发中执行 IAcsClient client = new DefaultAcsClient(profile); 会报NotSuchMethodException异常，排查了很久无果，切换成4.0.6版本，成功启动）

  1. <dependency>
  2.     <groupId>com.aliyun</groupId>
  3.     <artifactId>aliyun-java-sdk-core</artifactId>
  4.     <version>4.0.6</version>
  5. </dependency>

在安装和使用阿里云Java SDK前，确保已经：

  • 安装Java环境。阿里云Java SDK要求使用JDK1.6或更高版本。
  • 已经注册阿里云账号并生成访问访问密钥（AccessKey）。

创建AccessKey

阿里云官方对AccessKey的说明，概括起来，就是调用所有 API的凭证/验证信息(比如我们待会要调用的短信服务API)

20190414124300624.png

AccessKey信息可以在安全信息管理控制台看到，这里还提供了一种子账号Accesskey的方式，通过权限管理降低AccessKey泄露的风险

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nX2ppYXl1YW4_size_16_color_FFFFFF_t_70 1

添加短信签名和模板

打开短信服务控制台，选择国内消息，添加短信签名和模板，按照自己业务需求和系统指引填写，审核通过后即可使用

emmm，现在一点半，工作人员应该还没上班，显示待审核

20190414133000565.png

在application.yml中配置服务参数

配置如下：

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nX2ppYXl1YW4_size_16_color_FFFFFF_t_70 2

通过spring ioc将配置装载到spring bean 中去

  1. /**
  2.  * 阿里云短信服务配置
  3.  *
  4.  * @author jiayuan9608@163.com
  5.  * 2019-04-01 15:30
  6.  * @version 1.0.0
  7.  */
  9. @Data
  10. @Component
  11. @ConfigurationProperties(prefix = "aliyun.msg")
  12. public class AliyunMsgConfig {
  14.     /**
  15.      * 阿里云短信API  是否开启短信接口,0为开启（收费接口），1为关闭，2为开启模拟短信（免费接口）
  16.      */
  17.     private Integer openMsg;
  20.     /**
  21.      * 开发者访问id
  22.      */
  23.     private String accessKeyId;
  25.     /**
  26.      * 开发者访问密钥
  27.      */
  28.     private String accessKeysecret;
  30.     /**
  31.      * 短信签名
  32.      */
  33.     private String signName;
  35.     /**
  36.      * 短信模板
  37.      */
  38.     private String templateCode;
  40.     /**
  41.      * 随机验证码的范围-最小值
  42.      */
  43.     private Integer min;
  45.     /**
  46.      * 随机验证码的范围-最大值
  47.      */
  48.     private Integer max;
  50.     /**
  51.      * 产品域名,开发者无需替换
  52.      */
  53.     private String domain;
  55.     /**
  56.      * 版本日期
  57.      */
  58.     private String version;
  60.     /**
  61.      * 行为
  62.      */
  63.     private String action;
  64. }

编写短信发送服务

阿里云官方提供了短信发送服务的demo，根据自己实际情况进行改写。

将配置类注入进来，这里使用了自定义springUtil的形式完成注入，采用@Autowired的形式发现始终无法完成初始化，在idea中也看到了AliyunMsgConfig成功装载到spring容器中了，尝试指定bean进行加载也无法解决，emmm有点奇怪，具体原因有待考察。所以最后采用 springUtil 帮助完成了配置的初始化工作。

  1. private AliyunMsgConfig aliyunMsgConfig = SpringUtil.getBean(AliyunMsgConfig.class);

附springUtil代码：

  1. /**
  2.  * 自定义Spring相关工具类
  3.  *
  4.  * @author jiayuan9608@163.com
  5.  * 2019-02-20 10:55
  6.  * @version 1.0.0
  7.  */
  8. @Component
  9. @Slf4j
  10. public class SpringUtil implements ApplicationContextAware {
  12.     private static ApplicationContext applicationContext;
  14.     @Override
  15.     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  16.         if (SpringUtil.applicationContext == null) {
  17.             SpringUtil.applicationContext = applicationContext;
  18.         }
  19.         log.info("SpringUtil loaded into spring bean successed : {}", SpringUtil.applicationContext);
  20.     }
  21.     //======获取spring bean=======
  23.     //获取applicationContext
  24.     public static ApplicationContext getApplicationContext() {
  25.         return applicationContext;
  26.     }
  28.     //通过name获取Bean
  29.     public static Object getBean(String name) {
  30.         return getApplicationContext().getBean(name);
  31.     }
  33.     //通过class获取Bean
  34.     public static <T> T getBean(Class<T> clazz) {
  35.         return getApplicationContext().getBean(clazz);
  36.     }
  38.     //通过name，以及Clazz返回指定的Bean
  39.     public static <T> T getBean(String name, Class<T> clazz) {
  40.         return getApplicationContext().getBean(name, clazz);
  41.     }
  42. }

业务需要，定义一个存放随机验证码map集合,防止多个手机号同时注册导致验证码混乱（覆盖）。注意，像这类公共变量存放，常规操作应该是放在缓存中（比如redis, mongdb等），若通过静态变量存储，当类被卸载的时候，静态变量的生命周期随之结束，我们存储的信息也会随之丢失。

  1. /**
  2.      * 随机验证码map集合,防止多个手机号同时注册导致验证码混乱
  3.      */
  4.     private static Map<String, String> myAuthCodeMap = Maps.newHashMap();

发送短信，这里设置了三种状态，是否开启短信接口（实际发送短信接口需要花钱，所以在配置上面做了个开关=_=，土豪请随意～）：0为开启（收费接口），1为关闭，2为开启模拟短信（免费接口），均为业务需要进行的自定义，与官方API无关

  1. public int sendMsg(String phoneNumbers) {
  2.         if (1 == aliyunMsgConfig.getOpenMsg()) {
  3.             return ErrorCode.MSG_TURN_OFFED;
  4.         }
  5.         if (2 == aliyunMsgConfig.getOpenMsg()) {
  6.             this.buildAuthCode(phoneNumbers);
  7.             return ErrorCode.SIMULATION_MSG;
  8.         }
  9.         if(0 == aliyunMsgConfig.getOpenMsg()) {
  10.             return this.doMsgSend(phoneNumbers);
  11.         }else{
  12.             return ErrorCode.SYSTEM_ERROR;
  13.         }
  14.     }

核心发送逻辑

  1. private int doMsgSend(String phoneNumbers){
  2.         IClientProfile profile = DefaultProfile.getProfile("default",
  3.                 aliyunMsgConfig.getAccessKeyId(),
  4.                 aliyunMsgConfig.getAccessKeysecret());
  5.         IAcsClient client = new DefaultAcsClient(profile);
  6.         String authCode = this.buildAuthCode(phoneNumbers);
  7.         CommonRequest request = buildCommonRequest(phoneNumbers, authCode);
  8.         try {
  9.             CommonResponse response = client.getCommonResponse(request);
  10.             System.out.println(response.getData());
  11.             return ErrorCode.NO_ERROR;
  12.         } catch (ServerException e) {
  13.             log.warn("【阿里云短信发送异常】");
  14.             e.printStackTrace();
  15.             return ErrorCode.SYSTEM_ERROR;
  16.         } catch (ClientException e) {
  17.             log.warn("【阿里云短信发送异常】");
  18.             e.printStackTrace();
  19.             return ErrorCode.SYSTEM_ERROR;
  20.         }
  21.     }

构造发送请求（官方sdk的CommonRequest类没有添加@Builder注解，=_= ，初始化对象时只能一个个set，令人窒息的操作）

  1. private CommonRequest buildCommonRequest(String phoneNumbers, String code) {
  2.         CommonRequest request = new CommonRequest();
  3.         //request.setProtocol(ProtocolType.HTTPS);
  4.         request.setMethod(MethodType.POST);
  5.         request.setDomain(aliyunMsgConfig.getDomain());
  6.         request.setVersion(aliyunMsgConfig.getVersion());
  7.         request.setAction(aliyunMsgConfig.getAction());
  8.         request.putQueryParameter("PhoneNumbers", phoneNumbers);
  9.         request.putQueryParameter("TemplateCode", aliyunMsgConfig.getTemplateCode());
  10.         request.putQueryParameter("SignName", aliyunMsgConfig.getSignName());
  11.         request.putQueryParameter("TemplateParam", "{\"code\":" + code + "}");
  12.         return request;
  13.     }

生成预发送的验证码信息

  1. /**
  2.      * 生成6位随机验证码
  3.      *
  4.      * @return
  5.      */
  6.     public String buildAuthCode(String phoneNumbers) {
  7.         Integer max = aliyunMsgConfig.getMax();
  8.         Integer min = aliyunMsgConfig.getMin();
  9.         Integer authCode = (new Random().nextInt(max) % (max - min + 1) + min);
  10.         myAuthCodeMap.put(phoneNumbers, authCode.toString());
  11.         log.info("手机号 "+phoneNumbers+" 短信验证码："+authCode);
  12.         return authCode.toString();
  13.     }

编写一些后门服务用于开发调试方便

  1. /**
  2.      * 获取当前的6位随机验证码
  3.      *
  4.      * @return
  5.      */
  6.     public static String getMyAuthCode(String phoneNumbers) {
  7.         return myAuthCodeMap.get(phoneNumbers);
  8.     }
  10.     /**
  11.      * 清除所有的临时随机验证码
  12.      */
  13.     public static void cleanMyAuthCodeMap() {
  14.         myAuthCodeMap.clear();
  15.     }
  17.     /**
  18.      * 清除指定号码的验证码
  19.      * @param phoneNumber
  20.      */
  21.     public static void cleanMyAuthCodeMapByKey(String phoneNumber){
  22.         myAuthCodeMap.remove(phoneNumber);
  23.     }
  25.     /**
  26.      * 获取验证码集合，仅供开发测试！客户端不可调用！
  27.      *
  28.      * @return
  29.      */
  30.     public static Map<String, String> getMyAuthCodeMap() {
  31.         return myAuthCodeMap;
  32.     }

短信发送服务完整代码：（注：这里本类实例bean加载到spring容器中设置了懒加载@Lazy，是为了防止springUtil在获取AliyunMsgConfig bean实例的时候，AliyunMsgConfig还没装载完毕，导致找不到指定bean对象而抛出异常）

  1. package cn.jyycode.common.message;
  3. import cn.jyycode.common.config.AliyunMsgConfig;
  4. import cn.jyycode.common.constant.ErrorCode;
  5. import cn.jyycode.common.utils.SpringUtil;
  6. import com.aliyuncs.CommonRequest;
  7. import com.aliyuncs.CommonResponse;
  8. import com.aliyuncs.DefaultAcsClient;
  9. import com.aliyuncs.IAcsClient;
  10. import com.aliyuncs.exceptions.ClientException;
  11. import com.aliyuncs.exceptions.ServerException;
  12. import com.aliyuncs.http.MethodType;
  13. import com.aliyuncs.profile.DefaultProfile;
  14. import com.aliyuncs.profile.IClientProfile;
  15. import lombok.extern.slf4j.Slf4j;
  16. import org.springframework.context.annotation.Lazy;
  17. import org.springframework.stereotype.Component;
  19. import java.util.HashMap;
  20. import java.util.Map;
  21. import java.util.Random;
  23. /**
  24.  * 阿里云短信服务
  25.  *
  26.  * @author jiayuan9608@163.com
  27.  * 2019-04-01 15:49
  28.  * @version 1.0.0
  29.  */
  30. @Slf4j
  31. @Component
  32. @Lazy
  33. public class CommonRpc {
  35.     private AliyunMsgConfig aliyunMsgConfig = SpringUtil.getBean(AliyunMsgConfig.class);
  37.     /**
  38.      * 随机验证码map集合,防止多个手机号同时注册导致验证码混乱
  39.      */
  40.     private static Map<String, String> myAuthCodeMap = new HashMap<String, String>();
  42.     public int sendMsg(String phoneNumbers) {
  43.         if (1 == aliyunMsgConfig.getOpenMsg()) {
  44.             return ErrorCode.MSG_TURN_OFFED;
  45.         }
  46.         if (2 == aliyunMsgConfig.getOpenMsg()) {
  47.             this.buildAuthCode(phoneNumbers);
  48.             return ErrorCode.SIMULATION_MSG;
  49.         }
  50.         if(0 == aliyunMsgConfig.getOpenMsg()) {
  51.             return this.doMsgSend(phoneNumbers);
  52.         }else{
  53.             return ErrorCode.SYSTEM_ERROR;
  54.         }
  55.     }
  57.     private int doMsgSend(String phoneNumbers){
  58.         IClientProfile profile = DefaultProfile.getProfile("default",
  59.                 aliyunMsgConfig.getAccessKeyId(),
  60.                 aliyunMsgConfig.getAccessKeysecret());
  61.         IAcsClient client = new DefaultAcsClient(profile);
  62.         String authCode = this.buildAuthCode(phoneNumbers);
  63.         CommonRequest request = buildCommonRequest(phoneNumbers, authCode);
  64.         try {
  65.             CommonResponse response = client.getCommonResponse(request);
  66.             System.out.println(response.getData());
  67.             return ErrorCode.NO_ERROR;
  68.         } catch (ServerException e) {
  69.             log.warn("【阿里云短信发送异常】");
  70.             e.printStackTrace();
  71.             return ErrorCode.SYSTEM_ERROR;
  72.         } catch (ClientException e) {
  73.             log.warn("【阿里云短信发送异常】");
  74.             e.printStackTrace();
  75.             return ErrorCode.SYSTEM_ERROR;
  76.         }
  77.     }
  79.     private CommonRequest buildCommonRequest(String phoneNumbers, String code) {
  80.         CommonRequest request = new CommonRequest();
  81.         //request.setProtocol(ProtocolType.HTTPS);
  82.         request.setMethod(MethodType.POST);
  83.         request.setDomain(aliyunMsgConfig.getDomain());
  84.         request.setVersion(aliyunMsgConfig.getVersion());
  85.         request.setAction(aliyunMsgConfig.getAction());
  86.         request.putQueryParameter("PhoneNumbers", phoneNumbers);
  87.         request.putQueryParameter("TemplateCode", aliyunMsgConfig.getTemplateCode());
  88.         request.putQueryParameter("SignName", aliyunMsgConfig.getSignName());
  89.         request.putQueryParameter("TemplateParam", "{\"code\":" + code + "}");
  90.         return request;
  91.     }
  93.     /**
  94.      * 生成6位随机验证码
  95.      *
  96.      * @return
  97.      */
  98.     public String buildAuthCode(String phoneNumbers) {
  99.         Integer max = aliyunMsgConfig.getMax();
  100.         Integer min = aliyunMsgConfig.getMin();
  101.         Integer authCode = (new Random().nextInt(max) % (max - min + 1) + min);
  102.         myAuthCodeMap.put(phoneNumbers, authCode.toString());
  103.         log.info("手机号 "+phoneNumbers+" 短信验证码："+authCode);
  104.         return authCode.toString();
  105.     }
  107.     /**
  108.      * 获取当前的6位随机验证码
  109.      *
  110.      * @return
  111.      */
  112.     public static String getMyAuthCode(String phoneNumbers) {
  113.         return myAuthCodeMap.get(phoneNumbers);
  114.     }
  116.     /**
  117.      * 清除所有的临时随机验证码
  118.      */
  119.     public static void cleanMyAuthCodeMap() {
  120.         myAuthCodeMap.clear();
  121.     }
  123.     /**
  124.      * 清除指定号码的验证码
  125.      * @param phoneNumber
  126.      */
  127.     public static void cleanMyAuthCodeMapByKey(String phoneNumber){
  128.         myAuthCodeMap.remove(phoneNumber);
  129.     }
  131.     /**
  132.      * 获取验证码集合，仅供开发测试！
  133.      *
  134.      * @return
  135.      */
  136.     public static Map<String, String> getMyAuthCodeMap() {
  137.         return myAuthCodeMap;
  138.     }
  139. }

至此，一个短信发送验证码服务就完成了，使用者可以通过实例化CommonRpc类，调用sendMsg方法完成短信服务的发送，验证效果如下：

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nX2ppYXl1YW4_size_16_color_FFFFFF_t_70 3

发表评论

表情：
评论列表 （有 0 条评论，566人围观）

还没有评论，来说两句吧...

相关阅读

    相关 阿里云短信服务

    在开发过程中遇到过短信服务，推荐使用阿里云。个人申请阿里云短信服务确实有些困难，下面我先来简单说一下我的个人申请过程（仅供参考）。 1、申请签名流程 作为开发者,我们大

    叁歲伎倆叁歲伎倆/ 0 赞/ 167 阅读

    相关 应用接入阿里云短信服务

    背景        在日常开发中，我们可能会遇到短信验证之类的需求，这也是我们使用各类app或系统中比较常见的。在对比了各个平台提供的短信服务后，从价格，稳定性，接入便捷

    川长思鸟来川长思鸟来/ 0 赞/ 567 阅读