http://{您的应用接口地址}?accessKeyId={行云管家平台OpenAPI AccessKey}&signature={Web调用请求签名}&version=1&nonce={调用请求唯一标识}&timestamp={时间戳}

Content-type: application/json; charset=UTF-8    Accept: application/json

{ "phones": ["18000000000"], "template": "SystemUpgrade", "parameters": ["2018-10-01 19:30:00", "2018-10-01 22:30:00"] }

public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    response.setContentType("application/json; charset=UTF-8");
    PrintWriter out = response.getWriter();

    // 时间戳
    String timestamp = request.getParameter("timestamp");
    // 随机数
    String nonce = request.getParameter("nonce");
    // 版本
    String version = request.getParameter("version");
    // 本次调用签名值
    String signature = request.getParameter("signature");
    // 行云管家管理控制台 OpenAPI中的AccessKey信息
    String accessKeyId = request.getParameter("accessKeyId");
    // 行云管家管理控制台 OpenAPI中的AccessKey信息
    String accessKeySecret = "";

    Map<String, Object> signMap = new HashMap<String, Object>();
    signMap.put("timestamp", timestamp);
    signMap.put("version", version);
    signMap.put("nonce", nonce);
    signMap.put("accessKeyId", accessKeyId);

    // 通过工具类生成签名，与请求中携带的签名值进行比较，看是否相同
    String signature0 = SignUtil.sign(null, signMap, "POST", accessKeySecret);

    Map<String, Object> result = new HashMap<String, Object>();
    if (signature.equals(signature0)) {
        // 签名校验成功
        // body为短信模版参数，拿到参数去自有短信平台发送短信
        SmsRequest body = JSON.parseObject(request.getInputStream(), SmsRequest.class, null);
        result.put("success", true);
        result.put("msg", "签名成功");
        //短信内容
        String smsText = body.getSMSText();
        //接收短信的手机号码列表
        List<String> pns = body.getPhones();
        //--------在这里调用您的业务代码，进行短信发送即可---------- start //
    
        //--------在这里调用您的业务代码，进行短信发送即可---------- end //
    } else {
        // 签名校验失败，非行云管家平台发送请求
        result.put("success", false);
        result.put("msg", "签名失败");
        System.out.println("签名失败");
    }
    out.println(JSON.toJSONString(result));
    out.flush();
    out.close();
}

public enum SmsTemplate {
    /**
    * 短信验证码
    */
    VerifyCode(2),//验证码模版：验证码，超时（分）
    Session2FA(2),//会话双因子认证：超时（分）、验证码
    SystemUpgrade(2),//升级通知：开始时间，结束时间
    MonitorAlert(3),//监控预警
    CostAlert(2),//后付费资源消费预警
    AlertRecover(4)//告警恢复
    ;
    private int paramLength;//模版需要的参数长度

    SmsTemplate(int paramLength) {
      this.paramLength = paramLength;
    }

    public int getParamLength() {
      return paramLength;
    }
  }

public class SmsRequest {
    //手机号列表
    private List<String> phones = new ArrayList<String>();
    //短信模版
    private SmsTemplate template;
    //模版参数
    private List<String> parameters = new ArrayList<String>();

    public List<String> getPhones() {
      return phones;
    }

    public void setPhones(List<String> phones) {
      this.phones = phones;
    }

    public SmsTemplate getTemplate() {
      return template;
    }

    public void setTemplate(SmsTemplate template) {
      this.template = template;
    }

    public List<String> getParameters() {
      return parameters;
    }

    public void setParameters(List<String> parameters) {
      this.parameters = parameters;
    }
    public String getSMSText() {
        String sms = "";
        switch (template) {
        case VerifyCode :
            sms = "【行云管家】您的验证码是:" + parameters.get(0) + "，该验证码将会在" +
                parameters.get(1) + "分钟后过期。";
        case Session2FA :
            sms = "【行云管家】您正在尝试进行的操作已开启双因子认证，请在" + parameters.get(0) +
                "分钟之内输入以下验证码：" + parameters.get(1) + "，如非本人操作，请确认您的账户安全。";
        case SystemUpgrade :
            sms = "【行云管家】尊敬的用户，行云管家将于" + parameters.get(0) +
                "进行版本升级，届时将暂停服务，请大家提前做好准备，升级工作预计于" + parameters.get(1) +
                "完成，给您带来不便，敬请谅解！";
        case MonitorAlert :
            sms = "【行云管家】您的" + parameters.get(0) + parameters.get(1) +
                "由于" + parameters.get(2) + "而产生预警，请确认预警原因。";
        case CostAlert :
            sms = "【行云管家】您的云账户" + parameters.get(0) + "由于单日后付费资源消费大于" +
                 parameters.get(1) + "而产生预警，请确认预警原因。";
        case AlertRecover :
            sms = "【行云管家】您的" + parameters.get(0) + "“" + parameters.get(1) + "”" +
                parameters.get(2) + "告警恢复，恢复时间：" + parameters.get(3) + "。";
        default :
            sms = "";
        }
        return sms;
    }
}

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Map;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;

public class SignUtil {
    private static final Object LOCK = new Object();
    private static Mac macInstance;
    private static final String ALGORITHM = "HmacSHA1";
    public static String sign(String reqURl, Map<String, Object> parameterMap, String method,
        String accessKeySecret) {
        if (reqURl == null) {
            reqURl = "/";
        }
        if (!reqURl.startsWith("/")) {
            reqURl = "/" + reqURl;
        }
        String canonicalizedQueryString = canonicalize(parameterMap);
        String StringToSign =
                method + "&" +
                        percentEncode(reqURl) + "&" +
                        percentEncode(canonicalizedQueryString);
        return computeSignature(accessKeySecret, StringToSign);
    }

    public static String sign(Map<String, Object> parameterMap, String method, String accessKeySecret) {
        return sign("/", parameterMap, method, accessKeySecret);
    }

    private static String canonicalize(Map<String, Object> parameterMap) {
        StringBuilder sb = new StringBuilder();
        String[] parameterNames = parameterMap.keySet().toArray(new String[parameterMap.size()]);
        Arrays.sort(parameterNames);
        int count = 0;
        for (String paramName : parameterNames) {
            count++;
            sb.append(percentEncode(paramName));
            Object paramValue = parameterMap.get(paramName);
            if (paramValue != null) {
                sb.append("=").append(percentEncode(String.valueOf(paramValue)));
            }
            if (count < parameterNames.length) {
                sb.append("&");
            }
        }
        return sb.toString();
    }

    private static final String DEFAULT_ENCODING = "UTF-8";

    private static String percentEncode(String value) {
        try {
            return value != null ? URLEncoder.encode(value, DEFAULT_ENCODING).replace("+", "%20").replace("*", "%2A").replace("%7E", "~") : null;
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException(e);
        }
    }

    public static String computeSignature(String key, String data) {
        try {
            byte[] signData = sign(key.getBytes(DEFAULT_ENCODING), data.getBytes(DEFAULT_ENCODING));
            return "";
        } catch (UnsupportedEncodingException ex) {
            throw new RuntimeException("Unsupported algorithm: " + DEFAULT_ENCODING, ex);
        }
    }

    private static byte[] sign(byte[] key, byte[] data) {
        try {
            if (macInstance == null) {
                synchronized (LOCK) {
                    if (macInstance == null) {
                        macInstance = Mac.getInstance(ALGORITHM);
                    }
                }
            }
            Mac mac = null;
            try {
                mac = (Mac) macInstance.clone();
            } catch (CloneNotSupportedException e) {
                mac = Mac.getInstance(ALGORITHM);
            }
            mac.init(new SecretKeySpec(key, ALGORITHM));
            return mac.doFinal(data);
        } catch (NoSuchAlgorithmException ex) {
            throw new RuntimeException("Unsupported algorithm: " + ALGORITHM, ex);
        } catch (InvalidKeyException ex) {
            throw new RuntimeException("Invalid key: " + key, ex);
        }
    }

    private static String buildCanonicalizedResource(String resourcePath, Map<String, String> parameters) {
        if (!resourcePath.startsWith("/")) {
            throw new RuntimeException("Resource path should start with '/'");
        }

        StringBuilder builder = new StringBuilder();
        builder.append(resourcePath);
        if (parameters != null) {
            String[] parameterNames = parameters.keySet().toArray(
                    new String[parameters.size()]);
            Arrays.sort(parameterNames);
            char separater = '?';
            for (String paramName : parameterNames) {
                builder.append(separater);
                builder.append(paramName);
                String paramValue = parameters.get(paramName);
                if (paramValue != null) {
                    builder.append("=").append(paramValue);
                }
                separater = '&';
            }
        }
        return builder.toString();
    }
}