Este guia demonstra como enviar mensagnes SMS usando a API da Alibaba Cloud em uma aplicação Java. A implementação utiliza o Spring MVC para criar um controlaodr e uma classe utilitária para requisições HTTP.

Primeiro, é necessário configurar um controlador Spring. O exemplo abaixo cria um endpoint que aciona o envio de um SMS. As configurações do host, caminho e método são definidas, e o cabeçalho de autorização é construído usando um código de aplicativo exclusivo.

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.Map;

@RestController
@RequestMapping("/api/sms")
public class SmsController {

    private static final String API_HOST = "http://yzx.market.alicloudapi.com";
    private static final String ENDPOINT_PATH = "/yzx/sendSms";
    private static final String APP_CODE = "SEU_CODIGO_APP_AQUI";

    @GetMapping("/enviar")
    public String enviarSms() {
        String urlBase = API_HOST;
        String recurso = ENDPOINT_PATH;
        String operacao = "POST";

        Map<String, String> cabecalho = new HashMap<>();
        cabecalho.put("Authorization", "APPCODE " + APP_CODE);

        Map<String, String> parametrosConsulta = new HashMap<>();
        parametrosConsulta.put("mobile", "NUMERO_DESTINO");
        parametrosConsulta.put("tpl_id", "ID_TEMPLATE_SMS");

        Map<String, String> corpo = new HashMap<>();

        try {
            HttpResponse resposta = ClienteHttp.enviarPost(urlBase, recurso, operacao, cabecalho, parametrosConsulta, corpo);
            return "Resposta: " + resposta.getStatusLine().toString();
        } catch (Exception e) {
            e.printStackTrace();
            return "Erro ao enviar SMS: " + e.getMessage();
        }
    }
}

A classe utilitária abaixo abstrai as operações HTTP. Ela fornece métodos para diferentes verbos (GET, POST, PUT, DELETE) e inclui tratamento para conexões SSL.

import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.*;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.NameValuePair;
import java.security.SecureRandom;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import javax.net.ssl.*;

public class ClienteHttp {

    public static HttpResponse enviarPost(String host, String path, String method,
                                          Map<String, String> headers,
                                          Map<String, String> queryParams,
                                          Map<String, String> bodyParams) throws Exception {
        
        HttpClient client = inicializarCliente(host);
        String urlCompleta = montarUrl(host, path, queryParams);
        HttpPost requisicao = new HttpPost(urlCompleta);
        
        adicionarCabecalhos(requisicao, headers);
        
        if (bodyParams != null && !bodyParams.isEmpty()) {
            List<NameValuePair> paresNomeValor = new ArrayList<>();
            for (Map.Entry<String, String> entrada : bodyParams.entrySet()) {
                paresNomeValor.add(new BasicNameValuePair(entrada.getKey(), entrada.getValue()));
            }
            UrlEncodedFormEntity entidade = new UrlEncodedFormEntity(paresNomeValor, "UTF-8");
            requisicao.setEntity(entidade);
        }
        
        return client.execute(requisicao);
    }

    private static String montarUrl(String host, String path, Map<String, String> queryParams) {
        StringBuilder urlBuilder = new StringBuilder(host);
        if (path != null && !path.isEmpty()) {
            urlBuilder.append(path);
        }
        if (queryParams != null && !queryParams.isEmpty()) {
            StringBuilder queryString = new StringBuilder();
            for (Map.Entry<String, String> param : queryParams.entrySet()) {
                if (queryString.length() > 0) {
                    queryString.append("&");
                }
                queryString.append(param.getKey()).append("=").append(param.getValue());
            }
            if (queryString.length() > 0) {
                urlBuilder.append("?").append(queryString);
            }
        }
        return urlBuilder.toString();
    }

    private static void adicionarCabecalhos(HttpRequestBase requisicao, Map<String, String> headers) {
        for (Map.Entry<String, String> entrada : headers.entrySet()) {
            requisicao.setHeader(entrada.getKey(), entrada.getValue());
        }
    }

    private static HttpClient inicializarCliente(String host) {
        HttpClient httpClient = new DefaultHttpClient();
        if (host.startsWith("https://")) {
            try {
                SSLContext sslContext = SSLContext.getInstance("TLS");
                sslContext.init(null, new TrustManager[]{new X509TrustManager() {
                    public X509Certificate[] getAcceptedIssuers() { return null; }
                    public void checkClientTrusted(X509Certificate[] certs, String authType) {}
                    public void checkServerTrusted(X509Certificate[] certs, String authType) {}
                }}, new SecureRandom());
                
                SSLSocketFactory sslFactory = new SSLSocketFactory(sslContext, SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
                httpClient.getConnectionManager().getSchemeRegistry().register(new org.apache.http.conn.scheme.Scheme("https", 443, sslFactory));
            } catch (Exception e) {
                throw new RuntimeException("Falha ao configurar SSL", e);
            }
        }
        return httpClient;
    }
}

As dependências Maven necessárias para o projeto são especificadas abaixo. Elas incluem as bibliotecas Apache HttpClient para comunicação HTTP, o Spring Web para a estrutura do controlador e o commons-lang para utilidades.

<dependencies>
    <dependency>
        <groupId>org.apache.httpcomponents</groupId>
        <artifactId>httpclient</artifactId>
        <version>4.5.13</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.10</version>
    </dependency>
    <dependency>
        <groupId>commons-lang</groupId>
        <artifactId>commons-lang</artifactId>
        <version>2.6</version>
    </dependency>
</dependencies>