public ReceiveSubscriber(boolean useProps,
    String jndi,
    String url,
    String connfactory,
    String topic,
    boolean useAuth,
    String user,
    String pwd) 
{
        Context ctx = initJNDI(useProps, jndi, url, useAuth, user, pwd);
        TopicConnection _conn = null;
        Topic _topic = null;
        TopicSession _session = null;
        TopicSubscriber _subscriber = null;
        if (ctx != null) {
            try {
                ConnectionFactory.getTopicConnectionFactory(ctx,connfactory);
                _conn = ConnectionFactory.getTopicConnection();
                _topic = InitialContextFactory.lookupTopic(ctx, topic);
                _session = this.CONN.createTopicSession(false, TopicSession.AUTO_ACKNOWLEDGE);
                _subscriber = this.SESSION.createSubscriber(this.TOPIC);
                log.info("created the topic connection successfully");
            } catch (JMSException e) {
                log.error("Connection error: " + e.getMessage());
            }
        } else {
            log.error("Could not initialize JNDI Initial Context Factory");
        }
        this.CONN = _conn;
        this.TOPIC = _topic;
        this.SESSION = _session;
        this.SUBSCRIBER = _subscriber;
}

 public synchronized  void close() 
{
 // called from testEnded() thread
        try {
            this.RUN = false;
            this.CONN.stop();
            this.SUBSCRIBER.close();
            this.SESSION.close();
            this.CONN.close();
            this.CLIENTTHREAD.interrupt();
            this.CLIENTTHREAD = null;
            this.buffer.setLength(0);
        } catch (JMSException e) {
            log.error(e.getMessage());
        } catch (Exception e) {
            log.error(e.getMessage());
        }
}

close() will stop the connection first. Then it closes the subscriber, session and connection.

 public synchronized int count(int increment) 
{
        counter += increment;
        return counter;
}

Increment the count and return the new value

 public synchronized byte[] getByteResult() 
{
        return this.buffer.toString().getBytes();
}

Get the message(s) as an array of byte[]

 public synchronized String getMessage() 
{
        return this.buffer.toString();
}

Get the message as a string

 public synchronized  void reset() 
{
        counter = 0;
        this.buffer.setLength(0);
}

Reset the receiver ready for receiving any further messages

 public  void resume() 
{
        if (this.CONN == null) {
            log.error("Connection not set up");
            return;
        }
        try {
            this.CONN.start();
        } catch (JMSException e) {
            log.error("failed to start recieving");
        }
}

Resume will call Connection.start() and begin receiving messages from the JMS provider.

 public  void run() 
{
        if (SUBSCRIBER == null) { // just in case
            log.error("Subscriber has not been set up");
            return;
        }
        while (RUN) {
            try {
                Message message = this.SUBSCRIBER.receive();
                if (message != null && message instanceof TextMessage) {
                    TextMessage msg = (TextMessage) message;
                    String text = msg.getText();
                    if (text.trim().length()  > 0) {
                        synchronized (this) {
                            this.buffer.append(text);
                            count(1);
                        }
                    }
                }
            } catch (JMSException e) {
                log.error("Communication error: " + e.getMessage());
            }
        }
}

run calls listen to begin listening for inbound messages from the provider. Updates the count field so the caller can check how many messages have been receieved.

 public  void setLoop(int loop) 
{
        this.loop = loop;
}

Set the number of iterations for each call to sample()

 public  void start() 
{
        // No point starting thread unless subscriber exists
        if (SUBSCRIBER == null) {
            log.error("Subscriber has not been set up");
            return;
        }
        this.CLIENTTHREAD = new Thread(this, "Subscriber2");
        this.CLIENTTHREAD.start();
}

start will create a new thread and pass this class. once the thread is created, it calls Thread.start().