Hogyan küldjünk SMS-t az SMPP API segítségével Java nyelven

A Short Message Peer-to-Peer (SMPP) API egy hatékony távközlési protokoll, amelyet SMS-üzenetek cseréjére terveztek Short Message Service Center-ek (SMSC) és External Short Messaging Entity-k (ESME) között. A Java és az SMPP API kombinálásával a fejlesztők robusztus alkalmazásokat építhetnek SMS-üzenetek hatékony küldésére és fogadására. Ez az átfogó útmutató végigvezeti az SMPP API Java-ban történő implementálásán, hogy kapcsolódj az Ozeki SMS Gateway-hez, gyakorlati kódpéldákkal a kapcsolatkezelésről, üzenetküldésről és kézbesítési jelentések kezeléséről.

Miért érdemes Java-t és az SMPP API-t használni SMS küldéshez?

A Java egy sokoldalú, platformfüggetlen programozási nyelv, amelyet széles körben használnak vállalati szintű alkalmazások fejlesztéséhez. Az SMPP API-val kombinálva a Java lehetővé teszi a fejlesztők számára, hogy skálázható SMS megoldásokat hozzanak létre, amelyek zökkenőmentesen integrálódnak az Ozekihez hasonló SMS gateway-ekkel. Az SMPP protokoll ideális nagy teljesítményű SMS alkalmazásokhoz, megbízhatósága, tömeges üzenetküldés támogatása és kézbesítési nyomkövetési képességei miatt. Ez az útmutató a jSMPP könyvtárat használja, egy tiszta Java implementációt az SMPP protokollhoz, hogy egyszerűsítse a fejlesztést.

Java SMPP API kliens beállítása SMS üzenetek küldéséhez

Ahhoz, hogy SMS üzeneteket küldhess az SMPP API Java-ban, létre kell hoznod egy SMPP felhasználói fiókot az Ozeki SMS Gateway SMPP szerverén, és konfigurálnod kell a Java alkalmazásodat, hogy kapcsolódjon az SMPP szerveréhez. A jSMPP könyvtár népszerű választás a Java fejlesztők körében, mivel átfogó támogatást nyújt az SMPP protokoll funkcióihoz. Az alábbiakban áttekintjük a Java projekt beállításának lépéseit.

1. lépés: jSMPP függőség hozzáadása

A jSMPP könyvtár használatához a Java projektben add hozzá a következő Maven függőséget a pom.xml fájlhoz: 

<dependency>
    <groupId>org.jsmpp</groupId>
    <artifactId>jsmpp</artifactId>
    <version>2.3.10</version>
</dependency>

Ez a függőség biztosítja az összes szükséges osztályt az SMPP API Java-ban történő implementálásához, beleértve a munkamenet-kezelést, üzenetkódolást és kézbesítési visszaigazolások kezelését.

2. lépés: Alap SMPP kapcsolat példa

Az SMPP szerverhez való kapcsolódáshoz létre kell hozni egy munkamenetet és kötni kell azt az Ozeki SMS Gateway-hez. A következő Java kód bemutatja, hogyan hozzunk létre egy egyszerű SMPP klienst a jSMPP könyvtár segítségével: 

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 {
            // Kapcsolódás és kötés az Ozeki SMS Gateway-hez
            session.connectAndBind(
                "your.ozeki.server", 
                2775, 
                new BindParameter(
                    BindType.BIND_TX, 
                    "your_username", 
                    "your_password", 
                    "cp", 
                    TypeOfNumber.ALPHANUMERIC, 
                    NumberingPlanIndicator.UNKNOWN, 
                    null)
            );
            
            System.out.println("Sikeresen kapcsolódott az SMPP szerverhez");
            
            // Üzenetküldő kód hozzáadása itt
            
        } catch (Exception e) {
            System.err.println("Nem sikerült kapcsolódni és kötni az SMPP szerverhez: " + e.getMessage());
        } finally {
            session.unbindAndClose();
        }
    }
}

Ebben a példában cseréld le a your.ozeki.server, your_username, és your_password értékeket az Ozeki SMS Gateway adminisztrátor által biztosított valós hitelesítő adatokra. A BindType.BIND_TX egy adó kötést jelez, amely alkalmas SMS üzenetek küldésére.

SMPP API kapcsolatok kezelése Java-ban megbízható SMS kézbesítés érdekében

A megbízható SMS kézbesítéshez aktív SMPP kapcsolatot kell fenntartani. Az SMPP protokoll keep-alive üzeneteket (enquire_link PDU-kat) használ a kapcsolat aktív maradásának biztosítására. Az alábbi példa bemutatja, hogyan konfigurálhatod a keep-alive beállításokat és figyelheted a munkamenet állapotváltozásait Java-ban: 

session.setEnquireLinkTimer(30000); // Keep-alive küldése 30 másodpercenként
session.setTransactionTimer(10000); // Tranzakció időtúllépés beállítása 10 másodpercre

// Munkamenet állapotfigyelő hozzáadása monitorozáshoz
session.addSessionStateListener(new SessionStateListener() {
    @Override
    public void onStateChange(SessionState newState, SessionState oldState, Session source) {
        System.out.println("SMPP munkamenet állapota megváltozott " + oldState + " -ról " + newState + " -ra");
    }
});

Ezek a beállítások biztosítják a kapcsolat stabilitását, és a munkamenet állapotfigyelő segít nyomon követni a változásokat, például a kapcsolat megszakadását, a robusztus hibakezelés érdekében.

SMS küldése Java nyelven az SMPP API segítségével

A kapcsolat létrejötte után SMS üzeneteket küldhetsz a submit_sm PDU segítségével. A következő Java metódus bemutatja, hogyan küldj SMS-t az SMPP API Java-ban: 

public static void sendSMS(SMPPSession session, String sender, String recipient, String message) throws Exception {
    try {
        String messageId = session.submitShortMessage(
            "CMT", // Szolgáltatás típusa
            TypeOfNumber.ALPHANUMERIC, // Forrás TON
            NumberingPlanIndicator.UNKNOWN, // Forrás NPI
            sender, // Küldő címe
            TypeOfNumber.INTERNATIONAL, // Cél TON
            NumberingPlanIndicator.ISDN, // Cél NPI
            recipient, // Címzett címe
            new ESMClass(), // ESM osztály
            (byte)0, // Protokoll ID
            (byte)1, // Prioritás jelző
            null, // Ütemezett kézbesítési idő
            null, // Érvényességi idő
            new RegisteredDelivery(SMSCDeliveryReceipt.SUCCESS_FAILURE), // Kézbesítési visszaigazolás
            (byte)0, // Cserélje ki, ha jelen van jelző
            new GeneralDataCoding(Alphabet.ALPHA_DEFAULT), // Adatkódolás
            (byte)0, // Alapértelmezett üzenet ID
            message.getBytes() // Üzenet tartalma
        );
        
        System.out.println("SMS elküldve, üzenet azonosító: " + messageId);
    } catch (PDUException e) {
        System.err.println("Érvénytelen PDU paraméter: " + e.getMessage());
        throw e;
    } catch (ResponseTimeoutException e) {
        System.err.println("Válasz időtúllépés: " + e.getMessage());
        throw e;
    } catch (InvalidResponseException e) {
        System.err.println("Érvénytelen válasz: " + e.getMessage());
        throw e;
    } catch (NegativeResponseException e) {
        System.err.println("Negatív válasz érkezett: " + e.getMessage());
        throw e;
    } catch (Exception e) {
        System.err.println("Nem sikerült SMS-t küldeni: " + e.getMessage());
        throw e;
    }
}

Ez a metódus egy SMS-t küld kézbesítési visszaigazolás követéssel. A RegisteredDelivery paraméter biztosítja, hogy értesítéseket kapj az üzenet kézbesítési állapotáról.

SMS kézbesítési jelentések kezelése Java-ban és az SMPP API segítségével

Ahhoz, hogy nyomon kövesd, hogy egy SMS sikeresen kézbesítésre került-e, kötheted az SMPP munkamenetedet transceiver-ként (BindType.BIND_TRX) és implementálhatsz egy üzenet fogadó figyelőt. Az alábbi példa bemutatja, hogyan kezelheted a kézbesítési jelentéseket Java-ban: 

// Transceiver-ként kötés üzenetek küldéséhez és fogadásához
BindParameter bindParam = new BindParameter(
    BindType.BIND_TRX,
    "your_username",
    "your_password",
    "cp",
    TypeOfNumber.ALPHANUMERIC,
    NumberingPlanIndicator.UNKNOWN,
    null
);

// Üzenet fogadó figyelő beállítása kézbesítési jelentésekhez
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(
                "Kézbesítési visszaigazolás érkezett a(z) %s azonosítójú üzenethez: %s",
                delReceipt.getId(),
                delReceipt.getFinalStatus()
            ));
        }
        
        // Válasz a kézbesítési jelentésre
        try {
            byte[] messageId = new byte[]{1};
            session.deliverSmResponse(0, messageId, deliverSm);
        } catch (PDUException e) {
            System.err.println("Nem sikerült válaszolni a deliver_sm-re: " + e.getMessage());
        }
    }
});

Ez a kód feldolgozza a kézbesítési visszaigazolásokat, lehetővé téve, hogy nyomon kövesd az egyes SMS üzenetek sikerességét vagy hibáját az SMPP API Java-ban történő küldés során.

Teljes Java SMPP kliens SMS küldéshez az SMPP API segítségével

Az alábbiakban egy teljes Java osztály látható, amely integrálja a kapcsolatkezelést, üzenetküldést, és kézbesítési jelentések kezelését. Ez az implementáció termelési környezetben használható megfelelő hibakezeléssel és erőforrás-kezeléssel: 

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);
            
            // Munkamenet beállítások konfigurálása
            session.setEnquireLinkTimer(30000);
            session.setTransactionTimer(10000);
            
            // Kézbesítési visszaigazolás kezelő beállítása
            session.setMessageReceiverListener(new DeliveryReceiptListener());
            
            System.out.println("Sikeresen kapcsolódott az SMPP szerverhez");
        } catch (Exception e) {
            System.err.println("Nem sikerült kapcsolódni az SMPP szerverhez: " + 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("Nem sikerült SMS-t küldeni: " + 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(
                    "Kézbesítési visszaigazolás érkezett a(z) %s azonosítójú üzenethez: %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", 
                "Helló a Java SMPP klienstől!"
            );
            
            System.out.println("SMS elküldve, azonosító: " + messageId);
            
            // Alkalmazás futása a kézbesítési jelentések fogadásához
            System.out.println("Nyomj Ctrl+C-t a kilépéshez...");
            Thread.sleep(Long.MAX_VALUE);
            
        } catch (Exception e) {
            System.err.println("Hiba az SMPP kliensben: " + e.getMessage());
        }
    }
}

Ez a teljes implementáció az SMPP kliens funkcionalitását egy újrafelhasználható osztályba csomagolja, megkönnyítve a nagyobb Java alkalmazásokba való integrálást. Az AutoCloseable interfész biztosítja a megfelelő erőforrás-felszabadítást.

Ajánlott eljárások Java SMPP kliensek fejlesztéséhez

Annak érdekében, hogy a Java SMPP API kliens robusztus és skálázható legyen, kövesd az alábbi ajánlott eljárásokat:

  • Kapcsolatkészlet: Használj kapcsolatkészletet nagy mennyiségű SMS alkalmazásokhoz az SMPP munkamenetek hatékony kezeléséhez.
  • Kivételkezelés: Implementálj átfogó kivételkezelést a hálózati problémák vagy szerverhibák kezeléséhez.
  • Szálkészlet: Használj szálkészletet párhuzamos üzenetfeldolgozáshoz a teljesítmény javítása érdekében.
  • Üzenetsor: Implementálj egy üzenetsoroló mechanizmust a megbízható üzenetkézbesítés érdekében hálózati megszakadások esetén.
  • Kapcsolatmonitorozás: Figyeld az SMPP munkamenet állapotát és implementálj automatikus újrakapcsolódási logikát a megbízhatóság érdekében.
  • Karakterkódolás: Kezeld a különböző karakterkódolásokat (pl. GSM 7-bit, UCS-2) a nemzetközi SMS üzenetküldés támogatásához.

Összegzés

Az SMPP API Java-ban történő implementálása az Ozeki SMS Gateway segítségével hatékony megoldást nyújt SMS üzenetek küldésére és fogadására az alkalmazásaidban. A jSMPP könyvtár leegyszerűsíti az SMPP protokoll bonyolultságát, lehetővé téve a fejlesztők számára, hogy a robusztus üzenetküldési funkciókra koncentráljanak. Ez az útmutató bemutatta a Java SMPP kliens beállításának alapjait, a kapcsolatkezelést, SMS üzenetek küldését és a kézbesítési jelentések kezelését. A megadott példák és ajánlott eljárások követésével skálázható és megbízható SMS alkalmazásokat hozhatsz létre Java és az SMPP API segítségével.

Termelési környezetekben érdemes lehet fejlett funkciókat hozzáadni, mint például hosszú SMS-ek összefűzése, részletes naplózás, és teljesítményfigyelés. Az SMPP protokoll további képességeket kínál, mint például ütemezett üzenetküldés és prioritási beállítások, hogy tovább fejleszthesd az alkalmazásodat az igények változásával.

More information