Jak posílat SMS přes SMPP API pomocí Javy
Short Message Peer-to-Peer (SMPP) API je výkonný telekomunikační protokol určený pro výměnu SMS zpráv mezi centry krátkých zpráv (SMSC) a externími entitami pro zasílání zpráv (ESME). Využitím Javy a SMPP API mohou vývojáři vytvářet robustní aplikace pro efektivní odesílání a přijímání SMS zpráv. Tento komplexní průvodce vás provede procesem implementace SMPP API v Javě pro připojení k Ozeki SMS Gateway, včetně praktických příkladů kódu pro správu připojení, odesílání zpráv a zpracování doručovacích zpráv.
Proč používat Javu a SMPP API pro zasílání SMS?
Java je univerzální, platformně nezávislý programovací jazyk široce používaný pro
vývoj podnikových aplikací. V kombinaci se SMPP API
umožňuje Java vývojářům vytvářet škálovatelná SMS řešení, která se bezproblémově
integrují s SMS bránami, jako je Ozeki. SMPP protokol je ideální pro aplikace
s vysokou propustností díky své spolehlivosti, podpoře hromadného zasílání
a možnosti sledování doručení. Tento průvodce používá knihovnu jSMPP,
čistou implementaci SMPP protokolu v Javě, která zjednodušuje vývoj.
Nastavení SMPP API klienta v Javě pro odesílání SMS
Chcete-li začít odesílat SMS zprávy pomocí SMPP API v Javě,
musíte vytvořit uživatelský účet SMPP na
SMPP serveru Ozeki SMS Gateway a nakonfigurovat
vaši Java aplikaci pro připojení k tomuto serveru. Knihovna jSMPP
je oblíbenou volbou mezi vývojáři v Javě díky komplexní podpoře funkcí SMPP protokolu.
Níže popisujeme kroky pro nastavení vašeho projektu v Javě.
Krok 1: Přidání závislosti jSMPP
Chcete-li použít knihovnu jSMPP ve vašem projektu v Javě, přidejte
následující závislost Maven do vašeho souboru pom.xml:
<dependency>
<groupId>org.jsmpp</groupId>
<artifactId>jsmpp</artifactId>
<version>2.3.10</version>
</dependency>
Tato závislost poskytuje všechny potřebné třídy pro implementaci SMPP API v Javě, včetně správy relací, kódování zpráv a zpracování potvrzení o doručení.
Krok 2: Základní příklad připojení SMPP
Připojení k SMPP serveru vyžaduje vytvoření relace a její navázání na
Ozeki SMS Gateway. Následující kód v Javě ukazuje, jak vytvořit jednoduchého
SMPP klienta pomocí knihovny jSMPP:
import org.jsmpp.*;
import org.jsmpp.bean.*;
import org.jsmpp.session.*;
public class SimpleSMPPClient {
public static void main(String[] args) {
SMPPSession session = new SMPPSession();
try {
// Připojení a navázání relace s Ozeki SMS Gateway
session.connectAndBind(
"your.ozeki.server",
2775,
new BindParameter(
BindType.BIND_TX,
"your_username",
"your_password",
"cp",
TypeOfNumber.ALPHANUMERIC,
NumberingPlanIndicator.UNKNOWN,
null)
);
System.out.println("Úspěšně připojeno k SMPP serveru");
// Zde přidejte kód pro odesílání zpráv
} catch (Exception e) {
System.err.println("Nepodařilo se připojit a navázat relaci s SMPP serverem: " + e.getMessage());
} finally {
session.unbindAndClose();
}
}
}
V tomto příkladu nahraďte your.ozeki.server, your_username
a your_password skutečnými přihlašovacími údaji poskytnutými vaším
správcem Ozeki SMS Gateway. BindType.BIND_TX označuje vazbu vysílače,
vhodnou pro odesílání SMS zpráv.
Správa připojení SMPP API v Javě pro spolehlivé doručení SMS
Spolehlivé doručení SMS vyžaduje udržování aktivního SMPP připojení. SMPP protokol používá keep-alive zprávy (enquire_link PDUs) k zajištění, že připojení zůstává aktivní. Níže je příklad, jak nakonfigurovat nastavení keep-alive a sledovat změny stavu relace v Javě:
session.setEnquireLinkTimer(30000); // Odesílání keep-alive každých 30 sekund
session.setTransactionTimer(10000); // Nastavení časového limitu transakce na 10 sekund
// Přidání posluchače změn stavu relace pro monitorování
session.addSessionStateListener(new SessionStateListener() {
@Override
public void onStateChange(SessionState newState, SessionState oldState, Session source) {
System.out.println("Stav SMPP relace se změnil z " + oldState + " na " + newState);
}
});
Tato nastavení zajišťují stabilitu připojení a posluchač stavu relace pomáhá sledovat změny, jako jsou odpojení, pro robustní zpracování chyb.
Odesílání SMS pomocí Java přes SMPP API
Po připojení můžete odesílat SMS zprávy pomocí PDU submit_sm.
Následující Java metoda ukazuje, jak odeslat SMS pomocí SMPP
API v Javě:
public static void sendSMS(SMPPSession session, String sender, String recipient, String message) throws Exception {
try {
String messageId = session.submitShortMessage(
"CMT", // Typ služby
TypeOfNumber.ALPHANUMERIC, // Zdrojový TON
NumberingPlanIndicator.UNKNOWN, // Zdrojový NPI
sender, // Adresa odesílatele
TypeOfNumber.INTERNATIONAL, // Cílový TON
NumberingPlanIndicator.ISDN, // Cílový NPI
recipient, // Adresa příjemce
new ESMClass(), // Třída ESM
(byte)0, // ID protokolu
(byte)1, // Příznak priority
null, // Čas doručení
null, // Platnost
new RegisteredDelivery(SMSCDeliveryReceipt.SUCCESS_FAILURE), // Potvrzení doručení
(byte)0, // Příznak nahrazení
new GeneralDataCoding(Alphabet.ALPHA_DEFAULT), // Kódování dat
(byte)0, // Výchozí ID zprávy
message.getBytes() // Obsah zprávy
);
System.out.println("SMS odeslána s ID zprávy: " + messageId);
} catch (PDUException e) {
System.err.println("Neplatný parametr PDU: " + e.getMessage());
throw e;
} catch (ResponseTimeoutException e) {
System.err.println("Časový limit odpovědi: " + e.getMessage());
throw e;
} catch (InvalidResponseException e) {
System.err.println("Neplatná odpověď: " + e.getMessage());
throw e;
} catch (NegativeResponseException e) {
System.err.println("Obdržena negativní odpověď: " + e.getMessage());
throw e;
} catch (Exception e) {
System.err.println("Nepodařilo se odeslat SMS: " + e.getMessage());
throw e;
}
}
Tato metoda odesílá SMS s povoleným sledováním doručení. Parametr
RegisteredDelivery zajišťuje, že obdržíte oznámení
o stavu doručení zprávy.
Zpracování hlášení o doručení SMS pomocí Java a SMPP API
Pro sledování úspěšného doručení SMS můžete svou SMPP relaci navázat
jako transceiver (BindType.BIND_TRX) a implementovat naslouchací
metodu pro příjem zpráv. Níže je příklad, jak zpracovat hlášení o doručení v Javě:
// Navázání jako transceiver pro odesílání a příjem zpráv
BindParameter bindParam = new BindParameter(
BindType.BIND_TRX,
"vaše_uživatelské_jméno",
"vaše_heslo",
"cp",
TypeOfNumber.ALPHANUMERIC,
NumberingPlanIndicator.UNKNOWN,
null
);
// Nastavení naslouchací metody pro hlášení o doručení
session.setMessageReceiverListener(new MessageReceiverListener() {
@Override
public void onAcceptDeliverSm(DeliverSm deliverSm) {
if (MessageType.SMSC_DEL_RECEIPT.containedIn(deliverSm.getEsmClass())) {
DeliveryReceipt delReceipt = deliverSm.getShortMessageAsDeliveryReceipt();
System.out.println(String.format(
"Obdrženo hlášení o doručení pro zprávu %s: %s",
delReceipt.getId(),
delReceipt.getFinalStatus()
));
}
// Odpověď na hlášení o doručení
try {
byte[] messageId = new byte[]{1};
session.deliverSmResponse(0, messageId, deliverSm);
} catch (PDUException e) {
System.err.println("Nepodařilo se odpovědět na deliver_sm: " + e.getMessage());
}
}
});
Tento kód zpracovává hlášení o doručení, což vám umožňuje sledovat úspěch nebo selhání každé SMS odeslané přes SMPP API v Javě.
Kompletní Java SMPP klient pro odesílání SMS přes SMPP APINíže je kompletní třída v Javě, která integruje správu připojení, odesílání zpráv a zpracování doručených zpráv. Tato implementace je připravena pro produkční prostředí s řádným zpracováním chyb a správou zdrojů:
import org.jsmpp.*;
import org.jsmpp.bean.*;
import org.jsmpp.session.*;
import org.jsmpp.util.*;
public class SMPPClient implements AutoCloseable {
private SMPPSession session;
private String host;
private int port;
private String username;
private String password;
public SMPPClient(String host, int port, String username, String password) {
this.host = host;
this.port = port;
this.username = username;
this.password = password;
this.session = new SMPPSession();
}
public void connect() throws Exception {
try {
BindParameter bindParam = new BindParameter(
BindType.BIND_TRX,
username,
password,
"cp",
TypeOfNumber.ALPHANUMERIC,
NumberingPlanIndicator.UNKNOWN,
null
);
session.connectAndBind(host, port, bindParam);
// Nastavení parametrů session
session.setEnquireLinkTimer(30000);
session.setTransactionTimer(10000);
// Nastavení obsluhy doručených zpráv
session.setMessageReceiverListener(new DeliveryReceiptListener());
System.out.println("Úspěšně připojeno k SMPP serveru");
} catch (Exception e) {
System.err.println("Nepodařilo se připojit k SMPP serveru: " + e.getMessage());
throw e;
}
}
public String sendSMS(String sender, String recipient, String message) throws Exception {
try {
return session.submitShortMessage(
"CMT",
TypeOfNumber.ALPHANUMERIC,
NumberingPlanIndicator.UNKNOWN,
sender,
TypeOfNumber.INTERNATIONAL,
NumberingPlanIndicator.ISDN,
recipient,
new ESMClass(),
(byte)0,
(byte)1,
null,
null,
new RegisteredDelivery(SMSCDeliveryReceipt.SUCCESS_FAILURE),
(byte)0,
new GeneralDataCoding(Alphabet.ALPHA_DEFAULT),
(byte)0,
message.getBytes()
);
} catch (Exception e) {
System.err.println("Nepodařilo se odeslat SMS: " + e.getMessage());
throw e;
}
}
@Override
public void close() {
if (session != null) {
session.unbindAndClose();
}
}
private static class DeliveryReceiptListener implements MessageReceiverListener {
@Override
public void onAcceptDeliverSm(DeliverSm deliverSm) {
if (MessageType.SMSC_DEL_RECEIPT.containedIn(deliverSm.getEsmClass())) {
DeliveryReceipt delReceipt = deliverSm.getShortMessageAsDeliveryReceipt();
System.out.println(String.format(
"Přijata doručenka pro zprávu %s: %s",
delReceipt.getId(),
delReceipt.getFinalStatus()
));
}
}
}
public static void main(String[] args) {
try (SMPPClient client = new SMPPClient(
"your.ozeki.server",
2775,
"your_username",
"your_password")) {
client.connect();
String messageId = client.sendSMS(
"12345",
"+1234567890",
"Ahoj z Java SMPP klienta!"
);
System.out.println("SMS odeslána s ID: " + messageId);
// Udržování aplikace v běhu pro příjem doručenek
System.out.println("Pro ukončení stiskněte Ctrl+C...");
Thread.sleep(Long.MAX_VALUE);
} catch (Exception e) {
System.err.println("Chyba v SMPP klientovi: " + e.getMessage());
}
}
}
Tato kompletní implementace zapouzdřuje funkčnost SMPP klienta do znovupoužitelné
třídy, což usnadňuje integraci do větších Java aplikací. Rozhraní AutoCloseable
zajišťuje správné uvolnění zdrojů.
Doporučené postupy pro vytváření Java SMPP klientů
Pro zajištění robustnosti a škálovatelnosti vašeho Java SMPP API klienta dodržujte tyto doporučené postupy:
- Pooling připojení: Pro aplikace s vysokým objemem SMS používejte pooling připojení pro efektivní správu více SMPP session.
- Zpracování výjimek: Implementujte komplexní zpracování výjimek pro obnovu po síťových problémech nebo chybách serveru.
- Thread pooly: Pro zlepšení výkonu používejte thread pooly pro souběžné zpracování zpráv.
- Fronty zpráv: Implementujte mechanismus front pro zajištění spolehlivého doručení zpráv při výpadcích sítě.
- Monitorování připojení: Sledujte stav SMPP session a implementujte logiku automatického opětovného připojení pro spolehlivost.
- Kódování znaků: Zpracovávejte různá kódování znaků (např. GSM 7-bit, UCS-2) pro podporu mezinárodního zasílání SMS.
Závěr
Implementace SMPP API v Javě s Ozeki SMS Gateway poskytuje výkonné řešení
pro odesílání a přijímání SMS zpráv ve vašich aplikacích. Knihovna jSMPP
zjednodušuje složitosti SMPP protokolu, což vývojářům umožňuje soustředit se na vytváření
robustních funkcí pro zasílání zpráv. Tato příručka pokryla základy nastavení Java SMPP klienta,
správy připojení, odesílání SMS zpráv a zpracování doručenek. Dodržováním uvedených příkladů
a doporučených postupů můžete vytvářet škálovatelné a spolehlivé SMS aplikace pomocí
Javy a SMPP API.
Pro produkční prostředí zvažte přidání pokročilých funkcí, jako je spojování zpráv pro dlouhé SMS, podrobné logování a monitorování výkonu. SMPP protokol nabízí další možnosti, jako je plánované odesílání zpráv a nastavení priority, které mohou vylepšit vaši aplikaci s měnícími se požadavky.