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 API

Níž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.

More information