EJB/JMS Transaction Example

The example application will invoke an EJB which is deployed within WildFly which will:

  1. start an XA transaction
  2. send a JMS message
  3. update an in-memory database
  4. commit the transaction

The example application will then receive the message sent by the EJB.

WildFly configuration

The example leverages the Arquillian framework to run a WildFly instance and deploy the MDB.

Example step-by-step

download WildFly 8.0.0.Final from here and install.

set the JBOSS_HOME property to point to the WildFly install directory

type mvn verify from the example directory to run

The example code is composed of two main classes:

Example Application

Let's take a look at EJBClientExample first.

  1. First we need to get an initial context so we can look-up the EJB. This initial context will get it's properties from the jboss-ejb-client.properties.
    2.             Properties env = new Properties();
            env.put(Context.URL_PKG_PREFIXES, "org.jboss.ejb.client.naming");
            InitialContext initialContext = new InitialContext();
  2. We look up the EJB
    3.             SendMessageService service = (SendMessageService) initialContext.lookup("ejb:/test//SendMessageBean!org.apache.activemq.javaee.example.server.SendMessageService");
  3. We create the DB table which will be updated if it does not already exist
    4.             service.createTable();
  4. We invoke the EJB's sendAndUpdate method. This method will send a JMS text message (with the text passed in parameter) and insert a row in the database table with the text and the message's JMS Message ID
    5.             service.sendAndUpdate("This is a text message");

    We will now consume the JMS message which was sent by the EJB at step 4.

  5. We need to get a new initial context so we can look-up the JMS connection factory and destination objects from JNDI.
    6.             env = new Properties();
            env.put(Context.INITIAL_CONTEXT_FACTORY, "org.jboss.naming.remote.client.InitialContextFactory");
            env.put(Context.PROVIDER_URL, "http-remoting://localhost:8080");
            initialContext = new InitialContext(env);
  6. We look up the JMS connection factory
    7.             ConnectionFactory cf = (ConnectionFactory)initialContext.lookup("jms/RemoteConnectionFactory");
  7. We lookup the JMS queue
    8.             Queue queue = (Queue)initialContext.lookup("jms/queues/testQueue");
  8. We create a connection, a session and a message consumer for the queue
    9.             connection = cf.createConnection("guest", "password");
            Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
            MessageConsumer consumer = session.createConsumer(queue);
  9. We start the JMS connection
    10.             connection.start();
  10. We receive a message from the queue. It corresponds to the message sent by the EJB
    11.             TextMessage messageReceived = (TextMessage)consumer.receive(5000);
            System.out.println("Received message: " + messageReceived.getText() + " (" + messageReceived.getJMSMessageID() + ")");
  11. And finally, always remember to close your JMS connections and resources after use, in a finally block. Closing a JMS connection will automatically close all of its sessions, consumers, producer and browser objects
    12.             finally
            {
               if (initialContext != null)
               {
                  initialContext.close();
               }
               if (connection != null)
               {
                  connection.close();
               }
             }

EJB Example

Let's now take a look at the EJB example

  1. First, we create a new initial context
    2.             ic = new InitialContext();
  2. We look up the JMS XA Connection Factory (which is bound to java:/JmsXA)
    3.             ConnectionFactory cf = (ConnectionFactory)ic.lookup("java:/JmsXA");
  3. We look up the JMS Queue
    4.             Queue queue = (Queue)ic.lookup("queue/testQueue");
  4. We create a JMS connection, a session and a message producer for the queue
    5.             jmsConnection = cf.createConnection();
            Session session = jmsConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
            MessageProducer messageProducer = session.createProducer(queue);
  5. We create a text message with the text passed in parameter of the EJB method
    6.             TextMessage message = session.createTextMessage(text);
  6. We send the message to the queue
    7.             messageProducer.send(message);
            System.out.println("Sent message: " + message.getText() + "(" + message.getJMSMessageID() + ")");
  7. We now lookup the JDBC XA DataSource
    8.             DataSource ds = (DataSource)ic.lookup("java:/XADS");
  8. We retrieve a JDBC connection
    9.             jdbcConnection  = ds.getConnection();
  9. We create a prepared statement to insert the text and message's ID in the DB table
    10.             PreparedStatement pr = jdbcConnection.prepareStatement("INSERT INTO " + TABLE
                        + " (id, text) VALUES ('" + message.getJMSMessageID() + "', '" + text + "');");
  10. We execute the prepared statement
    11.             pr.execute();
  11. We close the prepared statement
    12.             pr.close();
  12. And finally, always remember to close all your connections and resources (for both JMS and JDBC) after use, in a finally block.
    13.             finally
            {
                if (ic != null)
                {
                   ic.close();
                }
                if (jmsConnection != null)
                {
                   jmsConnection.close();
                }
                if (jdbcConnection != null)
                {
                   jdbcConnection.close();
                }
            }