Wie man SMS über die SMPP-API mit Java versendet

Die Short Message Peer-to-Peer (SMPP) API ist ein leistungsstarkes Telekommunikationsprotokoll, das für den Austausch von SMS-Nachrichten zwischen Short Message Service Centers (SMSCs) und External Short Messaging Entities (ESMEs) entwickelt wurde. Durch die Nutzung von Java und der SMPP-API können Entwickler robuste Anwendungen erstellen, um SMS-Nachrichten effizient zu senden und zu empfangen. Diese umfassende Anleitung führt Sie durch den Prozess der Implementierung der SMPP-API in Java zur Verbindung mit dem Ozeki SMS Gateway, ergänzt durch praktische Codebeispiele für Verbindungsmanagement, Nachrichtenversand und die Handhabung von Zustellberichten.

Warum Java und die SMPP-API für SMS-Nachrichten verwenden?

Java ist eine vielseitige, plattformunabhängige Programmiersprache, die häufig für die Entwicklung von unternehmensfähigen Anwendungen verwendet wird. In Kombination mit der SMPP-API ermöglicht Java Entwicklern die Erstellung skalierbarer SMS-Lösungen, die nahtlos mit SMS-Gateways wie Ozeki integriert werden können. Das SMPP-Protokoll ist ideal für Hochdurchsatz-SMS- Anwendungen aufgrund seiner Zuverlässigkeit, Unterstützung für Massennachrichten und Zustellverfolgungsfunktionen. Diese Anleitung verwendet die jSMPP-Bibliothek, eine reine Java-Implementierung des SMPP-Protokolls, um die Entwicklung zu vereinfachen.

Einrichtung eines Java-SMPP-API-Clients zum Versenden von SMS-Nachrichten

Um mit der SMPP-API in Java SMS-Nachrichten zu versenden, müssen Sie ein SMPP-Benutzerkonto auf dem SMPP-Server des Ozeki SMS Gateways einrichten und Ihre Java-Anwendung für die Verbindung mit dessen SMPP-Server konfigurieren. Die jSMPP-Bibliothek ist eine beliebte Wahl für Java-Entwickler aufgrund ihrer umfassenden Unterstützung für SMPP-Protokollfunktionen. Nachfolgend skizzieren wir die Schritte zur Einrichtung Ihres Java-Projekts.

Schritt 1: jSMPP-Abhängigkeit hinzufügen

Um die jSMPP-Bibliothek in Ihrem Java-Projekt zu verwenden, fügen Sie die folgende Maven-Abhängigkeit in Ihre pom.xml-Datei ein:

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

Diese Abhängigkeit stellt alle notwendigen Klassen zur Implementierung der SMPP-API in Java bereit, einschließlich Sitzungsmanagement, Nachrichtencodierung und Handhabung von Zustellbestätigungen.

Schritt 2: Grundlegendes SMPP-Verbindungsbeispiel

Die Verbindung zu einem SMPP-Server erfordert die Herstellung einer Sitzung und deren Bindung an das Ozeki SMS Gateway. Der folgende Java-Code demonstriert, wie Sie einen einfachen SMPP-Client mit der jSMPP-Bibliothek erstellen:

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 {
            // Verbindung herstellen und an das Ozeki SMS Gateway binden
            session.connectAndBind(
                "your.ozeki.server", 
                2775, 
                new BindParameter(
                    BindType.BIND_TX, 
                    "your_username", 
                    "your_password", 
                    "cp", 
                    TypeOfNumber.ALPHANUMERIC, 
                    NumberingPlanIndicator.UNKNOWN, 
                    null)
            );
            
            System.out.println("Erfolgreich mit dem SMPP-Server verbunden");
            
            // Hier Code zum Versenden von Nachrichten einfügen
            
        } catch (Exception e) {
            System.err.println("Verbindung und Bindung an den SMPP-Server fehlgeschlagen: " + e.getMessage());
        } finally {
            session.unbindAndClose();
        }
    }
}

Ersetzen Sie in diesem Beispiel your.ozeki.server, your_username und your_password durch die tatsächlichen Anmeldedaten, die Ihnen von Ihrem Ozeki- SMS-Gateway-Administrator bereitgestellt wurden. Der BindType.BIND_TX gibt eine Senderbindung an, die für das Versenden von SMS-Nachrichten geeignet ist.

Verwaltung von SMPP-API-Verbindungen in Java für zuverlässige SMS-Zustellung

Eine zuverlässige SMS-Zustellung erfordert die Aufrechterhaltung einer aktiven SMPP-Verbindung. Das SMPP- Protokoll verwendet Keep-Alive-Nachrichten (enquire_link PDUs), um sicherzustellen, dass die Verbindung aktiv bleibt. Nachfolgend finden Sie ein Beispiel, wie Sie Keep-Alive-Einstellungen konfigurieren und Sitzungszustandsänderungen in Java überwachen können:

session.setEnquireLinkTimer(30000); // Keep-Alive alle 30 Sekunden senden
session.setTransactionTimer(10000); // Transaktions-Timeout auf 10 Sekunden setzen

// Sitzungszustands-Listener zur Überwachung hinzufügen
session.addSessionStateListener(new SessionStateListener() {
    @Override
    public void onStateChange(SessionState newState, SessionState oldState, Session source) {
        System.out.println("SMPP-Sitzungszustand von " + oldState + " zu " + newState + " geändert");
    }
});

Diese Einstellungen stellen sicher, dass die Verbindung stabil bleibt, und der Sitzungszustands-Listener hilft Ihnen, Änderungen wie Unterbrechungen für eine robuste Fehlerbehandlung zu überwachen.

SMS-Versand mit Java über die SMPP-API

Nach erfolgreicher Verbindung können Sie SMS-Nachrichten mit dem submit_sm-PDU versenden. Die folgende Java-Methode zeigt, wie Sie eine SMS mit der SMPP-API in Java senden:

public static void sendSMS(SMPPSession session, String sender, String recipient, String message) throws Exception {
    try {
        String messageId = session.submitShortMessage(
            "CMT", // Service-Typ
            TypeOfNumber.ALPHANUMERIC, // Quell-TON
            NumberingPlanIndicator.UNKNOWN, // Quell-NPI
            sender, // Absenderadresse
            TypeOfNumber.INTERNATIONAL, // Ziel-TON
            NumberingPlanIndicator.ISDN, // Ziel-NPI
            recipient, // Empfängeradresse
            new ESMClass(), // ESM-Klasse
            (byte)0, // Protokoll-ID
            (byte)1, // Prioritätsflag
            null, // Geplante Lieferzeit
            null, // Gültigkeitsdauer
            new RegisteredDelivery(SMSCDeliveryReceipt.SUCCESS_FAILURE), // Zustellbestätigung
            (byte)0, // Ersetzen-wenn-vorhanden-Flag
            new GeneralDataCoding(Alphabet.ALPHA_DEFAULT), // Datenkodierung
            (byte)0, // Standard-Nachrichten-ID
            message.getBytes() // Nachrichteninhalt
        );
        
        System.out.println("SMS wurde mit Nachrichten-ID gesendet: " + messageId);
    } catch (PDUException e) {
        System.err.println("Ungültiger PDU-Parameter: " + e.getMessage());
        throw e;
    } catch (ResponseTimeoutException e) {
        System.err.println("Antwort-Timeout: " + e.getMessage());
        throw e;
    } catch (InvalidResponseException e) {
        System.err.println("Ungültige Antwort: " + e.getMessage());
        throw e;
    } catch (NegativeResponseException e) {
        System.err.println("Negative Antwort erhalten: " + e.getMessage());
        throw e;
    } catch (Exception e) {
        System.err.println("SMS-Versand fehlgeschlagen: " + e.getMessage());
        throw e;
    }
}

Diese Methode sendet eine SMS mit aktivierter Zustellbestätigung. Der RegisteredDelivery-Parameter stellt sicher, dass Sie Benachrichtigungen über den Zustellstatus der Nachricht erhalten.

Verarbeitung von SMS-Zustellberichten mit Java und der SMPP-API

Um zu verfolgen, ob eine SMS erfolgreich zugestellt wurde, können Sie Ihre SMPP-Sitzung als Transceiver binden (BindType.BIND_TRX) und einen Nachrichtenempfänger-Listener implementieren. Hier ist ein Beispiel, wie Sie Zustellberichte in Java verarbeiten:

// Als Transceiver binden, um Nachrichten zu senden und zu empfangen
BindParameter bindParam = new BindParameter(
    BindType.BIND_TRX,
    "your_username",
    "your_password",
    "cp",
    TypeOfNumber.ALPHANUMERIC,
    NumberingPlanIndicator.UNKNOWN,
    null
);

// Nachrichtenempfänger-Listener für Zustellberichte setzen
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(
                "Zustellbestätigung für Nachricht %s erhalten: %s",
                delReceipt.getId(),
                delReceipt.getFinalStatus()
            ));
        }
        
        // Auf Zustellbericht antworten
        try {
            byte[] messageId = new byte[]{1};
            session.deliverSmResponse(0, messageId, deliverSm);
        } catch (PDUException e) {
            System.err.println("Antwort auf deliver_sm fehlgeschlagen: " + e.getMessage());
        }
    }
});

Dieser Code verarbeitet Zustellbestätigungen, sodass Sie den Erfolg oder Misserfolg jeder über die SMPP-API in Java gesendeten SMS nachverfolgen können.

  
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);  

            // Konfiguration der Sitzungseinstellungen  
            session.setEnquireLinkTimer(30000);  
            session.setTransactionTimer(10000);  

            // Einrichten des Zustellbestätigungshandlers  
            session.setMessageReceiverListener(new DeliveryReceiptListener());  

            System.out.println("Erfolgreich mit dem SMPP-Server verbunden");  
        } catch (Exception e) {  
            System.err.println("Verbindung zum SMPP-Server fehlgeschlagen: " + 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("Senden der SMS fehlgeschlagen: " + 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(  
                    "Zustellbestätigung für Nachricht %s erhalten: %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",   
                "Hallo vom Java SMPP-Client!"  
            );  

            System.out.println("SMS mit ID gesendet: " + messageId);  

            // Anwendung laufen lassen, um Zustellberichte zu empfangen  
            System.out.println("Drücken Sie Strg+C, um zu beenden...");  
            Thread.sleep(Long.MAX_VALUE);  

        } catch (Exception e) {  
            System.err.println("Fehler im SMPP-Client: " + e.getMessage());  
        }  
    }  
}