asyncreceiver.java

SMPP（点到点短消息协议）的java实现

package ie.omk.smpp.examples;

import ie.omk.smpp.Connection;
import ie.omk.smpp.event.ConnectionObserver;
import ie.omk.smpp.event.ReceiverExitEvent;
import ie.omk.smpp.event.SMPPEvent;
import ie.omk.smpp.message.DeliverSM;
import ie.omk.smpp.message.SMPPPacket;
import ie.omk.smpp.message.Unbind;
import ie.omk.smpp.message.UnbindResp;

import java.io.IOException;
import java.util.Date;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.tools.ant.BuildException;

/**
 * Example SMPP receiver using asynchronous communications. This example
 * demonstrates asynchronous communications by implementing the
 * ConnectionObserver interface and directly handling all receiver events.
 * 
 * @see ie.omk.smpp.examples.ParseArgs ParseArgs for details on running this
 *      class.
 */
public class AsyncReceiver extends SMPPAPIExample implements ConnectionObserver {

    private Log logger = LogFactory.getLog(AsyncReceiver.class);

    private static int msgCount = 0;

    // Start time (once successfully bound).
    private long start = 0;

    // End time (either send an unbind or an unbind received).
    private long end = 0;

    // This is called when the connection receives a packet from the SMSC.
    public void update(Connection r, SMPPEvent ev) {
        switch (ev.getType()) {
        case SMPPEvent.RECEIVER_EXIT:
            receiverExit(r, (ReceiverExitEvent) ev);
            break;
        }
    }

    public void packetReceived(Connection myConnection, SMPPPacket pak) {
        switch (pak.getCommandId()) {

        // Bind transmitter response. Check it's status for success...
        case SMPPPacket.BIND_RECEIVER_RESP:
            if (pak.getCommandStatus() != 0) {
                logger.info("Error binding to the SMSC. Error = "
                        + pak.getCommandStatus());
            } else {
                this.start = System.currentTimeMillis();
                logger.info("Successfully bound. Waiting for message"
                        + " delivery..");

                synchronized (this) {
                    // on exiting this block, we're sure that
                    // the main thread is now sitting in the wait
                    // call, awaiting the unbind request.
               }
            }
            break;

        // Submit message response...
        case SMPPPacket.DELIVER_SM:
            if (pak.getCommandStatus() != 0) {
                logger.info("Deliver SM with an error! "
                        + pak.getCommandStatus());

            } else {
                ++msgCount;
                logger.info("deliver_sm: "
                        + Integer.toString(pak.getSequenceNum()) + ": \""
                        + ((DeliverSM) pak).getMessageText() + "\"");
            }
            break;

        // Unbind request received from server..
        case SMPPPacket.UNBIND:
            this.end = System.currentTimeMillis();
            logger.info("\nSMSC has requested unbind! Responding..");
            try {
                UnbindResp ubr = new UnbindResp((Unbind) pak);
                myConnection.sendResponse(ubr);
                
                synchronized (this) {
                    notify();
               }
            } catch (IOException x) {
                logger.warn("Exception", x);
            } finally {
                endReport();
            }
            break;

        // Unbind response..
        case SMPPPacket.UNBIND_RESP:
            this.end = System.currentTimeMillis();
            logger.info("\nUnbound.");
            synchronized (this) {
                notify();
            }
            endReport();
            break;

        default:
            logger.info("\nUnexpected packet received! Id = 0x"
                    + Integer.toHexString(pak.getCommandId()));
        }
    }

    private void receiverExit(Connection myConnection, ReceiverExitEvent ev) {
        if (ev.getReason() != ReceiverExitEvent.EXCEPTION) {
            if (ev.getReason() == ReceiverExitEvent.BIND_TIMEOUT) {
                logger.info("Bind timed out waiting for response.");
            }
            logger.info("Receiver thread has exited: " + ev.getReason());
        } else {
            Throwable t = ev.getException();
            logger.info("Receiver thread died due to exception:");
            logger.warn("Exception", t);
            endReport();
        }
        synchronized (this) {
            notify();
        }
    }

    // Print out a report
    private void endReport() {
        logger.info("deliver_sm's received: " + msgCount);
        logger.info("Start time: " + new Date(start).toString());
        logger.info("End time: " + new Date(end).toString());
        logger.info("Elapsed: " + (end - start) + " milliseconds.");
    }

    public void execute() throws BuildException {
        try {
            myConnection = new Connection(hostName, port, true);
            
            // Need to add myself to the list of listeners for this connection
            myConnection.addObserver(this);

            // Automatically respond to ENQUIRE_LINK requests from the SMSC
            myConnection.autoAckLink(true);
            myConnection.autoAckMessages(true);

            // Bind to the SMSC
            logger.info("Binding to the SMSC..");

            synchronized (this) {
                myConnection.bind(
                        Connection.RECEIVER,
                        systemID,
                        password,
                        systemType,
                        sourceTON,
                        sourceNPI,
                        sourceAddress);
    
                logger.info("Waiting for unbind...");
                wait();
            }

            myConnection.closeLink();
        } catch (Exception x) {
            throw new BuildException("Exception occurred while running example: " + x.getMessage() , x);
        }
    }
}