Odbieranie SMS w Javie
Przewodnik na tej stronie ma na celu przedstawienie krótkiego wprowadzenia, jak możesz pobrać odebrane wiadomości z SMS Gateway do swojej aplikacji Java. Ta operacja jest zademonstrowana za pomocą prostego kodu Java, który wykorzystuje żądania HTTP do zbierania przychodzących wiadomości z SMS Gateway. Jeśli zastosujesz się do tego przewodnika, nauczysz się, jak stworzyć przykładową aplikację Java, która pobiera wiadomości z folderu odbiorczego, a także zobaczysz, jak przetestować rozwiązanie. Więc zaczynajmy.
Czym jest Java SMS API?
Java SMS API umożliwia wdrożenie usług SMS w Twojej aplikacji Java. API komunikuje się z SMS Gateway za pomocą żądań HTTP, które wysyłają wiadomość i zwracają odpowiedź.
Wymagania wstępne
- Zainstalowane Apache NetBeans IDE 12.0
- Zainstalowane Ozeki 10 SMS Gateway
- Skonfigurowane połączenie z serwerem HTTP
- Otwórz Apache NetBeans IDE
- Utwórz nową aplikację Java
- Utwórz nową klasę Java
- Skopiuj i wklej przykładowy kod źródłowy poniżej
- Wpisz 'https://localhost:9515' w przeglądarce, aby otworzyć SMS Gateway
- Wybierz połączenie HTTP Server i otwórz jego formularz HTML
- Wyślij kilka testowych wiadomości
- Uruchom aplikację Java, aby odebrać wiadomości
Przykładowy kod Java do odbierania wiadomości SMS z SMS Gateway jest dostępny za darmo, możesz go modyfikować lub używać w swoim projekcie. Jeśli chcesz tylko przetestować rozwiązanie, postępuj zgodnie z instrukcjami krok po kroku poniżej lub możesz również obejrzeć powyższe wideo, aby dowiedzieć się, jak utworzyć przykładową aplikację Java, która może odbierać wiadomości przychodzące z SMS Gateway.
package ozeki;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.security.GeneralSecurityException;
import java.security.cert.X509Certificate;
import java.util.stream.Collectors;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import javax.xml.parsers.*;
import org.xml.sax.InputSource;
import org.w3c.dom.*;
import java.io.*;
public class ReceiveSMS {
public static void main(String[] args) {
TrustManager[] trustAllCerts = new TrustManager[]{
new X509TrustManager() {
@Override
public java.security.cert.X509Certificate[] getAcceptedIssuers() {
return new X509Certificate[0];
}
@Override
public void checkClientTrusted(
java.security.cert.X509Certificate[] certs, String authType) {
}
@Override
public void checkServerTrusted(
java.security.cert.X509Certificate[] certs, String authType) {
}
}
};
try {
SSLContext sc = SSLContext.getInstance("SSL");
sc.init(null, trustAllCerts, new java.security.SecureRandom());
HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
HostnameVerifier allHostsValid = new HostnameVerifier() {
@Override
public boolean verify(String hostname, SSLSession session) {
return true;
}
};
HttpsURLConnection.setDefaultHostnameVerifier(allHostsValid);
} catch (GeneralSecurityException e) {
System.out.println(e.getMessage());
}
try {
StringBuilder sendString = new StringBuilder();
String username = "john";
String password = "Xc3ffs";
String httpUrl = "https://127.0.0.1:9508/";
String folder = "inbox";
String limit = "3";
sendString.append(httpUrl).append("api?action=receivemessage&username=").
append(username).append("&password=").
append(password).append("&folder=").append(folder).
append("&limit=").append(limit).append("&afterdownload=delete");
System.out.println("Sending request: " + sendString.toString());
URL url = new URL(sendString.toString());
HttpURLConnection con = (HttpURLConnection) url.openConnection();
con.setRequestMethod("GET");
BufferedReader br = null;
System.out.println("Http response received: ");
if (con.getResponseCode() == 200) {
br = new BufferedReader(new InputStreamReader(con.getInputStream()));
String response = br.lines().collect(Collectors.joining("\n"));
response = response.substring(response.indexOf('\n')+1);
response = response.substring(response.indexOf('\n')+1);
DisplayMessages(response);
} else {
br = new BufferedReader(new InputStreamReader(con.getErrorStream()));
String response = br.lines().collect(Collectors.joining("\n"));
System.out.println(response);
}
} catch (IOException ex) {
System.out.println(ex.getMessage());
}
}
static void DisplayMessages(String response) {
try{
DocumentBuilderFactory dbf =
DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
InputSource is = new InputSource();
is.setCharacterStream(new StringReader(response));
Document doc = db.parse(is);
NodeList nodes = doc.getElementsByTagName("message");
for (int i = 0; i < nodes.getLength(); i++) {
Element element = (Element) nodes.item(i);
NodeList originator = element.getElementsByTagName("originator");
Element line = (Element) originator.item(0);
String sender = getCharacterDataFromElement(line);
NodeList messagedata = element.getElementsByTagName("messagedata");
line = (Element) messagedata.item(0);
String text = getCharacterDataFromElement(line);
DisplayMessage(sender, text);
}
} catch (Exception ex) {
System.out.println("The inbox is empty");
}
}
public static void DisplayMessage(String sender, String text) {
System.out.println(sender + ": "+ text);
}
public static String getCharacterDataFromElement(Element e) {
Node child = e.getFirstChild();
if (child instanceof CharacterData) {
CharacterData cd = (CharacterData) child;
return cd.getData();
}
return "?";
}
}
Krok 1 - Otwórz Apache NetBeans IDE
Aby móc stworzyć aplikację w języku Java, potrzebujesz programu, który to umożliwi. Jednym z takich programów jest Apache NetBeans IDE, który można pobrać z sekcji Wymagania wstępne powyżej. Jeśli już masz to IDE, wystarczy je otworzyć z pulpitu, jak widać na Rysunku 1.
Krok 2 - Utwórz nową aplikację Java
Po otwarciu Apache NetBeans IDE pierwszą rzeczą, którą musisz zrobić, jest utworzenie aplikacji Java. W tym celu wybierz opcję 'Nowy projekt...' z paska narzędzi. Po wykonaniu tej czynności pojawi się okno zawierające wszystkie dostępne projekty, które można utworzyć w Apache NetBeans. Tutaj wybierz opcję Aplikacja Java, jak na Rysunku 2, a następnie kliknij 'Dalej'.
Krok 3 - Skonfiguruj aplikację Java
Przed utworzeniem aplikacji Java musisz dokonać kilku konfiguracji. W tym menu należy podać nazwę projektu, można również wybrać lokalizację projektu. Tutaj można również określić nazwę pakietu. Jeśli zakończysz wszystkie konfiguracje, po prostu kliknij 'Zakończ', jak na Rysunku 3.
Krok 4 - Utwórz klasę Java
Po utworzeniu aplikacji Java musisz utworzyć klasę Java, ponieważ na tym etapie nie zawiera ona jeszcze żadnej klasy. W tym celu kliknij prawym przyciskiem myszy na pakiet, wybierz 'Nowy', a następnie, jak pokazuje Rysunek 4, kliknij 'Klasa Java...'. Następnie musisz określić nazwę klasy Java i po zakończeniu kliknij 'Utwórz'.
Krok 5 - Zastąp kod Java z tej strony
Na tym etapie masz już potrzebną aplikację Java, ale nie zawiera ona właściwego kodu. Aby to naprawić, musisz zastąpić oryginalny kod przykładowym kodem z tej strony. Przejdź do przykładowego kodu i skopiuj go do schowka za pomocą skrótu klawiszowego Ctrl+C. Następnie przejdź do utworzonej klasy Java i najpierw usuń kod, który tam znajdziesz. Następnie wciśnij Ctrl+V, aby wkleić przykładowy kod do klasy Java, jak widać na Rysunku 5.
Krok 6 - Wyślij kilka testowych wiadomości
Przed uruchomieniem przykładowej aplikacji Java musisz mieć kilka przychodzących wiadomości, które mogą zostać zebrane przez aplikację. SMS Gateway umożliwia symulację przychodzących wiadomości, dzięki czemu możesz przetestować swoje rozwiązanie. W tym celu otwórz SMS Gateway i wybierz połączenie HTTP Server. Jeśli nie masz połączenia HTTP Server, sprawdź jak utworzyć połączenie HTTP Server. Tutaj otwórz formularz HTML tego połączenia i, jak na Rysunku 6, wyślij kilka testowych wiadomości.
Krok 7 - Uruchom aplikację Java
Ostatnim krokiem tego przewodnika jest uruchomienie aplikacji Java. To prosta operacja; wystarczy kliknąć przycisk 'Uruchom' w Apache NetBeans, jak na Rysunku 7. Ta czynność uruchamia przykładowy kod Java, który drukuje żądanie HTTP wysłane do SMS Gateway, a następnie drukuje również odpowiedź z SMS Gateway, która zawiera wszystkie przychodzące wiadomości.
Podsumowanie
Ten przewodnik, który właśnie przeczytałeś, dostarcza informacji o tym, jak odbierać wiadomości SMS z SMS Gateway za pomocą aplikacji Java. Korzystając z naszego Java SMS API, możesz wykorzystać zasoby języka Java i użyć go do kontrolowania SMS Gateway. Java API w połączeniu z Ozeki SMS Gateway stworzy potężny system wysyłania SMS, zdolny wysłać do 1000 SMS na sekundę.
Jeśli chcesz dowiedzieć się więcej o zaletach innych podobnych rozwiązań API, odwiedź naszą stronę o zarządzaniu ruchem SMS za pomocą Pythona.
Jeśli potrzebujesz przekazywania wiadomości e-mail na SMS i jeszcze tego nie zrobiłeś, pobierz Ozeki SMS Gateway teraz i skonfiguruj to rozwiązanie!