Jak wysyłać SMS-y w Javie

Jakie są możliwe sposoby wysyłania i odbierania wiadomości SMS z aplikacji Java?

W jaki sposób?

(Zastrzeżenie: pracuję w Twilio)

Twilio oferuje zestaw Java SDK do wysyłania wiadomości SMS za pośrednictwem interfejsu API REST Twilio.

jeśli chcesz tylko prostych powiadomień, wielu operatorów obsługuje SMS-y przez e-mail; zobacz SMS przez e-mail

Istnieje API o nazwie SMSLib, jest naprawdę niesamowite. http://smslib.org/

Teraz masz wielu dostawców Saas, którzy mogą zaoferować tę usługę za pomocą swoich interfejsów API

Np .: mailchimp, esendex, Twilio, ...

Najlepszym API SMS, jakie widziałem w Javie, jest JSMPP. Jest potężny, łatwy w użyciu i sam go używałem do aplikacji na poziomie przedsiębiorstwa (wysyłałem ponad 20 000 wiadomości SMS dziennie).

Ten interfejs API został utworzony w celu zmniejszenia szczegółowości istniejącego interfejsu API SMPP. Jest bardzo prosty i łatwy w użyciu, ponieważ ukrywa złożoność komunikacji protokołu niskiego poziomu, taką jak automatyczne zapytanie o odpowiedź na żądanie łącza.

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

Wypróbowałem kilka innych interfejsów API, takich jak Ozeki, ale większość z nich jest albo komercyjna, albo ma ograniczenia w przepustowości (np. Nie może wysłać więcej niż 3 wiadomości SMS w ciągu sekundy).

Możesz to zrobić za pomocą modemu GSM i interfejsu komunikacyjnego Java [wypróbowane i przetestowane]

1. Najpierw musisz ustawić Java Comm Api

   W tym artykule szczegółowo opisano sposób konfigurowania interfejsu API komunikacji

2. Następny Potrzebujesz modemu GSM (najlepiej modułu sim900)

3. Preferowana najnowsza wersja Java JDK

4. Przewodnik poleceń AT

   Kod

   próbka pakietu;

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

Możesz używać Nexmo do wysyłania i odbierania SMS-ów .

Wysyłanie wiadomości SMS za pomocą Nexmo Java Library jest dość proste. Po utworzeniu nowego konta , wypożyczeniu numeru wirtualnego i uzyskaniu klucza API i tajnego klucza możesz użyć biblioteki do wysyłania SMS-ów w następujący sposób:

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

Aby odbierać wiadomości SMS, musisz skonfigurować serwer, który używa webhooka. To również jest dość proste. Polecam zapoznać się z naszym samouczkiem dotyczącym odbierania SMS-ów z Javą .

Ujawnienie: pracuję dla Nexmo

TextMarks zapewnia dostęp do udostępnionego skrótu do wysyłania i odbierania wiadomości tekstowych z Twojej aplikacji za pośrednictwem ich interfejsu API. Wiadomości przychodzą z / do 41411 (zamiast np. Losowego numeru telefonu iw przeciwieństwie do bramek e-mail masz pełne 160 znaków do pracy).

Możesz również nakazać użytkownikom wysłanie tekstu w Twoich słowach kluczowych pod numer 41411 w celu wywołania różnych funkcji w Twojej aplikacji. Jest klient API JAVA wraz z kilkoma innymi popularnymi językami oraz bardzo obszerną dokumentacją i wsparciem technicznym.

14-dniowy bezpłatny okres próbny można łatwo przedłużyć dla programistów, którzy wciąż testują go i tworzą swoje aplikacje.

Sprawdź tutaj: Informacje o interfejsie API TextMarks

Są dwa sposoby: Po pierwsze: użyj bramki SMS API, za którą musisz zapłacić, być może znajdziesz wersję próbną, nawet bezpłatną, ale jest to rzadkie. Po drugie: Aby użyć polecenia AT z modemem GSM podłączonym do laptopa. to wszystko

OMK.smpp. API. jest oparty na SMPP, a symulator jest również dostępny za darmo

LOGICA SMPP API.

Inną opcją jest Kannel, bezpłatna bramka WAP i SMS.

Proponuję rozwiązanie oparte na chmurze, takie jak Twilio. Rozwiązania oparte na chmurze są opłacalne niż rozwiązania wewnętrzne, ponieważ nie są wymagane żadne bieżące prace konserwacyjne. SMS przez e-mail nie jest eleganckim rozwiązaniem, ponieważ musisz uzyskać informacje o operatorze od użytkownika i nigdy nie możesz być pewien, że możesz wysłać SMS-a na wszystkie numery telefonów komórkowych. Używam twilio java api w mojej aplikacji internetowej, aby wysyłać sms z serwera. w ciągu kilku minut możesz zintegrować się ze swoją aplikacją.

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

Oto przykład wysyłania wiadomości SMS z dokumentów:

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

Możesz użyć API LOGICA SMPP Java do wysyłania i odbierania wiadomości SMS w aplikacji Java. LOGICA SMPP to sprawdzony interfejs API w aplikacjach telekomunikacyjnych. Logica API zapewnia również możliwość sygnalizacji połączenia TCP / IP.

Możesz bezpośrednio zintegrować się z różnymi operatorami telekomunikacyjnymi na całym świecie.

To zależy od tego, jak zamierzasz pracować i kim jest twój dostawca.

Jeśli pracujesz z firmą obsługującą bramę sms, prawdopodobnie będziesz pracować z protokołem SMPP (3.4 jest nadal najpopularniejszym), a następnie spójrz na OpenSMPP i jSMPP. Są to potężne biblioteki do pracy z SMPP.

Jeśli zamierzasz pracować z własnym sprzętem (np. Modem GSM), najłatwiejszym sposobem wysyłania wiadomości są polecenia AT, różnią się one w zależności od modelu, więc powinieneś dowiedzieć się, jakie polecenia AT są obsługiwane przez twój modem . Następnie, jeśli modem ma adres IP i jest otwarty na połączenie, możesz wysyłać polecenia przez gniazdo 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();

W przeciwnym razie będziesz pracować przez port COM, ale metoda jest taka sama (wysyłanie poleceń AT), więcej informacji na temat pracy z portami szeregowymi znajdziesz tutaj .

smslib jest bardzo przydatny do tego celu. Możesz podłączyć modem do swojego komputera i użyć tej biblioteki do wysyłania smsów. Działa. Użyłem go

Możesz do tego użyć Twilio . Ale jeśli szukasz jakiegoś trudnego obejścia, możesz zastosować obejście, o którym wspomniałem poniżej.

Nie ma możliwości odbierania smsów. Jest to jednak trudna metoda, której możesz użyć do wysyłania wiadomości SMS do wielu klientów. Możesz użyć Twittera API. Konto na Twitterze możemy śledzić z telefonu komórkowego za pomocą sms-a. Musimy tylko wysłać sms na Twittera. Wyobraź sobie, że tworzymy konto na Twitterze o nazwie użytkownika @username. Następnie możemy wysłać sms pod numer 40404, jak pokazano poniżej.

follow @username

Następnie zaczynamy otrzymywać tweety, które są tweetowane na tym koncie.

Po utworzeniu konta na Twitterze możemy użyć interfejsu API Twittera do publikowania tweetów z tego konta. Następnie wszyscy klienci, którzy śledzą to konto, jak wspomniałem wcześniej, zaczynają otrzymywać tweety.

Możesz dowiedzieć się, jak publikować tweety za pomocą Twittera API z poniższego linku.

Twitter API

Zanim zaczniesz programować, musisz uzyskać pozwolenie na używanie Twittera. Możesz uzyskać dostęp do Twittera API z poniższego linku.

Konsola programisty Twittera

To nie jest najlepsze rozwiązanie Twojego problemu, ale miej nadzieję, że to pomoże.

Uwielbiamy również Javę w Wavecell , ale na to pytanie można odpowiedzieć bez szczegółów specyficznych dla języka, ponieważ mamy REST API, które zaspokoi większość Twoich potrzeb:

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

Spójrz na te pytania, jeśli masz problemy z wysyłaniem żądań HTTP w Javie:

• HTTP POST przy użyciu JSON w Javie
• Jak mogę wysłać obiekt json w postu http w java

W szczególnych przypadkach możesz również rozważyć użycie interfejsu API SMPP, a wspomniana już biblioteka JSMPP pomoże w tym.

Możesz użyć poleceń AT & T do wysyłania smsów za pomocą modemu GSM.