Jakarta Messaging

clients

Specification: Jakarta Messaging

Version: 3.1

Status: Final Release

Release: February 25, 2022
send(Message message)

send(Message message, int deliveryMode, int priority, long timeToLive)

send(Destination destination, Message message, int deliveryMode, int
priority, long timeToLive)

send(Destination destination, Message message)
send(Destination destination, Message message)
send(Destination destination, String body)

send(Destination destination, Map<String,Object> body)

send(Destination destination, byte[] body)

send(Destination destination, Serializable body)

send(Destination destination, String body)
send(Message message)

send(Message message, int deliveryMode, int priority, long timeToLive)

send(Queue queue, Message message)

send(Queue queue, Message message, int deliveryMode, int priority, long
timeToLive)
publish(Message message)

publish(Message message, int deliveryMode, int priority, long
timeToLive)

publish(Topic topic, Message message)

publish(Topic topic, Message message, int deliveryMode, int priority,
long timeToLive)
send(Message message, CompletionListener completionListener)

send(Message message, int deliveryMode, int priority, long timeToLive,
CompletionListener completionListener)

send(Destination destination, Message message, CompletionListener
completionListener)

send(Destination destination, Message message, int deliveryMode, int
priority, long timeToLive, CompletionListener completionListener)
context.createProducer().
    setProperty("foo", "bar").
    setTimeToLive(10000).
    setDeliveryMode(NON_PERSISTENT).
    setDisableMessageTimestamp(true).
    send(dataQueue, body);
@Inject
private JMSContext context;
@Inject
@JMSConnectionFactory("jms/connectionFactory")
private JMSContext context;
@Inject
@JMSConnectionFactory("jms/connectionFactory")
@JMSPasswordCredential(
    userName="admin",password="mypassword")
private JMSContext context;
@Inject
@JMSConnectionFactory("jms/connectionFactory")
@JMSSessionMode(JMSContext.AUTO_ACKNOWLEDGE)
private JMSContext context;
import javax.naming.*;
import jakarta.jms.*;

Context namingContext = new InitialContext();
ConnectionFactory ConnectionFactory =
    (ConnectionFactory) namingContext.lookup("myCF");
Queue stockQueue = (Queue)namingContext.lookup("StockSource");
Connection connection = connectionFactory.createConnection();
connection.close();
try (Connection connection=connectionFactory.createConnection()) {
    // use connection in this try block
    // it will be closed when try block completes
} catch (JMSException e) {
    // exception handling
}
// Session is not transacted and
// uses AUTO_ACKNOWLEDGE for message acknowledgement

Session session=connection.createSession(Session.AUTO_ACKNOWLEDGE);
// stockQueue was previously looked up using JNDI

MessageProducer producer = session.createProducer(stockQueue);
// stockQueue was previously looked up using JNDI

MessageConsumer consumer = session.createConsumer(stockQueue);
connection.start();
String stockData; // Stock information as a string

// Set the message's text to be the stockData string
TextMessage message = session.createTextMessage();
message.setText(stockData);
// Send the message
producer.send(message);
Message stockMessage = consumer.receive();
// Wait up to 4 seconds for a message
Message stockMessage = receiver.receive(4000);
// extract stock information from message
String newStockData = ((TextMessage)stockMessage)getText();
// extract stock information from message
String newStockData= stockMessage.getBody(String.class);
import jakarta.jms.*;

public class StockListener implements MessageListener {
    public void onMessage(Message message) {
    // Unpack and handle the messages received
    ...
    }
}
StockListener myListener = new StockListener();

// consumer is a MessageConsumer object
consumer.setMessageListener(myListener);
public void onMessage(Message message) {

// Unpack and handle the messages received
    String newStockData =
        ((TextMessage)message).getText();
    if(...) {
        // Logic related to the data
    }
}
String stockData; // Stock information as a String

// Set the message's text to be the stockData string
TextMessage message = session.createTextMessage();
message.setText(stockData);

// Set the message property "StockSector"
message.setStringProperty("StockSector", "Technology");
String selector = new String("(StockSector = 'Technology')");
MessageConsumer consumer =
    session.createConsumer(stockQueue,selector);
import javax.naming.*;
import jakarta.jms.*;

// Look up connection factory
Context namingContext = new InitialContext();
ConnectionFactory connectionFactory =
    (ConnectionFactory) namingContext.lookup("ConnectionFactory")

// Look up destination
Topic newsFeedTopic = namingContext.lookup("BreakingNews");

// Create connection and session
Connection connection = ConnectionFactory.createConnection();
Session session=connection.createSession(Session.AUTO_ACKNOWLEDGE);
MessageConsumer consumer =
    session.createDurableConsumer(newsFeedTopic,"mySubscription");
// Create a consumer on an existing durable subscription
MessageConsumer consumer =
    session.createDurableConsumer(newsFeedTopic, "mySubscription");
String stockData; // Stock information as a string

TextMessage message = session.createTextMessage();

// Set the stockData string to the message body
message.setText(stockData);
String stockData = stockMessage.getText();
String stockData = stockMessage.getBody(String.class);
// Stock information as a byte array
byte[] stockData;
BytesMessage message = session.createBytesMessage();
message.writeBytes(stockData);
int bodyLength = message.getBodyLength();
byte[] stockData = new byte[bodyLength];
int bytesCopied = message.readBytes(stockData);
byte[] stockData = message.getBody(byte[].class);
String stockName; // Name of the stock
double stockValue; // Current value of the stock
long stockTime; // Time stock quote was updated */
double stockDiff; // +/- change in the stock quote*/
String stockInfo; // Information on this stock */
MapMessage message = session.createMapMessage();
// First parameter is the name of the map element,
// Second parameter is the value
message.setString("Name", "ORCL");
message.setDouble("Value", stockValue);
message.setLong("Time", stockTime);
message.setDouble("Diff", stockDiff);
message.setString(
    "Info", "Recent server announcement causes market interest");
String stockName; // Name of the stock
double stockValue; // Current value of the stock
long stockTime; // Time stock quote was updated
double stockDiff; // +/- change in the stock
String stockInfo; // Information on this stock
stockName = message.getString("Name");
stockDiff = message.getDouble("Diff");
stockValue = message.getDouble("Value");
stockTime = message.getLong("Time");
Map stockData = message.getBody(Map.class);
stockName = (String)stockData.getString("Name");
stockDiff = (Double)stockData.getDouble("Diff");
stockValue = (Double)stockData.getDouble("Value");
stockTime = (Long)stockData.getLong("Time");
String stockName; // Name of the stock
double stockValue; // Current value of the stock
long stockTime; // Time stock quote was updated
double stockDiff; // +/- change in the stock quote
String stockInfo; // Information on this stock

// Create message
StreamMessage message = session.createStreamMessage();
// Set data for message
message.writeString(stockName);
message.writeDouble(stockValue);
message.writeLong(stockTime);
message.writeDouble(stockDiff);
message.writeString(stockInfo);
String stockName; // Name of the stock quote
double stockValue; // Current value of the stock
long stockTime; // Time stock quote was updated
double stockDiff; // +/- change in the stock quote
String stockInfo; // Information on this stock

stockName = message.readString();
stockValue = message.readDouble();
stockTime = message.readLong();
stockDiff = message.readDouble();
stockInfo = message.readString();
String stockName; // Name of the stock quote
double stockValue; // Current value of the stock
long stockTime; // Time stock quote was updated
double stockDiff; // +/- change in the stock quote
String stockInfo; // Information on this stock

// Create a StockObject
StockObject stockObject = new StockObject();

// Establish the values for the StockObject
stockObject.setName(stockName);
stockObject.setValue(stockValue);
stockObject.setTime(stockTime);
stockObject.setDiff(stockDiff);
stockObject.setInfo(stockInfo);
// Create an ObjectMessage
ObjectMessage message = session.createObjectMessage();

// Set the body of the message to the StockObject
message.setObject(stockObject);
// Retrieve the StockObject from the message
StockObject stockObject = (StockObject)message.getObject();

// Extract data from the StockObject using StockObject methods
String stockName; // Name of the stock quote
double stockValue; // Current value of the stock
long stockTime; // Time stock quote was updated
double stockDiff; // +/- change in the stock quote
String stockInfo; // Information on this stock

stockName = stockObject.getName();
stockValue = stockObject.getValue();
stockTime = stockObject.getTime();
stockDiff = stockObject.getDiff();
stockInfo = stockObject.getInfo();
StockObject stockObject = message.getBody(StockObject.class);

// Extract data from the StockObject using StockObject methods
String stockName; // Name of the stock quote
double stockValue; // Current value of the stock
long stockTime; // Time stock quote was updated
double stockDiff; // +/- change in the stock quote
String stockInfo; // Information on this stock

stockName = stockObject.getName();
stockValue = stockObject.getValue();
stockTime = stockObject.getTime();
stockDiff = stockObject.getDiff();
stockInfo = stockObject.getInfo();
@Resource(lookup = "jms/connectionFactory")
ConnectionFactory connectionFactory;

@Resource(lookup="jms/dataQueue")
Queue dataQueue;

public void sendMessageOld (String body) throws JMSException {
    try (Connection connection =
        connectionFactory.createConnection()){
        Session session = connection.createSession();
        MessageProducer producer = session.createProducer(dataQueue);
        TextMessage textMessage = session.createTextMessage(body);
        messageProducer.send(textMessage);
    }
}
@Resource(lookup = "jms/connectionFactory")
ConnectionFactory connectionFactory;

@Resource(lookup="jms/dataQueue")
Queue dataQueue;

public void sendMessageNew (String body) {
    try (JMSContext context = connectionFactory.createContext();){
        context.createProducer().send(dataQueue,body);
    }
}
@Inject
@JMSConnectionFactory("jms/connectionFactory")
private JMSContext context;

@Resource(mappedName = "jms/dataQueue")
private Queue dataQueue;

public void sendMessageNew(String body) {
    context.send(dataQueue, body);
}
public void sendMessageOld(String body)
    throws JMSException, NamingException{

    InitialContext namingContext = getInitialContext();
    ConnectionFactory connectionFactory = (ConnectionFactory)
    namingContext.lookup("jms/connectionFactory");
    Queue dataQueue = (Queue) namingContext.lookup("jms/dataQueue")
    try (Connection connection =
            connectionFactory.createConnection()) {
        Session session = connection.createSession();
        MessageProducer messageProducer =
        session.createProducer(dataQueue);
        TextMessage textMessage = session.createTextMessage(body);
        messageProducer.send(textMessage);
    }
}
public void sendMessageNew(String body) throws NamingException {

    InitialContext namingContext = getInitialContext();
    ConnectionFactory connectionFactory = (ConnectionFactory)
        namingContext.lookup("jms/connectionFactory");
    Queue dataQueue = (Queue)namingContext.lookup("jms/dataQueue");
    try (JMSContext context=connectionFactory.createContext();){
        context.createProducer().send(dataQueue,body);
    }
}
public void sendMessageOld(String body)
throws JMSException, NamingException{

    InitialContext namingContext = getInitialContext();
    ConnectionFactory connectionFactory = (ConnectionFactory)
        namingContext.lookup("jms/connectionFactory");
    Queue dataQueue = (Queue) namingContext.lookup("jms/dataQueue");

    try (Connection connection =
            connectionFactory.createConnection()) {
        Session session = connection.createSession();
        MessageProducer producer = session.createProducer(dataQueue);
        TextMessage textMessage = session.createTextMessage(body);
        textMessage.setStringProperty("foo", "bar");
        messageProducer.setDeliveryMode(NON_PERSISTENT);
        messageProducer.setDisableMessageTimestamp(true);
        messageProducer.send(textMessage);
    }
}
public void sendMessageNew(String body) throws NamingException{

    InitialContext namingContext = getInitialContext();
    ConnectionFactory connectionFactory = (ConnectionFactory)
    namingContext.lookup("jms/connectionFactory");
    Queue dataQueue = (Queue)namingContext.lookup("jms/dataQueue");

    try (JMSContext context = connectionFactory.createContext()){
        context.createProducer().
            setProperty("foo", "bar").
            setTimeToLive(10000).
            setDeliveryMode(NON_PERSISTENT).
            setDisableMessageTimestamp(true).
            send(dataQueue, body);
    }
}
@Resource(lookup = "jms/connectionFactory")
ConnectionFactory connectionFactory;

@Resource(lookup="jms/dataQueue")
Queue dataQueue;

public String receiveMessageOld() throws JMSException {

    try (Connection connection =
            connectionFactory.createConnection()) {
        connection.start();
        Session session = connection.createSession();
        MessageConsumer consumer = session.createConsumer(dataQueue);
        TextMessage TextMessage =
            (TextMessage)messageConsumer.receive();
        String body = textMessage.getText();
        return body;
    }
}
@Resource(lookup = "jms/connectionFactory")
ConnectionFactory connectionFactory;

@Resource(lookup="jms/dataQueue")
Queue dataQueue;

public String receiveMessageNew() {

    try (JMSContext context = connectionFactory.createContext();){
    JMSConsumer consumer = context.createConsumer(demoQueue);
    return consumer.receiveBody(String.class);
    }
}
@Inject
@JMSConnectionFactory("jms/connectionFactory")
private JMSContext context;

@Resource(lookup="jms/dataQueue")
Queue dataQueue;

public String receiveMessageNew() {

    JMSConsumer consumer = context.createConsumer(dataQueue);
    return consumer.receiveBody(String.class);
}
public String receiveMessageOld()
        throws JMSException, NamingException {

    InitialContext namingContext = getInitialContext();
    ConnectionFactory connectionFactory = (ConnectionFactory)
        namingContext.lookup("jms/connectionFactory");
    Queue inboundQueue = (Queue)
        namingContext.lookup("jms/dataQueue");

    try (Connection connection =
            connectionFactory.createConnection();){
        Session session = connection.createSession(AUTO_ACKNOWLEDGE);
        MessageConsumer consumer = session.createConsumer(dataQueue);
        connection.start();
        TextMessage TextMessage = (TextMessage) consumer.receive();
        return textMessage.getText();
    }
}
public String receiveMessageNew() throws NamingException {

    InitialContext namingContext = getInitialContext();
    ConnectionFactory connectionFactory = (ConnectionFactory)
        namingContext.lookup("jms/connectionFactory");
    Queue dataQueue = (Queue) namingContext.lookup("jms/dataQueue");

    try (JMSContext context =
            connectionFactory.createContext(AUTO_ACKNOWLEDGE);) {
        JMSConsumer consumer = context.createConsumer(dataQueue);
        return consumer.receiveBody(String.class);
    }
}
@Resource(lookup = "jms/connectionFactory")
ConnectionFactory connectionFactory;

@Resource(lookup = "jms/newsFeedTopic")
Topic newsFeedTopic;

public String receiveMessageOld() throws JMSException {

    try (Connection connection =
            connectionFactory.createConnection()) {
        Session session = connection.createSession();
        MessageConsumer consumer =
            session.createDurableConsumer(newsFeedTopic, "mysub");
        connection.start();
        TextMessage textMessage = (TextMessage)consumer.receive();
        return textMessage.getText();
    }
}
@Resource(lookup = "jms/connectionFactory")
ConnectionFactory connectionFactory;

@Resource(lookup="jms/newsFeedTopic")
Topic newsFeedTopic;

public String receiveMessageNew() {

    try (JMSContext context = connectionFactory.createContext()){
        JMSConsumer consumer =
            context. createDurableConsumer (newsFeedTopic,"mysub");
        return consumer.receiveBody(String.class);
    }
}
@Inject
@JMSConnectionFactory("jms/connectionFactory")
private JMSContext context;

@Resource(lookup="jms/newsFeedTopic")
Topic newsFeedTopic;

public String receiveMessageNew() {

    JMSConsumer consumer =
        context.createDurableConsumer(newsFeedTopic, "mysub");
    return consumer.receiveBody(String.class);
}
public void receiveMessagesOld()
throws JMSException, NamingException{

    InitialContext namingContext = getInitialContext();
    ConnectionFactory connectionFactory = (ConnectionFactory)
        namingContext.lookup("jms/connectionFactory");
    Queue dataQueue =
        (Queue) namingContext.lookup("jms/dataQueue");

    try (Connection connection =
            connectionFactory.createConnection();){
        Session session = connection.createSession(_AUTO_ACKNOWLEDGE_);
        MessageConsumer consumer = session.createConsumer(dataQueue);
        MessageListener messageListener = new MyListener();
        consumer.setMessageListener(messageListener);
        connection.start();

        // wait for messages to be received
        // details omitted
    }
}
public void receiveMessagesNew() throws NamingException {

    InitialContext namingContext = getInitialContext();
    ConnectionFactory connectionFactory = (ConnectionFactory)
        namingContext.lookup("jms/connectionFactory");
    Queue dataQueue =
        (Queue) namingContext.lookup("jms/dataQueue");

    try (JMSContext context = connectionFactory.createContext();){
        JMSConsumer consumer = context.createConsumer(demoQueue);
        MessageListener messageListener = new MyListener();
        consumer.setMessageListener(messageListener);

        // wait for messages to be received
        // details omitted
    }
}
public void receiveMessagesOld()
        throws JMSException, NamingException{

InitialContext namingContext = getInitialContext();
ConnectionFactory connectionFactory = (ConnectionFactory)
    namingContext.lookup("jms/connectionFactory");
Topic newsFeedTopic = (Topic)
    namingContext.lookup("jms/newsFeedTopic");

    try (Connection connection =
            connectionFactory.createConnection();) {
        Session session = connection.createSession(AUTO_ACKNOWLEDGE);
        MessageConsumer consumer =
            session.createDurableConsumer(newsFeedTopic, "mysub");
        MessageListener messageListener = new MyListener();
        consumer.setMessageListener(messageListener);
        connection.start();

        // wait for messages to be received
        //details omitted
    }
}
public void receiveMessagesNew() throws NamingException {

    InitialContext namingContext = getInitialContext();
    ConnectionFactory connectionFactory = (ConnectionFactory)
        namingContext.lookup("jms/connectionFactory");
    Topic newsfeedTopic = (Topic)
        namingContext.lookup("jms/newsfeedTopic");

    try (JMSContext context =
            connectionFactory.createContext(AUTO_ACKNOWLEDGE);){
        JMSConsumer consumer =
            context.createDurableConsumer(inboundTopic, "mysub");
        MessageListener messageListener = new MyListener();
        consumer.setMessageListener(messageListener);

        // wait for messages to be received
        // details omitted
    }
}
public void receiveMessagesOld()
        throws JMSException, NamingException {

    InitialContext namingContext = getInitialContext();
    ConnectionFactory connectionFactory = (ConnectionFactory)
        namingContext.lookup("jms/connectionFactory");
    Queue dataQueue = (Queue) namingContext.lookup("jms/dataQueue");

    try (Connection connection =
            connectionFactory.createConnection();){
        Session s1 = connection.createSession(AUTO_ACKNOWLEDGE);
        MessageConsumer consumer1 = s1.createConsumer(dataQueue);
        MyListener messageListener1 = new MyListener("One");
        messageConsumer1.setMessageListener(messageListener1);

        Session s2 = connection.createSession(AUTO_ACKNOWLEDGE);
        MessageConsumer consumer2 = s2.createConsumer(dataQueue);
        MyListener messageListener2 = new MyListener("Two");
        messageConsumer2.setMessageListener(messageListener2);

        connection.start();

        // wait for messages to be received
        // details omitted
    }
}
public void receiveMessagesNew() throws NamingException {

    InitialContext namingContext = getInitialContext();
    ConnectionFactory connectionFactory = (ConnectionFactory)
        namingContext.lookup("jms/connectionFactory");
    Queue dataQueue = (Queue) namingContext.lookup("jms/dataQueue");

    try (JMSContext context1 =
            connectionFactory.createContext(AUTO_ACKNOWLEDGE);
        JMSContext context2 =
            context1.createContext(AUTO_ACKNOWLEDGE)){

        JMSConsumer consumer1 = context1.createConsumer(dataQueue);
        MyListener messageListener1 = new MyListener("One");
        consumer1.setMessageListener(messageListener1);

        JMSConsumer consumer2 = context2.createConsumer(dataQueue);
        MyListener messageListener2 = new MyListener("Two");
        consumer2.setMessageListener(messageListener2);

        // wait for messages to be received
        // details omitted
    }
}
public void receiveAndSendMessageOld()
        throws JMSException, NamingException {

    InitialContext namingContext = getInitialContext();
    ConnectionFactory connectionFactory = (ConnectionFactory)
        namingContext.lookup("jms/connectionFactory");
    Queue dataQueue = (Queue) namingContext.lookup("jms/dataQueue");
    Queue outboundQueue = (Queue)
        namingContext.lookup("jms/outboundQueue");

    try (Connection connection =
            connectionFactory.createConnection()){
        Session session =
            connection.createSession(SESSION_TRANSACTED);
        MessageConsumer consumer = session.createConsumer(dataQueue);
        MessageProducer producer =
            session.createProducer(outboundQueue);
        connection.start();

        TextMessage textMessage = null;
        do {
            textMessage = (TextMessage) consumer.receive(1000);
            if (textMessage!=null){
                producer.send(textMessage);
                session.commit();
                }
        } while (textMessage!=null);
    }
}
public void receiveAndSendMessageNew() throws NamingException {

    InitialContext namingContext = getInitialContext();
    ConnectionFactory connectionFactory = (ConnectionFactory)
        namingContext.lookup("jms/connectionFactory");
    Queue dataQueue =
        (Queue) namingContext.lookup("jms/dataQueue");
    Queue outboundQueue =
        (Queue) namingContext.lookup("jms/outboundQueue");

    try (JMSContext context =
            connectionFactory.createContext(SESSION_TRANSACTED);){
        JMSConsumer consumer = context.createConsumer(dataQueue);
        TextMessage textMessage = null;
        do {
            textMessage = (TextMessage) consumer.receive(1000);
            if (textMessage != null) {
                context.createProducer().send(
                outboundQueue, textMessage);
                context.commit();
            }
        } while (textMessage != null);
    }
}
@Stateless
@LocalBean
public class RequestReplyOld {

@Resource(lookup = "jms/connectionFactory")
ConnectionFactory connectionFactory;

@EJB private SenderBeanOld senderBean;

@TransactionAttribute(TransactionAttributeType.REQUIRED)
public String requestReplyOld(String request) throws JMSException {

    try (Connection connection =
            connectionFactory.createConnection()) {
        Session session = connection.createSession();
        TemporaryQueue replyQueue = session.createTemporaryQueue();

        // call a second bean to
        // send the request message in a separate transaction
        senderBean.sendRequestOld(request,replyQueue);

        // now receive the reply, using the same connection
        // as was used to create the temporary reply queue
        MessageConsumer consumer= session.createConsumer(replyQueue);
        connection.start();
        TextMessage reply = (TextMessage) consumer.receive();
        return reply.getText();
    }
}
}
@Stateless
@LocalBean
public class SenderBeanOld {

@Resource(lookup = "jms/connectionFactory")
ConnectionFactory connectionFactory;

@Resource(lookup="jms/requestQueue")
Queue requestQueue;

@TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
public void sendRequestOld(
        String requestString, TemporaryQueue replyQueue)
        throws JMSException {

    try (Connection connection =
            connectionFactory.createConnection()) {
        Session session = connection.createSession();
        TextMessage requestMessage =
            session.createTextMessage(requestString);
        requestMessage.setJMSReplyTo(replyQueue);
        MessageProducer messageProducer =
            session.createProducer(requestQueue);
        messageProducer.send(requestMessage);
    }
}
}
@MessageDriven(mappedName = "jms/requestQueue")
public class RequestResponderOld implements MessageListener {

@Resource(lookup = "jms/connectionFactory")
ConnectionFactory connectionFactory;

public void onMessage(Message message) {

    try (Connection connection =
        connectionFactory.createConnection()){
    Session session = connection.createSession();
    // extract request from request message
    String request = ((TextMessage)message).getText();
    // extract temporary reply destination from request message
    Destination replyDestination = message.getJMSReplyTo();
    // prepare response
    TextMessage replyMessage =
        session.createTextMessage("Reply to: "+request);
    // send response
    MessageProducer messageProducer =
        session.createProducer(replyDestination);
    messageProducer.send(replyMessage);
    } catch (JMSException ex) {
        // log an error here
    }
}
}
@Stateless
@LocalBean
public class RequestReplyNew {

@Resource(lookup = "jms/connectionFactory")
ConnectionFactory connectionFactory;

@EJB private SenderBeanNew senderBean;

@TransactionAttribute(TransactionAttributeType.REQUIRED)
public String requestReplyNew(String request) throws JMSException {

    try (JMSContext context = connectionFactory.createContext()) {
        TemporaryQueue replyQueue = context.createTemporaryQueue();

        // send the request message in a separate transaction
        // so use a separate bean
        // this call may throw JMSException
        senderBean.sendRequestNew(request,replyQueue);

        // now receive the reply, using the same connection
        // as was used to create the temporary reply queue
        JMSConsumer consumer = context.createConsumer(replyQueue);
        return consumer.receiveBody(String.class);
    }
}
}
@Stateless
@LocalBean
public class SenderBeanNew {

@Resource(lookup = "jms/connectionFactory")
ConnectionFactory connectionFactory;

@Resource(lookup="jms/requestQueue")
Queue requestQueue;

@TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
public void sendRequestNew(
        String requestString, TemporaryQueue replyQueue)
        throws JMSException {

    try (JMSContext context = connectionFactory.createContext()) {
        TextMessage requestMessage =
            context.createTextMessage(requestString);
        // this call may throw JMSException
        requestMessage.setJMSReplyTo(replyQueue);
        context.createProducer().send(
            requestQueue,requestMessage);
    }
}
}
@MessageDriven(mappedName = "jms/requestQueue")
public class RequestResponderNew implements MessageListener {

@Resource(lookup = "jms/connectionFactory")
ConnectionFactory connectionFactory;

public void onMessage(Message message) {

    try (JMSContext context = connectionFactory.createContext()){

        // extract request from request message
        // this may throw a JMSException
        String request = ((TextMessage)message).getText();

        // extract temporary reply destination from request message
        // this may throw a JMSException
        Destination replyDestination = message.getJMSReplyTo();

        // prepare response
        TextMessage replyMessage =
            context.createTextMessage("Reply to: "+request);

        // send response
        context.createProducer().send(replyDestination,replyMessage);
    } catch (JMSException ex) {
        // log an error here
    }
}
}
@Stateless
@LocalBean
public class RequestReplyNew {

@Inject
@JMSConnectionFactory("jms/connectionFactory2")
private JMSContext context;

@EJB private SenderBeanNew senderBean;

@TransactionAttribute(TransactionAttributeType.REQUIRED)
public String requestReplyNew(String request) throws JMSException {

    TemporaryQueue replyQueue = context.createTemporaryQueue();

    // send the request message in a separate transaction
    // so use a separate bean
    // this call may throw JMSException
    senderBean.sendRequestNew(request,replyQueue);

    // now receive the reply, using the same connection
    // as was used to create the temporary reply queue
    JMSConsumer consumer = context.createConsumer(replyQueue);
    return consumer.receiveBody(String.class);
}
}
@Stateless
@LocalBean
public class SenderBeanNew {

@Inject
@JMSConnectionFactory("jms/connectionFactory")
private JMSContext context;

@Resource(lookup="jms/requestQueue")
Queue requestQueue;

@TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
public void sendRequestNew(
        String requestString, TemporaryQueue replyQueue)
        throws JMSException {

    TextMessage requestMessage =
        context.createTextMessage(requestString);
    // this call may throw JMSException
    requestMessage.setJMSReplyTo(replyQueue);
    context.createProducer().send(requestQueue,requestMessage);
}
}
@MessageDriven(mappedName = "jms/requestQueue")
public class RequestResponderNew implements MessageListener {

@Inject
@JMSConnectionFactory("jms/connectionFactory")
private JMSContext context;

public void onMessage(Message message) {

    try {
        // extract request from request message
        // this may throw a JMSException
        String request = ((TextMessage)message).getText();

        // extract temporary reply destination from request message
        // this may throw a JMSException
        Destination replyDestination = message.getJMSReplyTo();

        // prepare response
        TextMessage replyMessage =
            context.createTextMessage("Reply to: "+request);

        // send response
        context.createProducer().send(replyDestination,replyMessage);
    } catch (JMSException ex) {
        // log an error here
    }
}
}

Jakarta Messaging

Copyright

Eclipse Foundation Specification License

Disclaimers

1. Introduction

1.1. Overview of Jakarta Messaging

1.1.1. What is messaging?

1.1.2. The objectives of Jakarta Messaging

1.1.3. Jakarta Messaging domains

1.1.4. What Jakarta Messaging does not include

1.1.5. Java SE and Jakarta EE support

1.2. What is new in Jakarta Messaging 2.0?

2. Architecture

2.1. Overview

2.2. What is a Jakarta Messaging application?

2.3. Administration

2.4. Two messaging styles

2.5. Jakarta Messaging APIs

2.6. Interfaces common to multiple APIs

2.7. Classic API interfaces

2.8. Simplified API interfaces

2.8.1. Goals of the simplified API

2.8.2. Key features of the simplified API

2.9. Legacy domain-specific API interfaces

2.10. Relationship between interfaces

2.11. Terminology for sending and receiving messages

2.12. Developing a Jakarta Messaging application

2.12.1. Developing a Jakarta Messaging client

2.13. Security

2.14. Multi-threading

2.15. Triggering clients

2.16. Request/reply

3. Jakarta Messaging message model

3.1. Background

3.2. Goals

3.3. Jakarta Messaging messages

3.4. Message header fields

3.4.1. JMSDestination

3.4.2. JMSDeliveryMode

3.4.3. JMSMessageID

3.4.4. JMSTimestamp

3.4.5. JMSCorrelationID

3.4.6. JMSReplyTo

3.4.7. JMSRedelivered

3.4.8. JMSType

3.4.9. JMSExpiration

3.4.10. JMSPriority

3.4.11. How message header values are set

3.4.12. Overriding message header fields

3.4.13. JMSDeliveryTime

3.5. Message properties

3.5.1. Property names

3.5.2. Property values

3.5.3. Using properties

3.5.4. Property value conversion

3.5.5. Property values as objects

3.5.6. Property iteration

3.5.7. Clearing a message’s property values

3.5.8. Non-existent properties

3.5.9. Jakarta Messaging defined properties

3.5.10. Provider-specific properties

3.5.11. JMSXDeliveryCount

3.6. Message acknowledgment

3.7. The Message interface

3.8. Message selection

3.8.1. Message selector

3.8.1.1. Message selector syntax

3.8.1.2. Null values

3.8.1.3. Special notes

3.9. Access to sent messages

3.10. Changing the value of a received message

3.11. Jakarta Messaging message body

3.11.1. Clearing a message body

3.11.2. Read-only message body

3.11.3. Conversions provided by StreamMessage and MapMessage

3.11.4. Messages for non-Jakarta Messaging clients

3.12. Provider implementations of Jakarta Messaging message interfaces

4. Messaging domains

4.1. Jakarta Messaging point-to-point model

4.1.1. Overview