如何利用阿里云市场购买并使用短信服务

简介: 如何利用阿里云市场购买并使用短信服务

就在前几天,谷粒学院项目又遇到了这样一个需求,我就开始忙着申请、开通这个业务,最后得知:个人用户无法使用短信服务,必须是公司或者上线的业务才可申请 ,这就让我们这些苦逼的大学生为难了。 之后我尝试过 购买服务器搭建网站 再申请、转腾讯云、公众号申请等沙雕操作,最终都以失败告终!💔💔💔


后来某一天来自佛祖的运气,让我通过一个弹幕得知,可以在阿里云 云市场购买其他云的短信服务,😘😘😘 妙极了!


❤️❤️❤️下面介绍如何使用阿里云时长购买并使用短信服务的详细流程!❤️❤️❤️


使用步骤


1、进入云市场官网 https://market.aliyun.com/


d5724fbeca3b1f29241399aae7337abe.png


2、搜索对应的产品


1e9fbc7db08b53e5871a6e07faddd790.png


3、进行购买


d7c3d6964fc4ab2f46052a4c74a08e61.png


4、购买成功后可以进入控制台进行查看


4473d6eb36950f209f43de3fb2ebde62.png


d2d7d525b06aee334d3695ceab802ff3.png


35866355841ed7ddc86a1d3a7bdc24f3.png


5、如何使用


查看购买下方的指南



24e6f0ffc2d9d2a19ef0fc983f78c94d.png

26d39b57caf1717e989fdc2e364e0f6b.png

933a281d7be87ba90ca4be9e8dc21143.png


6、查看短信模板


d6de987439b3d4a7d52ca827ca334e4d.png


现在我们 mobile,templateId,param(后序自己进行字符串拼接)都有了,就差smsId了


7、联系客服进行身份认证,申请smsId.


如何申请: http://help.guoyangyun.com/Problem/Certification.html


b4b1b7d61258990d03c8c7cd2c37c956.png


客服的服务态度绝对是五星的,回复的very quickly,也很有耐心.


d6f770a1d13afd3d60d4a64feee6b449.png


认证成功后,客服会发送自己一个smsId:xxxxxxxxx


8、使用代码开始发送短信


90987e1cf8152ab87ed9a9c7e781be9d.png


具体代码

下面贴出Java发送验证码的详细代码

  • 依赖 pom.xml
<dependencies>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.15</version>
    </dependency>
    <dependency>
        <groupId>org.apache.httpcomponents</groupId>
        <artifactId>httpclient</artifactId>
        <version>4.2.1</version>
    </dependency>
    <dependency>
        <groupId>org.apache.httpcomponents</groupId>
        <artifactId>httpcore</artifactId>
        <version>4.2.1</version>
    </dependency>
    <dependency>
        <groupId>commons-lang</groupId>
        <artifactId>commons-lang</artifactId>
        <version>2.6</version>
    </dependency>
    <dependency>
        <groupId>org.eclipse.jetty</groupId>
        <artifactId>jetty-util</artifactId>
        <version>9.3.7.v20160115</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>


  • httpUtils
package com.rg.sms;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import org.apache.commons.lang.StringUtils;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpDelete;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.entity.ByteArrayEntity;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
public class HttpUtils {
    /**
     * get
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @return
     * @throws Exception
     */
    public static HttpResponse doGet(String host, String path, String method,
                                     Map <String, String> headers,
                                     Map <String, String> querys)
            throws Exception {
        HttpClient httpClient = wrapClient(host);
        HttpGet request = new HttpGet(buildUrl(host, path, querys));
        for (Map.Entry <String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }
        return httpClient.execute(request);
    }
    /**
     * post form
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @param bodys
     * @return
     * @throws Exception
     */
    public static HttpResponse doPost(String host, String path, String method,
                                      Map <String, String> headers,
                                      Map <String, String> querys,
                                      Map <String, String> bodys)
            throws Exception {
        HttpClient httpClient = wrapClient(host);
        HttpPost request = new HttpPost(buildUrl(host, path, querys));
        for (Map.Entry <String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }
        if (bodys != null) {
            List <NameValuePair> nameValuePairList = new ArrayList <NameValuePair>();
            for (String key : bodys.keySet()) {
                nameValuePairList.add(new BasicNameValuePair(key, bodys.get(key)));
            }
            UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(nameValuePairList, "utf-8");
            formEntity.setContentType("application/x-www-form-urlencoded; charset=UTF-8");
            request.setEntity(formEntity);
        }
        return httpClient.execute(request);
    }
    /**
     * Post String
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPost(String host, String path, String method,
                                      Map <String, String> headers,
                                      Map <String, String> querys,
                                      String body)
            throws Exception {
        HttpClient httpClient = wrapClient(host);
        HttpPost request = new HttpPost(buildUrl(host, path, querys));
        for (Map.Entry <String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }
        if (StringUtils.isNotBlank(body)) {
            request.setEntity(new StringEntity(body, "utf-8"));
        }
        return httpClient.execute(request);
    }
    /**
     * Post stream
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPost(String host, String path, String method,
                                      Map <String, String> headers,
                                      Map <String, String> querys,
                                      byte[] body)
            throws Exception {
        HttpClient httpClient = wrapClient(host);
        HttpPost request = new HttpPost(buildUrl(host, path, querys));
        for (Map.Entry <String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }
        if (body != null) {
            request.setEntity(new ByteArrayEntity(body));
        }
        return httpClient.execute(request);
    }
    /**
     * Put String
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPut(String host, String path, String method,
                                     Map <String, String> headers,
                                     Map <String, String> querys,
                                     String body)
            throws Exception {
        HttpClient httpClient = wrapClient(host);
        HttpPut request = new HttpPut(buildUrl(host, path, querys));
        for (Map.Entry <String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }
        if (StringUtils.isNotBlank(body)) {
            request.setEntity(new StringEntity(body, "utf-8"));
        }
        return httpClient.execute(request);
    }
    /**
     * Put stream
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPut(String host, String path, String method,
                                     Map <String, String> headers,
                                     Map <String, String> querys,
                                     byte[] body)
            throws Exception {
        HttpClient httpClient = wrapClient(host);
        HttpPut request = new HttpPut(buildUrl(host, path, querys));
        for (Map.Entry <String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }
        if (body != null) {
            request.setEntity(new ByteArrayEntity(body));
        }
        return httpClient.execute(request);
    }
    /**
     * Delete
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @return
     * @throws Exception
     */
    public static HttpResponse doDelete(String host, String path, String method,
                                        Map <String, String> headers,
                                        Map <String, String> querys)
            throws Exception {
        HttpClient httpClient = wrapClient(host);
        HttpDelete request = new HttpDelete(buildUrl(host, path, querys));
        for (Map.Entry <String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }
        return httpClient.execute(request);
    }
    private static String buildUrl(String host, String path, Map <String, String> querys) throws UnsupportedEncodingException {
        StringBuilder sbUrl = new StringBuilder();
        sbUrl.append(host);
        if (!StringUtils.isBlank(path)) {
            sbUrl.append(path);
        }
        if (null != querys) {
            StringBuilder sbQuery = new StringBuilder();
            for (Map.Entry <String, String> query : querys.entrySet()) {
                if (0 < sbQuery.length()) {
                    sbQuery.append("&");
                }
                if (StringUtils.isBlank(query.getKey()) && !StringUtils.isBlank(query.getValue())) {
                    sbQuery.append(query.getValue());
                }
                if (!StringUtils.isBlank(query.getKey())) {
                    sbQuery.append(query.getKey());
                    if (!StringUtils.isBlank(query.getValue())) {
                        sbQuery.append("=");
                        sbQuery.append(URLEncoder.encode(query.getValue(), "utf-8"));
                    }
                }
            }
            if (0 < sbQuery.length()) {
                sbUrl.append("?").append(sbQuery);
            }
        }
        return sbUrl.toString();
    }
    private static HttpClient wrapClient(String host) {
        HttpClient httpClient = new DefaultHttpClient();
        if (host.startsWith("https://")) {
            sslClient(httpClient);
        }
        return httpClient;
    }
    private static void sslClient(HttpClient httpClient) {
        try {
            SSLContext ctx = SSLContext.getInstance("TLS");
            X509TrustManager tm = new X509TrustManager() {
                public X509Certificate[] getAcceptedIssuers() {
                    return null;
                }
                public void checkClientTrusted(X509Certificate[] xcs, String str) {
                }
                public void checkServerTrusted(X509Certificate[] xcs, String str) {
                }
            };
            ctx.init(null, new TrustManager[]{tm}, null);
            SSLSocketFactory ssf = new SSLSocketFactory(ctx);
            ssf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
            ClientConnectionManager ccm = httpClient.getConnectionManager();
            SchemeRegistry registry = ccm.getSchemeRegistry();
            registry.register(new Scheme("https", 443, ssf));
        } catch (KeyManagementException ex) {
            throw new RuntimeException(ex);
        } catch (NoSuchAlgorithmException ex) {
            throw new RuntimeException(ex);
        }
    }
}


  • SMSUtils类
package com.rg.sms;
import org.apache.http.HttpResponse;
import java.util.HashMap;
import java.util.Map;
/**
 * @author lxy
 * @version 1.0
 * @Description
 * @date 2022/3/6 14:35
 */
public class SmsUtil {
    /**
     *
     * @param mobile  手机号
     * @param code    发送的验证码
     * @param minute  多长时间有效
     * @param smsSignId  签名id
     * @param templateId 模板id
     * @param minute
     */
    public static void sendMessage(String appCode,String mobile,String code,String minute,String smsSignId,String templateId){
        String host = "https://gyytz.market.alicloudapi.com";
        String path = "/sms/smsSend";
        String method = "POST";
        Map<String, String> headers = new HashMap<String, String>();
        //最后在header中的格式(中间是英文空格)为Authorization:APPCODE 83359fd73fe94948385f570e3c139105
        headers.put("Authorization", "APPCODE " + appCode);
        Map<String, String> querys = new HashMap<String, String>();
        querys.put("mobile", mobile);
        querys.put("param", "**code**:"+code+",**minute**:"+minute);
        querys.put("smsSignId", smsSignId);
        querys.put("templateId", templateId);
        Map <String, String> bodys = new HashMap <String, String>();
        try {
            /**
             * 重要提示如下:
             * HttpUtils请从12
             * https://github.com/aliyun/api-gateway-demo-sign-java/blob/master/src/main/java/com/aliyun/api/gateway/demo/util/HttpUtils.java
             * 下载
             *
             * 相应的依赖请参照
             * https://github.com/aliyun/api-gateway-demo-sign-java/blob/master/pom.xml
             */
            HttpResponse response = HttpUtils.doPost(host, path, method, headers, querys, bodys);
            System.out.println(response.toString());
            //获取response的body
            //System.out.println(EntityUtils.toString(response.getEntity()));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


  • Demo
/**
 * @author lxy
 * @version 1.0
 * @Description
 * @date 2022/3/6 15:19
 */
public class Demo {
    public static void main(String[] args) {
        SmsUtil.sendMessage("xxxxxx","xxxxxx","999999","30","xxxxxxxxxxxx","a09602b817fd47e59e7c6e603d3f088d");
    }
}


查看发送结果:

image.png


image.png





相关文章
|
1月前
|
SQL 弹性计算 安全
购买阿里云活动内云服务器之后设置密码、安全组、增加带宽、挂载云盘教程
当我们通过阿里云的活动购买完云服务器之后,并不是立马就能使用了,还需要我们设置云服务器密码,配置安全组等基本操作之后才能使用,有的用户还需要购买并挂载数据盘到云服务器上,很多新手用户由于是初次使用阿里云服务器,因此并不知道这些设置的操作流程,下面给大家介绍下这些设置的具体操作流程。
购买阿里云活动内云服务器之后设置密码、安全组、增加带宽、挂载云盘教程
|
2月前
|
Serverless 开发者 Docker
ModelScope问题之购买云服务器阿里云显示一直在准备中如何解决
ModelScope镜像是指用于在ModelScope平台上创建和管理的容器镜像,这些镜像包含用于模型训练和推理的环境和依赖;本合集将说明如何使用ModelScope镜像以及管理镜像的技巧和注意事项。
74 2
|
2月前
|
弹性计算 应用服务中间件
一看就懂:阿里云服务器价格购买价格表,选择适合你的云服务器
一看就懂:阿里云服务器价格购买价格表,选择适合你的云服务器
|
1月前
|
SQL 关系型数据库 MySQL
阿里云MySQL数据库价格、购买、创建账号密码和连接数据库教程
阿里云数据库使用指南:购买MySQL、SQL Server等RDS实例,选择配置和地区,完成支付。创建数据库和账号,设置权限。通过DMS登录数据库,使用账号密码访问。同地域VPC内的ECS需将IP加入白名单以实现内网连接。参考链接提供详细步骤。
371 3
|
2月前
|
弹性计算 安全 数据安全/隐私保护
阿里云幻兽帕鲁/Palworld服务器购买3个月和1个月时长多少钱?
阿里云幻兽帕鲁/Palworld服务器购买3个月和1个月时长多少钱?在阿里云上搭建幻兽帕鲁服务器,付费时长怎么选?选择1个月还是3个月?选择3个月。为什么?因为续费价格比较贵。所以建议购买资源时长选择3个月。
|
1月前
|
存储 编解码 缓存
购买阿里云服务器如何选择实例?根据业务场景与细分场景选择实例规格
对于很多初次购买阿里云服务器的用户来说,面对众多可选择的云服务器实例规格,往往不知道如何选择,不同实例规格适用于不同的业务场景,本文为大家汇总了不同业务场景和细分场景下应该选择的主要实例规格,以及这些实例规格的主要性能和适用场景,如果你不知道如何选择阿里云服务器的实例规格,不妨根据自己的场景参考本文所推荐的主要实例规格来选择。
购买阿里云服务器如何选择实例?根据业务场景与细分场景选择实例规格
|
2月前
|
弹性计算 大数据 测试技术
2024购买阿里云服务器4核8G配置需要多少钱?
2024购买阿里云服务器4核8G配置需要多少钱?
|
2月前
|
弹性计算 大数据 测试技术
阿里云服务器4核8g的购买价格_精准报价
阿里云服务器4核8g配置多少钱一年?1个月费用多少?云服务器u1实例3折优惠价955.58元一年,计算型c7云服务器4核8G价格2944.79元一年。4核8G服务器按月购买比较贵,经济型e实例4核8G配置1个月216元,通用算力型u1服务器336.96元一个月。阿里云百科分享4核8G服务器租用费用
|
9天前
|
人工智能 安全 云计算
阿里云服务器购买之后发票如何申请?申请发票流程及常见问题参考
申请发票是很多用户尤其是企业级用户在购买完阿里云服务器之后非常关注的问题,对于初次购买阿里云服务器的用户来说,往往并不清楚如何找阿里云申请发票,本文以图文形式为大家介绍阿里云服务器购买完成之后申请发票的详细流程以及常见问题。
阿里云服务器购买之后发票如何申请?申请发票流程及常见问题参考
|
1月前
|
弹性计算 关系型数据库 MySQL
阿里云MySQL云数据库优惠价格、购买和使用教程分享!
阿里云数据库使用流程包括购买和管理。首先,选购支持MySQL、SQL Server、PostgreSQL等的RDS实例,如选择2核2GB的MySQL,设定地域和可用区。购买后,等待实例创建。接着,创建数据库和账号,设置DB名称、字符集及账号权限。最后,通过DMS登录数据库,填写账号和密码。若ECS在同一地域和VPC内,可内网连接,记得将ECS IP加入白名单。
442 2

热门文章

最新文章