Quali sono i modi possibili per inviare e ricevere sms dall'applicazione Java?
Come?
Quali sono i modi possibili per inviare e ricevere sms dall'applicazione Java?
Come?
Risposte:
(Disclaimer: lavoro a Twilio)
Twilio offre un SDK Java per l'invio di SMS tramite l'API REST di Twilio.
se tutto ciò che desideri sono semplici notifiche, molti gestori supportano SMS via e-mail; vedi SMS via e-mail
La migliore API SMS che ho visto in Java è JSMPP. È potente, facile da usare e l'ho usato da solo per un'applicazione di livello aziendale (invio quotidiano di oltre 20.000 messaggi SMS).
Questa API è stata creata per ridurre la verbosità dell'API SMPP esistente. È molto semplice e facile da usare perché nasconde la complessità della comunicazione di protocollo di basso livello come la richiesta automatica di risposta-risposta del collegamento.
Ho provato alcune altre API come Ozeki, ma la maggior parte di esse è commerciale o presenta limitazioni nella velocità effettiva (ad esempio, non è possibile inviare più di 3 messaggi SMS in un secondo).
C'è un'API chiamata SMSLib, è davvero fantastica. http://smslib.org/
Ora hai molti provider Saas che possono offrirti questo servizio usando le loro API
Es: mailchimp, esendex, Twilio, ...
Per prima cosa devi impostare Java Comm Api
Questo articolo descrive in dettaglio come impostare l'API di comunicazione
Successivamente è necessario un modem GSM (preferibilmente modulo sim900)
Preferibile l'ultima versione di Java JDK
Guida ai comandi AT
campione del pacchetto;
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");
}
}
}Puoi usare Nexmo per inviare SMS e ricevere SMS .
L'invio di SMS con la libreria Java Nexmo è abbastanza semplice. Dopo aver creato un nuovo account , noleggiato un numero virtuale e ottenuto la chiave API e il segreto, puoi utilizzare la libreria per inviare SMS in questo modo:
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);
}
}
}Per ricevere SMS devi configurare un server che utilizza un webhook. Anche questo è abbastanza semplice. Consiglio di consultare il nostro tutorial sulla ricezione di SMS con Java .
Divulgazione: lavoro per Nexmo
TextMarks ti dà accesso al suo shortcode condiviso per inviare e ricevere messaggi di testo dalla tua app tramite la loro API. I messaggi provengono da / a 41411 (anziché ad es. Un numero di telefono casuale e, diversamente dai gateway di posta elettronica, hai a disposizione 160 caratteri completi).
Puoi anche dire alle persone di scrivere un testo nelle tue parole chiave a 41411 per invocare varie funzionalità nella tua app. C'è un client API JAVA insieme a molte altre lingue popolari e documentazione e supporto tecnico molto completi.
La versione di prova gratuita di 14 giorni può essere facilmente estesa per gli sviluppatori che lo stanno ancora testando e costruendo le loro app.
Dai un'occhiata qui: Info API TextMarks
È possibile LOGICA SMPP API Java per l'invio e la ricezione di SMS nell'applicazione Java. LOGICA SMPP è un'API ben collaudata nell'applicazione delle telecomunicazioni. L'API Logica fornisce anche la capacità di segnalazione sulla connessione TCP / IP.
È possibile integrare direttamente con vari operatori di telecomunicazioni in tutto il mondo.
Ci sono due modi: Primo: usa un gateway API SMS che devi pagare, forse trovi qualche versione di prova anche gratuita ma è scarsa. Secondo: utilizzare il comando AT con un modem GSM collegato al laptop. È tutto
Dipende da come lavorerai e da chi è il tuo fornitore.
Se lavori con una società sms-gateway probabilmente lavorerai attraverso il protocollo SMPP (3.4 è ancora il più comune), quindi dai un'occhiata a OpenSMPP e jSMPP. Queste sono potenti librerie per lavorare con SMPP.
Se hai intenzione di lavorare con il tuo hardware (ad esempio un modem gsm) il modo più semplice per inviare messaggi è attraverso i comandi AT, differiscono a seconda del modello, quindi dovresti scoprire quali comandi AT sono supportati dal tuo modem . Successivamente, se il modem ha un IP e aperto alla connessione, è possibile inviare comandi tramite socket 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();Altrimenti lavorerai attraverso una porta COM, ma il metodo è lo stesso (invio di comandi AT), puoi trovare maggiori informazioni su come lavorare con le porte seriali qui .
Suggerisco una soluzione basata su cloud come Twilio. Le soluzioni basate su cloud sono convenienti, rispetto a una soluzione interna in quanto non è necessaria alcuna manutenzione continua. Gli SMS tramite e-mail non sono una soluzione elegante, in quanto è necessario ottenere le informazioni sul corriere dall'utente e non si può mai essere sicuri di poter inviare messaggi a tutti i numeri di cellulare. Sto usando twilio java api nella mia applicazione web, per inviare sms dal lato server. in pochi minuti puoi integrarti con la tua app.
https://www.twilio.com/docs/java/install
Ecco un esempio di invio di un messaggio SMS dai documenti:
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 è molto utile per questo scopo, puoi connettere un modem con il tuo PC e usare questa lib per inviare sms. Funziona, l'ho usato
Adoriamo anche Java in Wavecell , ma a questa domanda è possibile rispondere senza dettagli specifici della lingua poiché abbiamo un'API REST che coprirà la maggior parte delle tue esigenze:
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!" }'Guarda queste domande se hai problemi con l'invio di richieste HTTP in Java:
Per casi specifici puoi anche prendere in considerazione l'uso dell'API SMPP e la libreria JSMPP già menzionata ti aiuterà.
Per questo puoi usare Twilio . Ma se stai cercando qualche soluzione complicata, puoi seguire la soluzione che ho menzionato di seguito.
Questo non è possibile per ricevere sms. Ma questo è un metodo complicato che puoi usare per inviare sms al numero di client. Puoi usare l'API di twitter. Possiamo seguire l'account twitter dal nostro telefono cellulare con un sms. Non ci resta che inviare sms a twitter. Immagina di creare un account Twitter con il nome utente di @username. Quindi possiamo inviare sms a 40404 come mostrato di seguito.
follow @username
Quindi iniziamo a ricevere tweet che sono twittati in quell'account.
Quindi, dopo aver creato un account Twitter, possiamo utilizzare l'API Twitter per pubblicare tweet da tale account. Quindi tutti i clienti che hanno seguito quell'account, come ho detto prima, iniziano a ricevere tweet.
Puoi imparare come pubblicare tweet con l'API di Twitter dal seguente link.
Prima di iniziare a sviluppare devi ottenere l'autorizzazione per utilizzare twitter api. Puoi accedere a twitter api dal seguente link.
Console per gli sviluppatori di Twitter
Questa non è la soluzione migliore per il tuo problema, ma spero che questo aiuto.
È possibile utilizzare i comandi AT & T per l'invio di sms tramite modem GSM.