Cómo enviar SMS en Java

(Descargo de responsabilidad: Trabajo en Twilio)

Twilio ofrece un SDK de Java para enviar SMS a través de la API REST de Twilio.

Si todo lo que desea son notificaciones simples, muchos operadores admiten SMS por correo electrónico; consulte SMS a través de correo electrónico

Hay una API llamada SMSLib, es realmente impresionante. http://smslib.org /

EDITAR:

Ahora tiene muchos proveedores Saas que pueden brindarle este servicio utilizando las API

Ej: mailchimp, esendex, Twilio, ...

La mejor API de SMS que he visto en Java es JSMPP. Es potente, fácil de usar, y lo usé yo mismo para una aplicación de nivel empresarial (enviando más de 20K mensajes SMS diarios).

Esta API se creó para reducir el nivel de detalle de la API SMPP existente. Es muy simple y fácil de usar porque oculta la complejidad de la comunicación de protocolo de bajo nivel, como preguntar automáticamente enlace solicitud-respuesta.

• https://code.google.com/p/jsmpp/

He probado algunas otras API como Ozeki, pero la mayoría de ellas es comercial o tiene limitación en su rendimiento (es decir, no puede enviar más de 3 mensajes SMS en un segundo, por ejemplo).

Puede utilizar Nexmo a enviar SMS así como recibir SMS.

Enviar SMS con la Biblioteca Java de Nexmo es bastante sencillo. Después de crear una nueva cuenta , alquilar un número virtual y obtener su clave y secreto de API, puede usar la biblioteca para enviar SMS de la siguiente manera:

  public class SendSMS {

      public static void main(String[] args) throws Exception {
          AuthMethod auth = new TokenAuthMethod(API_KEY, API_SECRET);
          NexmoClient client = new NexmoClient(auth);

          TextMessage message = new TextMessage(FROM_NUMBER, TO_NUMBER, "Hello from Nexmo!");

          //There may be more than one response if the SMS sent is more than 160 characters.
          SmsSubmissionResult[] responses = client.getSmsClient().submitMessage(message);
            for (SmsSubmissionResult response : responses) {
            System.out.println(response);
          }
      }
  }

Para recibir SMS, deberá configurar un servidor que consuma un webhook. Eso es bastante simple. Recomiendo revisar nuestro tutorial sobre recibir SMS con Java .

Divulgación: Trabajo para Nexmo

Puede Hacer esto Con Un Módem GSM y Java Communications Api[Probado Y Probado]

1. Primero Debe Configurar Java Comm Api

   Este Artículo Describe En Detalle Cómo Configurar La Api De Comunicación

2. A Continuación, Necesita Un Módem GSM (preferiblemente Módulo sim900)

3. Java JDK última versión preferible

4. AT Guía de comandos

   Código

   Muestra de paquete;

       import java.io.*;
       import java.util.*;
   
       import gnu.io.*;
   
       import java.io.*;
   
   
       import org.apache.log4j.chainsaw.Main;
   
       import sun.audio.*;
   
       public class GSMConnect implements SerialPortEventListener, 
        CommPortOwnershipListener {
   
        private static String comPort = "COM6"; // This COM Port must be connect with GSM Modem or your mobile phone
        private String messageString = "";
        private CommPortIdentifier portId = null;
        private Enumeration portList;
        private InputStream inputStream = null;
        private OutputStream outputStream = null;
        private SerialPort serialPort;
        String readBufferTrial = "";
        /** Creates a new instance of GSMConnect */
        public GSMConnect(String comm) {
   
          this.comPort = comm;
   
        }
   
        public boolean init() {
          portList = CommPortIdentifier.getPortIdentifiers();
          while (portList.hasMoreElements()) {
            portId = (CommPortIdentifier) portList.nextElement();
            if (portId.getPortType() == CommPortIdentifier.PORT_SERIAL) {
              if (portId.getName().equals(comPort)) {
                  System.out.println("Got PortName");
                return true;
              }
            }
          }
          return false;
        }
   
        public void checkStatus() {
          send("AT+CREG?\r\n");
        }
   
   
   
        public void send(String cmd) {
          try {
            outputStream.write(cmd.getBytes());
          } catch (IOException e) {
            e.printStackTrace();
          }
        }
   
        public void sendMessage(String phoneNumber, String message) {
              char quotes ='"';
          send("AT+CMGS="+quotes + phoneNumber +quotes+ "\r\n");
          try {
           Thread.sleep(2000);
       } catch (InterruptedException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
       }
           //   send("AT+CMGS=\""+ phoneNumber +"\"\r\n");
          send(message + '\032');
          System.out.println("Message Sent");
        }
   
        public void hangup() {
          send("ATH\r\n");
        }
   
        public void connect() throws NullPointerException {
          if (portId != null) {
            try {
              portId.addPortOwnershipListener(this);
   
              serialPort = (SerialPort) portId.open("MobileGateWay", 2000);
              serialPort.setSerialPortParams(115200,SerialPort.DATABITS_8,SerialPort.STOPBITS_1,SerialPort.PARITY_NONE);
            } catch (PortInUseException | UnsupportedCommOperationException e) {
              e.printStackTrace();
            }
   
            try {
              inputStream = serialPort.getInputStream();
              outputStream = serialPort.getOutputStream();
   
            } catch (IOException e) {
              e.printStackTrace();
            }
   
            try {
              /** These are the events we want to know about*/
              serialPort.addEventListener(this);
              serialPort.notifyOnDataAvailable(true);
              serialPort.notifyOnRingIndicator(true);
            } catch (TooManyListenersException e) {
              e.printStackTrace();
            }
   
       //Register to home network of sim card
   
            send("ATZ\r\n");
   
          } else {
            throw new NullPointerException("COM Port not found!!");
          }
        }
   
        public void serialEvent(SerialPortEvent serialPortEvent) {
          switch (serialPortEvent.getEventType()) {
            case SerialPortEvent.BI:
            case SerialPortEvent.OE:
            case SerialPortEvent.FE:
            case SerialPortEvent.PE:
            case SerialPortEvent.CD:
            case SerialPortEvent.CTS:
            case SerialPortEvent.DSR:
            case SerialPortEvent.RI:     
            case SerialPortEvent.OUTPUT_BUFFER_EMPTY:
            case SerialPortEvent.DATA_AVAILABLE:
   
              byte[] readBuffer = new byte[2048];
              try {
                while (inputStream.available() > 0) 
                {
                  int numBytes = inputStream.read(readBuffer);
   
                  System.out.print(numBytes);
                  if((readBuffer.toString()).contains("RING")){
                  System.out.println("Enter Inside if RING Loop");    
   
   
   
                  }
                }
   
                System.out.print(new String(readBuffer));
              } catch (IOException e) {
              }
              break;
          }
        }
        public void outCommand(){
            System.out.print(readBufferTrial);
        }
        public void ownershipChange(int type) {
          switch (type) {
            case CommPortOwnershipListener.PORT_UNOWNED:
              System.out.println(portId.getName() + ": PORT_UNOWNED");
              break;
            case CommPortOwnershipListener.PORT_OWNED:
              System.out.println(portId.getName() + ": PORT_OWNED");
              break;
            case CommPortOwnershipListener.PORT_OWNERSHIP_REQUESTED:
              System.out.println(portId.getName() + ": PORT_INUSED");
              break;
          }
   
        }
        public void closePort(){
   
           serialPort.close(); 
        }
   
        public static void main(String args[]) {
          GSMConnect gsm = new GSMConnect(comPort);
          if (gsm.init()) {
            try {
                System.out.println("Initialization Success");
              gsm.connect();
              Thread.sleep(5000);
              gsm.checkStatus();
              Thread.sleep(5000);
   
              gsm.sendMessage("+91XXXXXXXX", "Trial Success");
   
              Thread.sleep(1000);
   
              gsm.hangup();
              Thread.sleep(1000);
              gsm.closePort();
              gsm.outCommand();
              System.exit(1);
   
   
            } catch (Exception e) {
              e.printStackTrace();
            }
          } else {
            System.out.println("Can't init this card");
          }
        }
   
   
           }
   

TextMarks te da acceso a su shortcode compartido para enviar y recibir mensajes de texto desde tu aplicación a través de su API. Los mensajes vienen desde / hasta el 41411(en lugar de, por ejemplo, un número de teléfono aleatorio y, a diferencia de las pasarelas de correo electrónico, tiene los 160 caracteres completos para trabajar).

También puedes decirle a la gente que envíe texto con tus palabras clave al 41411 para invocar varias funcionalidades en tu app. Hay un cliente API de JAVA junto con varios otros lenguajes populares y documentación muy completa y técnica apoyo.

La prueba gratuita de 14 días se puede extender fácilmente para los desarrolladores que aún la están probando y creando sus aplicaciones.

Échale un vistazo aquí: TextMarks API Info

Usted puede LOGICA SMPP Java API para enviar y Recibir SMS en la aplicación Java. LOGICA SMPP es una api bien probada en aplicaciones de telecomunicaciones. Logica API también le proporciona capicidad de señalización en conexión TCP / IP.

Puede integrarse directamente con varios operadores de telecomunicaciones en todo el mundo.

Hay dos maneras : Primero: Use una puerta de enlace API SMS que necesita para pagar por ella, tal vez encuentre algunas pruebas incluso gratuitas, pero es escasa . Segundo: Para usar el comando AT con un módem GSM conectado a su computadora portátil . eso es todo

Depende de cómo vaya a trabajar y quién es su proveedor.

Si trabajas con una empresa de gateway sms probablemente trabajarás a través del protocolo SMPP (3.4 sigue siendo el más común), entonces echa un vistazo a OpenSMPP y jSMPP. Estas son libs poderosas para trabajar con SMPP.

Si va a trabajar con su propio hardware (por ejemplo, un módem gsm), la forma más fácil de enviar mensajes es a través de comandos AT, que difieren depende del modelo, por lo que debe averiguar qué comandos AT es compatible con su módem. A continuación, si su módem tiene una IP y está abierto a la conexión, puede enviar comandos a través de java socket

Socket smppSocket = new Socket("YOUR_MODEM_IP", YOUR_MODEM_PORT);
DataOutputStream os = new DataOutputStream(smppSocket.getOutputStream());
DataInputStream is = new DataInputStream(smppSocket.getInputStream());

os.write(some_byte_array[]);
is.readLine();

De lo contrario, trabajará a través de un puerto COM, pero el método es el mismo (enviando comandos AT), puede encontrar más información sobre cómo trabajar con puertos serie aquí.

OMK.smpp. API. se basa en SMPP y simulador también está disponible de forma gratuita

LOGICA SMPP API.

Y otra opción es Kannel una pasarela WAP y SMS gratuita.

Sugiero una solución basada en la nube como Twilio. Las soluciones basadas en la nube son rentables, que una solución interna, ya que no se requiere mantenimiento continuo. SMS a través de correo electrónico no es una solución elegante, ya que tienes que obtener la información del operador del usuario y nunca puedes estar seguro de que puedes enviar mensajes de texto a todos los números móviles. Estoy usando twilio java api en mi aplicación web, para enviar sms desde serverside. en pocos minutos, puede integrarse con su app.

Https://www.twilio.com/docs/java/install

Aquí hay un ejemplo enviando un mensaje SMS desde los documentos:

import com.twilio.sdk.TwilioRestClient;
import com.twilio.sdk.TwilioRestException;
import com.twilio.sdk.resource.factory.MessageFactory;
import com.twilio.sdk.resource.instance.Message;
import org.apache.http.NameValuePair;
import org.apache.http.message.BasicNameValuePair;

import java.util.ArrayList;
import java.util.List;

public class Example {

  // Find your Account Sid and Token at twilio.com/user/account
  public static final String ACCOUNT_SID = "{{ account_sid }}";
  public static final String AUTH_TOKEN = "{{ auth_token }}";

  public static void main(String[] args) throws TwilioRestException {
    TwilioRestClient client = new TwilioRestClient(ACCOUNT_SID, AUTH_TOKEN);

    // Build a filter for the MessageList
    List<NameValuePair> params = new ArrayList<NameValuePair>();
    params.add(new BasicNameValuePair("Body", "Test Twilio message"));
    params.add(new BasicNameValuePair("To", "+14159352345"));
    params.add(new BasicNameValuePair("From", "+14158141829"));

    MessageFactory messageFactory = client.getAccount().getMessageFactory();
    Message message = messageFactory.create(params);
    System.out.println(message.getSid());
  }
}

Smslib es muy útil para este propósito u puede conectar un módem con Su pc y utilizar esta lib para enviar sms . Funciona lo he usado

También nos encanta Java en Wavecell , pero esta pregunta se puede responder sin detalles específicos del lenguaje, ya que tenemos una API REST que cubrirá la mayoría de sus necesidades:

curl -X "POST" https://api.wavecell.com/sms/v1/amazing_hq/single \
    -u amazing:1234512345 \
    -H "Content-Type: application/json" \
    -d $'{ "source": "AmazingDev", "destination": "+6512345678", "text": "Hello, World!" }'

Mire estas preguntas si tiene problemas con el envío de solicitudes HTTP en Java:

• HTTP POST usando JSON en Java
• ¿Cómo puedo enviar un objeto json en http post en java

Para casos específicos, también puede considerar el uso de SMPP API y ya mencionado JSMPP biblioteca ayudará con eso.

Puede usar los comandos de AT & T para enviar sms utilizando el módem GSM.