Comment envoyer des SMS en Java

(Avertissement: Je travaille chez Twilio)

Twilio propose un SDK Java pour l'envoi de SMS via l'API REST Twilio.

Si tout ce que vous voulez, ce sont des notifications simples, de nombreux transporteurs prennent en charge les SMS par e-mail; voir SMS par E-Mail

Il y a une API appelée SMSLib, c'est vraiment génial. http://smslib.org/

MODIFIER:

Maintenant, vous avez beaucoup de fournisseurs Saas qui peuvent vous donner ce service en utilisant des API

Ex: mailchimp, esendex, Twilio, ...

La meilleure API SMS que j'ai vue en Java est JSMPP. Il est puissant, facile à utiliser, et je l'ai utilisé moi-même pour une application de niveau entreprise (envoi de plus de 20K SMS par jour).

Cette API créée pour réduire la verbosité de l'API SMPP existante. Il est très simple et facile à utiliser car il cache la complexité de la communication de protocole de bas niveau telle que s'enquièrent automatiquement lien requête-réponse.

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

J'ai essayé d'autres API telles que Ozeki, mais la plupart d'entre elles sont commerciales ou ont une limitation de son débit (c'est-à-dire qu'elles ne peuvent pas envoyer plus de 3 SMS en une seconde, par exemple).

Vous pouvez utiliser Nexmo à envoyer des SMS ainsi que recevoir des SMS.

Envoyer des SMS avec la bibliothèque Nexmo Java est assez simple. Après la création d'un nouveau compte , la location d'un numéro virtuel et l'obtention de votre clé API et de votre secret, vous pouvez utiliser la bibliothèque pour envoyer des SMS comme suit:

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

Pour recevoir des SMS, vous devez configurer un serveur qui consomme un webhook. C'est assez simple. Je recommande de consulter notre tutoriel sur recevoir des SMS avec Java .

Divulgation: je travaille pour Nexmo

Vous Pouvez le Faire Avec Un Modem GSM et Java Communications Api [Essayé et testé]

1. Vous Devez D'abord Définir Java Comm Api

   Cet Article Décrit En Détail Comment Configurer L'Api De Communication

2. Ensuite, Vous Avez Besoin D'Un Modem GSM (de préférence Le Module sim900)

3. Java JDK dernière version préférable

4. Au Guide de commande

   Code

   Échantillon de paquet;

       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 vous donne accès à son shortcode partagé pour envoyer et recevoir des messages texte de votre application via leur API. Les messages proviennent de / vers 41411 (au lieu, par exemple, d'un numéro de téléphone aléatoire et contrairement aux passerelles de messagerie, vous avez les 160 caractères complets avec lesquels travailler).

Vous pouvez également dire aux gens d'envoyer du texte dans vos mots clés à 41411 pour appeler diverses fonctionnalités de votre application. Il existe un client API JAVA ainsi que plusieurs autres langages populaires et une documentation très complète et technique soutien.

L'essai gratuit de 14 jours peut être facilement prolongé pour les développeurs qui le testent encore et construisent leurs applications.

Vérifiez-le ici: TextMarks API Info

Vous pouvez vous LOGICA SMPP API Java pour l'envoi et la réception de SMS dans l'application Java. LOGICA SMPP est une api éprouvée dans les applications télécoms. L'API Logica vous fournit également une capacité de signalisation sur une connexion TCP/IP.

Vous pouvez intégrer directement avec divers opérateurs de télécommunications à travers le monde.

Il y a deux façons : Tout d'abord: Utilisez une passerelle API SMS que vous devez payer pour cela , peut-être que vous trouverez des essais même gratuits, mais c'est rare . Deuxième : À utiliser à la commande avec un modem GSM connecté à votre ordinateur portable . c'est tout

Cela dépend de la façon dont vous allez travailler et de votre fournisseur.

Si vous travaillez avec une société de passerelle SMS, vous travaillerez probablement via le protocole SMPP (3.4 est toujours le plus courant), alors jetez un oeil sur OpenSMPP et jSMPP. Ce sont des bibliothèques puissantes pour travailler avec SMPP.

Si vous allez travailler avec votre propre matériel (par exemple un modem gsm), la façon la plus simple d'envoyer des messages est de passer par les commandes AT, elles diffèrent selon le modèle, vous devriez donc savoir ce que sont les commandes AT pris en charge par votre modem. Ensuite, si votre modem a une adresse IP et ouvert à la connexion, vous pouvez envoyer des commandes via 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();

Sinon vous travaillerez via un port COM, mais la méthode est la même (envoi de commandes AT), vous pouvez trouver plus d'informations sur la façon de travailler avec les ports série ici .

OMK.smpp. API. c'est sur la base de SMPP et simulateur est également disponible gratuitement

LOGICA SMPP API.

Et une autre option est Kannel une passerelle WAP et SMS gratuite.

Je suggère une solution basée sur le cloud comme Twilio. Les solutions basées sur le cloud sont rentables, qu'une solution interne car il n'y a pas de maintenance continue, requise. SMS par e-mail n'est pas une solution élégante, car vous devez obtenir les informations du transporteur de l'utilisateur et vous ne pouvez jamais être sûr que vous pouvez envoyer un SMS à tous les numéros de téléphone mobile. J'utilise l'api java twilio dans mon application Web, pour envoyer des SMS depuis le serveur. en quelques minutes, vous pouvez intégrer avec votre App.

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

Voici un exemple d'envoi d'un message SMS à partir des documents:

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 est très utile à cet effet, vous pouvez connecter un modem à votre PC et utiliser cette bibliothèque pour envoyer des SMS . Cela fonctionne je l'ai utilisé

Nous aimons aussi Java dans Wavecell, mais cette question peut être répondue sans détails spécifiques à la langue puisque nous avons une API REST {[3] } qui couvrira la plupart de vos besoins:

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!" }'

Regardez ces questions si vous avez des problèmes avec l'envoi de requêtes HTTP en Java:

• HTTP POST utilisant JSON en Java
• Comment puis-je envoyer un objet json dans http post en java

Pour des cas spécifiques, vous pouvez également envisager d'utiliser le SMPP API et déjà mentionné JSMPP bibliothèque aidera avec cela.

Vous pouvez utiliser les commandes AT & T pour envoyer des SMS à l'aide du modem GSM.