Interview Questions

Send Bulk SMS using JSMPP

This article contains code examples to send sms to a huge set of subscribers. The input of MSISDN can be provided through a file as comma separated values. The class BulkSMSSender reads the input file of comma separated MSISDN and in turn initiates a pool of threads which executes sendTextMessage() method of SendSMSImpl class. Also there is a JSMPPServer class which acts an SMSC Simulator. It should be run first, which will listen to a port (example- 7001). The SendSMSImpl class sends text message to that port in which the JSMPPServer listens. In this way you can verify whether your messages are received at the destination.

SendSMSImpl.java

package in.techdive.sms;

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

import org.jsmpp.bean.Alphabet;
import org.jsmpp.bean.BindType;
import org.jsmpp.bean.ESMClass;
import org.jsmpp.bean.GeneralDataCoding;
import org.jsmpp.bean.MessageClass;
import org.jsmpp.bean.NumberingPlanIndicator;
import org.jsmpp.bean.RegisteredDelivery;
import org.jsmpp.bean.SMSCDeliveryReceipt;
import org.jsmpp.bean.TypeOfNumber;
import org.jsmpp.session.BindParameter;
import org.jsmpp.session.SMPPSession;
import org.jsmpp.util.AbsoluteTimeFormatter;
import org.jsmpp.util.TimeFormatter;

public class SendSMSImpl implements SendSMS, Runnable
{

        private String  msisdn;

        /**
         * @return the msisdn
         */

        public String getMsisdn()
        {
                return msisdn;
        }

        /**
         * @param msisdn
         *            the msisdn to set
         */

        public void setMsisdn(String msisdn)
        {
                this.msisdn = msisdn;
        }

        public SendSMSImpl()
        {
                super();
        }

        private TimeFormatter   tF      = new AbsoluteTimeFormatter();

        /*
         * This method is used to send SMS to the given MSISDN
         */

        public void sendTextMessage(String MSISDN)
        {

                // bind param instance is created with parameters for binding with SMSC
                BindParameter bP = new BindParameter(BindType.BIND_TX, "tdd", "tdd", "tdd.sys", TypeOfNumber.UNKNOWN,
                                NumberingPlanIndicator.UNKNOWN, null);

                SMPPSession smppSession = null;

                try
                {
                        // smpp session is created using the bindparam and the smsc ip address/port
                        smppSession = new SMPPSession("localhost", 7001, bP);

                }
                catch (IOException e1)
                {
                        e1.printStackTrace();
                }

                // Sample TextMessage
                String message = "This is a Test Message";

                GeneralDataCoding dataCoding = new GeneralDataCoding(false, true, MessageClass.CLASS1, Alphabet.ALPHA_DEFAULT);

                ESMClass esmClass = new ESMClass();

                try
                {
               
                        smppSession.submitShortMessage("CMT", TypeOfNumber.NATIONAL, NumberingPlanIndicator.ISDN, MSISDN,
                                        TypeOfNumber.NATIONAL, NumberingPlanIndicator.ISDN, MSISDN, esmClass, (byte) 0, (byte) 0, tF
                                                        .format(new Date()), null, new RegisteredDelivery(SMSCDeliveryReceipt.DEFAULT), (byte) 0,
                                        dataCoding, (byte) 0, message.getBytes());
                }
                catch (Exception e)
                {
                        e.printStackTrace();
                }
        }

        public void run()
        {
                sendTextMessage();

        }

        public void sendTextMessage()
        {
                sendTextMessage(getMsisdn());

        }
}

public interface SendSMS
{

        void sendTextMessage();
}

BulkSMSSender.java

/**
 *
 */

package in.techdive.sms;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;


public class BulkSMSSender
{
        final ArrayBlockingQueue<Runnable>
        queue = new ArrayBlockingQueue<Runnable>(100, true);
        int poolSize = 2;
        int maxPoolSize = 2;
        long keepAliveTime = 10;
        ThreadPoolExecutor threadPool = null;

        public BulkSMSSender()
        {
                threadPool = new ThreadPoolExecutor(poolSize, maxPoolSize, keepAliveTime, TimeUnit.SECONDS, queue);
                threadPool.prestartAllCoreThreads();
        }

        public void executeTask()
        {
                int i = 0;

                while (queue.size() > 0)
                {
                        threadPool.execute(queue.poll());
                        try
                        {
                                Thread.sleep(1000);
                        }
                        catch (InterruptedException e)
                        {
                                e.printStackTrace();
                        }
                }
                threadPool.shutdown();
        }

        public void addTaskToQueue(Runnable r)
        {
                queue.add(r);
        }

        public void msisdnFileReader() throws IOException
        {
                FileReader fReader = new FileReader("C:\\msisdn.txt");
                StringBuilder sBuild = new StringBuilder();

                BufferedReader bufReader = new BufferedReader(fReader);

                String s = "";
                while ((s = bufReader.readLine()) != null)
                {
                        sBuild.append(s);
                }

                String[] msisdnArr = sBuild.toString().split(",");

                for (String msisdn : msisdnArr)
                {
                        SendSMSImpl sms = new SendSMSImpl();
                        sms.setMsisdn(msisdn);
                        addTaskToQueue(sms);

                }

                executeTask();

        }

        public static void main(String[] args) throws IOException
        {

                BulkSMSSender bulkSMSSender = new BulkSMSSender();
                bulkSMSSender.msisdnFileReader();
        }
}

JSMPPServer.java

package in.techdive.sms;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

import org.apache.log4j.BasicConfigurator;
import org.jsmpp.PDUStringException;
import org.jsmpp.SMPPConstant;
import org.jsmpp.bean.CancelSm;
import org.jsmpp.bean.DataSm;
import org.jsmpp.bean.QuerySm;
import org.jsmpp.bean.ReplaceSm;
import org.jsmpp.bean.SubmitMulti;
import org.jsmpp.bean.SubmitMultiResult;
import org.jsmpp.bean.SubmitSm;
import org.jsmpp.extra.ProcessRequestException;
import org.jsmpp.session.BindRequest;
import org.jsmpp.session.DataSmResult;
import org.jsmpp.session.QuerySmResult;
import org.jsmpp.session.SMPPServerSession;
import org.jsmpp.session.SMPPServerSessionListener;
import org.jsmpp.session.ServerMessageReceiverListener;
import org.jsmpp.session.Session;
import org.jsmpp.util.AbsoluteTimeFormatter;
import org.jsmpp.util.MessageIDGenerator;
import org.jsmpp.util.MessageId;
import org.jsmpp.util.RandomMessageIDGenerator;
import org.jsmpp.util.TimeFormatter;

public class JSMPPServer
{
        private static TimeFormatter    timeFormatter   = new AbsoluteTimeFormatter();  ;

        public static void main(String[] args) throws IOException
        {
                BasicConfigurator.configure();
                JSMPPServer smppServer = new JSMPPServer();
                smppServer.serviceRequest();
        }

        public void serviceRequest() throws IOException
        {

                SMPPServerSessionListener sessionListener = new SMPPServerSessionListener(7001);
                // set all default ServerMessageReceiverListener for all accepted SMPPServerSessionListener
                // prepare the message receiver
                ServerMessageReceiverListener messageReceiverListener = new ServerMessageReceiverListenerImpl();
                sessionListener.setMessageReceiverListener(messageReceiverListener);

                while (true)
                {
                        try
                        {

                                System.out.println("Listening ...");

                                // accepting connection, session still in OPEN state
                                SMPPServerSession session = sessionListener.accept();
                                // or we can set for each accepted session session.setMessageReceiverListener(messageReceiverListener)
                                System.out.println("Accept connection");

                                try
                                {
                                        BindRequest request = session.waitForBind(1000);
                                        System.out.println("Receive bind request");

                                        if (request.getBindParameter().getSystemId().equals("tdd")
                                                        && request.getBindParameter().getPassword().equals("tdd"))
                                        {

                                                // accepting request and send bind response immediately
                                                System.out.println("Accepting bind request");
                                                request.accept("tdd.sys");

                                                // try { Thread.sleep(2000); } catch (InterruptedException e) {}
                                        }
                                        else
                                        {
                                                System.out.println("Rejecting bind request");
                                                request.reject(SMPPConstant.STAT_ESME_RINVPASWD);
                                        }
                                }
                                catch (TimeoutException e)
                                {
                                        System.out.println("No binding request made after 5000 millisecond");
                                        e.printStackTrace();
                                }

                                System.out.println("Closing session");
                                // session.unbindAndClose();
                                System.out.println("Closing session listener");
                                // sessionListener.close();
                        }
                        catch (PDUStringException e)
                        {
                                e.printStackTrace();
                        }
                        catch (IOException e)
                        {
                                e.printStackTrace();
                        }

                }
        }
}

class ServerMessageReceiverListenerImpl implements org.jsmpp.session.ServerMessageReceiverListener
{

        final MessageIDGenerator        messageIdGenerator      = new RandomMessageIDGenerator();

        public MessageId onAcceptSubmitSm(SubmitSm submitSm, SMPPServerSession source) throws ProcessRequestException
        {
                System.out.println("Receiving message : " + new String(submitSm.getShortMessage()));
                // need message_id to response submit_sm
                return messageIdGenerator.newMessageId();
        }

        public QuerySmResult onAcceptQuerySm(QuerySm querySm, SMPPServerSession source) throws ProcessRequestException
        {
                return null;
        }

        public SubmitMultiResult onAcceptSubmitMulti(SubmitMulti submitMulti, SMPPServerSession source)
                        throws ProcessRequestException
        {
                return null;
        }

        public DataSmResult onAcceptDataSm(DataSm dataSm) throws ProcessRequestException
        {
                return null;
        }

        public void onAcceptCancelSm(CancelSm cancelSm, SMPPServerSession source) throws ProcessRequestException
        {
        }

        public void onAcceptReplaceSm(ReplaceSm replaceSm, SMPPServerSession source) throws ProcessRequestException
        {
        }

        public DataSmResult onAcceptDataSm(DataSm dataSm, Session source) throws ProcessRequestException
        {
                return null;
        }
}

Related Articles:
Send SMS Message Using JSMPP

Send Long SMS Message Using JSMPP

Send Ringtone Using JSMPP