Cómo enviar SMS en Java

¿Cuáles son las formas posibles de enviar y recibir sms desde la aplicación Java?

¿Cómo?

(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 quiere es notificaciones simples, muchos operadores admiten SMS por correo electrónico; ver SMS por correo electrónico

La mejor API de SMS que he visto en Java es JSMPP. Es potente, fácil de usar, y lo utilicé para una aplicación de nivel empresarial (envío de más de 20 mil mensajes SMS diarios).

Esta API creada para reducir la verbosidad 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 la solicitud de respuesta de enlace de solicitud automática.

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

He probado algunas otras API como Ozeki, pero la mayoría de ellas son comerciales o tienen limitaciones en su rendimiento (es decir, no pueden enviar más de 3 mensajes SMS en un segundo, por ejemplo).

Hay una API llamada SMSLib, es realmente increíble. http://smslib.org/

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

Ej: mailchimp, esendex, Twilio, ...

Puede hacer esto con un módem GSM y una API de comunicaciones Java [probado y probado]

1. Primero necesitas 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 Command Guide

   Código

   paquete de muestra;

       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");
          }
        }
   
   
           }
   

Puede usar Nexmo para enviar SMS y recibir SMS .

Enviar SMS con la Biblioteca Nexmo Java es bastante sencillo. Después de crear una nueva cuenta , alquilar un número virtual y obtener su clave y secreto 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 también. Recomiendo consultar nuestro tutorial sobre la recepción de SMS con Java .

Divulgación: trabajo para Nexmo

TextMarks le da acceso a su shortcode compartido para enviar y recibir mensajes de texto desde su aplicación a través de su API. Los mensajes provienen del / al 41411 (en lugar de, por ejemplo, un número de teléfono aleatorio y, a diferencia de las puertas de enlace de correo electrónico, tiene 160 caracteres completos para trabajar).

También puede decirle a las personas que envíen mensajes de texto en sus palabras clave al 41411 para invocar varias funciones en su aplicación. Hay un cliente API JAVA junto con varios otros idiomas populares y documentación y soporte técnico muy completos.

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

Compruébelo aquí: Información de la API TextMarks

Puede utilizar la API Java LOGICA SMPP para enviar y recibir SMS en la aplicación Java. LOGICA SMPP está bien probado api en aplicaciones de telecomunicaciones. Logica API también le proporciona capicidad de señalización en la conexión TCP / IP.

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

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

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

Si trabaja con una empresa de sms-gateway, probablemente trabajará a través del protocolo SMPP (3.4 sigue siendo el más común), eche 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, estos difieren según el modelo, por lo tanto, debe averiguar qué comandos AT admite 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 del socket de Java

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 es base en SMPP y el simulador también está disponible de forma gratuita

API LOGICA SMPP.

Y otra opción es Kannel, una puerta de enlace 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. Los SMS a través del correo electrónico no son una solución elegante, ya que debe obtener la información del operador del usuario y nunca puede estar seguro de que puede 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 el lado del servidor. En pocos minutos, puede integrarse con su aplicación.

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, puede conectar un módem con su PC y usar esta lib para enviar sms. Funciona lo he usado

También amamos Java en Wavecell , pero esta pregunta se puede responder sin detalles específicos del idioma 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 para enviar solicitudes HTTP en Java:

• POST HTTP usando JSON en Java
• ¿Cómo puedo enviar un objeto json en una publicación http en java?

Para casos específicos, también puede considerar usar la API SMPP y la biblioteca JSMPP ya mencionada ayudará con eso.

Puedes usar Twilio para esto. Pero si está buscando una solución alternativa, puede seguir la solución que he mencionado a continuación.

Esto no es posible para recibir sms. Pero este es un método complicado que puede usar para enviar sms a varios clientes. Puedes usar la API de Twitter. Podemos seguir la cuenta de Twitter desde nuestro teléfono móvil con un sms. Solo tenemos que enviar sms a twitter. Imagina que creamos una cuenta de Twitter con el nombre de usuario de @username. Entonces podemos enviar sms al 40404 como se muestra a continuación.

follow @username

Luego comenzamos a recibir tweets que se twittean en esa cuenta.

Entonces, después de crear una cuenta de Twitter, podemos usar la API de Twitter para publicar tweets desde esa cuenta. Luego, todos los clientes que han seguido esa cuenta como mencioné antes comienzan a recibir tweets.

Puede aprender cómo publicar tweets con la API de Twitter desde el siguiente enlace.

API de Twitter

Antes de comenzar a desarrollar, debe obtener permiso para usar la API de Twitter. Puede obtener acceso a la API de Twitter desde el siguiente enlace.

Consola de desarrollador de Twitter

Esta no es la mejor solución para su problema, pero espero que esto ayude.

Puede usar los comandos AT&T para enviar sms usando un módem GSM.