Java EE JCA Resource Adapter Remote Server Configuration Example

This example demonstrates how to configure the Resource adapter to connect to a remote HornetQ server

This example is composed of a message driven bean and a client

MDBRemoteServerClientExample will send a message to the MDB via a queue and wait for the MDB to send a response via a reply queue

WildFly configuration

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

Configuring the incoming JCA resource adapter

The MDB will consume messages via the inflow JCA resource adapter. This can be configured in 2 ways:

  1. via a pooled-connection-factory in the "messaging" subsystem
  2. via the activation configuration properties on the MDB set either via annotations or ejb-jar.xml

In this example the MDB is annotated with @ResourceAdapter("hornetq-ra-remote.rar") which refers to this pooled-connection-factory:

                    <pooled-connection-factory name="hornetq-ra-remote">
                        <transaction mode="xa"/>
                        <user>guest</user>
                        <password>password</password>
                        <connectors>
                            <connector-ref connector-name="remote-http-connector"/>
                        </connectors>
                        <entries>
                            <entry name="java:/RemoteJmsXA"/>
                        </entries>
                    </pooled-connection-factory>

This configuration ensures the MDB will consume from the remote queue.

Configuring the outgoing JCA resource adapter

The same pooled-connection-factory used for JCA inflow also configures an outgoing JCA connection factory which Java EE components can use to send messages to the same remote HornetQ Server.

                    <pooled-connection-factory name="hornetq-ra-remote">
                        <transaction mode="xa"/>
                        <user>guest</user>
                        <password>password</password>
                        <connectors>
                            <connector-ref connector-name="remote-http-connector"/>
                        </connectors>
                        <entries>
                            <entry name="java:/RemoteJmsXA"/>
                        </entries>
                    </pooled-connection-factory>

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

  1. First we need to get an initial context so we can send a JMS message to the second server.
    2.             final Properties env = new Properties();

            env.put(Context.URL_PKG_PREFIXES, "org.jboss.ejb.client.naming");

            env.put(Context.INITIAL_CONTEXT_FACTORY, "org.jboss.naming.remote.client.InitialContextFactory");

            env.put(Context.PROVIDER_URL, "http-remoting://localhost:8180");

            initialContext = new InitialContext(env);
  2. Look up the MDB's queue
    3.             Queue queue = (Queue) initialContext.lookup("queues/mdbQueue");
  3. look up the connection factory
    4.             ConnectionFactory cf = (ConnectionFactory) initialContext.lookup("jms/RemoteConnectionFactory");
  4. We then create a connection
    5.             connection = cf.createConnection("guest", "password");
  5. we then create a session
    6.             Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
  6. we now create a message producer to send the message
    7.             MessageProducer producer = session.createProducer(queue);
  7. create a text message and send it
    8.             producer.send(session.createTextMessage("a message"));
  8. The MDB receives the text message
    9.             TextMessage tm = (TextMessage)message;
  9. The MDB looks up the reply queue
    10.             Queue destQueue = HornetQJMSClient.createQueue("mdbReplyQueue");
  10. The MDB creates a connection
    11.             Connection connection = connectionFactory.createConnection();
  11. The MDB creates a session
    12.             Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
  12. The MDB creates a message producer to send the message
    13.             MessageProducer producer = session.createProducer(destQueue);
  13. The MDB creates and sends a text message
    14.             producer.send(session.createTextMessage("A reply message"));
  14. The MDB closes the connection which returns it to the pool
    15.             connection.close();
  15. The client now looks up the reply queue
    16.             Queue replyQueue = (Queue) initialContext.lookup("queues/mdbReplyQueue");
  16. and creates a message consumer to receive the message
    17.             MessageConsumer consumer = session.createConsumer(replyQueue);
  17. starting the connection starts delivery
    18.             connection.start();
  18. The message consumer receives the text message
    19.             TextMessage textMessage = (TextMessage) consumer.receive(5000);
  19. and we always clear up out JMS resources
    20.             if (initialContext != null)
            {
               initialContext.close();
            }
            if (connection != null)
            {
               connection.close();
             }