A JMS message can be sent from a stateless session bean:

@Resource(lookup = "myConnection")
ConnectionFactory connectionFactory;
    
@Resource(lookup = "myQueue")
Destination inboundQueue;

public void sendMessage(String text) {
    try {
        Connection connection = 
            connectionFactory.createConnection();
        Session session = 
            connection.createSession(false, 
                                     Session.AUTO_ACKNOWLEDGE);
        MessageProducer messageProducer = 
            session.createProducer(inboundQueue);
        TextMessage textMessage = 
            session.createTextMessage(text);
        messageProducer.send(textMessage);
    } catch (JMSException ex) {
        //. . .
    }
}

In this code:

This code can be used to send messages using both messaging models.

By default, a JMS provider ensures that a message is not lost in transit in case of a provider failure. This is called a durable publisher/producer. The messages are logged to stable storage for recovery from a provider failure. However, this has performance overheads and requires additional storage for persisting the messages. If a receiver can afford to miss the messages, NON_PERSISTENT delivery mode may be specified. This does not require the JMS provider to store the message or otherwise guarantee that it is not lost if the provider fails.

This delivery mode can be specified:

messageProducer.setDeliveryMode(
    DeliveryMode.NON_PERSISTENT);

All messages sent by this messageProducer follow the semantics defined by NON_PERSISTENT delivery mode.

Delivery mode may alternatively be specified for each message:

messageProducer.send(textMessage, 
    DeliveryMode.NON_PERSISTENT, 6, 5000);

In this code, textMessage is the message to be sent with the NON_PERSISTENT delivery mode. The third argument defines the priority of the message and the last argument defines the expiration time.

JMS defines priority of a message on a scale of 0 (lowest) to 9 (highest). By default, the priority of a message is 4 (Message.DEFAULT_PRIORITY). Message priority may also be changed by invoking the Message.setJMSPriority method.

By default, a message never expires, as defined by Message.DEFAULT_TIME_TO_LIVE. This can be changed by calling the Message.setJMSExpiration method.

A JMS message can be received synchronously:

@Resource(lookup = "myConnection")
ConnectionFactory connectionFactory;
    
@Resource(lookup = "myQueue")
Destination inboundQueue;

public void receiveMessage() {
    try {
        Connection connection = 
            connectionFactory.createConnection();
        Session session = 
            connection.createSession(false, 
                                Session.AUTO_ACKNOWLEDGE);
        MessageConsumer consumer = 
            session.createConsumer(inboundQueue);
        connection.start();
        while (true) {
             Message m = consumer.receive();
             // process the message
        }
    } catch (JMSException ex) {
        //. . .
    }
}

In this code:

There are multiple publishers and subscribers to a topic. The subscribers receive the message only when they are active. However, a durable subscriber may be created that receives messages published while the subscriber is not active:

@Resource(lookup = "myTopicConnection")
TopicConnectionFactory topicConnectionFactory;

@Resource(lookup = "myTopic")
Topic myTopic;

public void receiveMessage() {
    TopicConnection connection = 
        topicConnectionFactory.createTopicConnection();
    TopicSession session = 
        connection.createTopicSession(false,
                                 Session.AUTO_ACKNOWLEDGE);
    TopicSubscriber subscriber = 
        session.createDurableSubscriber(myTopic, "myID");
    //. . .
}

In this code, TopicConnectionFactory and Topic are injected using @Resource. TopicConnection is created from the factory, which is then used to create TopicSession. TopicSession.createDurableSubscriber creates a durable subscriber. This method takes two arguments: the first is the durable Topic to subscribe to, and the second is the name used to uniquely identify this subscription. A durable subscription can have only one active subscriber at a time. The JMS provider retains all the messages until they are received by the subscriber or expire.

A client may use QueueBrowser to look at messages on a queue without removing them:

QueueBrowser browser = session.createBrowser(inboundQueue);
Enumeration messageEnum = browser.getEnumeration();
while (messageEnum.hasMoreElements()) {
    Message message = (Message)messageEnum.nextElement();
    //. . .
}

A JMS message can be received asynchronously using a message-driven bean:

@MessageDriven(mappedName = "myDestination")
public class MyMessageBean implements MessageListener {
    
    @Override
    public void onMessage(Message message) {
        try {
            // process the message
        } catch (JMSException ex) {
            //. . .
        }
    }
}

In this code:

This code shows how a message received by the onMessage method is a text message, and how the message body can be retrieved and displayed:

public void onMessage(Message message) {
    try {
        TextMessage tm = (TextMessage)message;
        System.out.println(tm.getText());
    } catch (JMSException ex) {
        //. . .
    }
}

Even though a message-driven bean cannot be invoked directly by a session bean, it can still invoke other session beans. A message-driven bean can also send JMS messages.

Typically, JMS Destination objects (i.e., Queue and Topic) are administered objects and identified by a JNDI name. These objects can also be created dynamically, where their scope is bound to the Connection from which they are created:

TopicConnection connection = 
    topicConnectionFactory.createTopicConnection();
TopicSession session = 
    connection.createTopicSession(false, 
                                  Session.AUTO_ACKNOWLEDGE);
TemporaryTopic tempTopic = 
    session.createTemporaryTopic();

Similarly, a TemporaryQueue can be created:

QueueConnection connection = 
    queueConnectionFactory.createQueueConnection();
QueueSession session = 
    connection.createQueueSession(false, 
                                  Session.AUTO_ACKNOWLEDGE);
TemporaryQueue tempQueue = 
    session.createTemporaryQueue();

These temporary destinations are automatically closed, deleted, and their contents lost when the connection is closed. They can also be explicitly deleted by calling the TemporaryQueue.delete or TemporaryTopic.delete method.

These temporary destinations can be used to simulate a request-reply design pattern by using JMSReplyTo and JMSCorrelationID header field.