Tutorial: Starting with Glassfish and JMS

Remark 11.12.2010:
I seriously tried to make this running using Glassfish V3. Several hours in poking around with the various libraries, it just does not work. If ever someone comes around who found the solution, let us know !
Related posts: http://stackoverflow.com/questions/4311157/glassfish-v3-x-and-remote-standalone-client and http://www.java.net/forum/topic/glassfish/glassfish/class-and-libraries-jms-client-and-gf-3x

Remark 08.11.2010:
This is a very popular blog entry ! But it is from January 2009 and refers to Glassfish V2. The below tutorial does not work with Glassfish V3. I am currently reviewing it and creating an updated walk-through with the latest version(s). Stay tuned.

Remark 21.07.2011:
To all JMS fans, please consider ActiveMQ as alternative. I documented all necessary steps here (javadude.wordpress.com/2011/07/21/glassfish-v3-1-running-embedded-activemq-for-jms-part-1)
I gave up on Glassfish JMS (at least for external apps).

Despite tons of material, downloads and websites on JAVA enterprise applications, tools and features, there are few sources only for “Let’s get started” styled tutorials. The Netbeans tutorial is often the best starting point (link).

I was reading about the background of JMS, some of the material is of a very theoretical nature and I tried to find some simple sample to get my hands dirty. A good short article on JMS in the glassfish context you can find at java.net (link)

This tutorial describes the steps to get a most simple messaging application up and running implementing a one-to-many communication using topics, also called publish-subscribe. A enterprise client creates a message put it on a topic and a message-driven bean (MDB) retrieves the message.

Using: Netbeans 6.5 with installed Glassfish V2.

1. Creating a new JAVA EE project.

MyJMS Project: New Project

2. We call it MyJMS. Disable the web-application and enable application-client

MyJMS Project: New EE Application

3. We will have a project window with 2 subprojects for the EJB and the application client.

MyJMS Project

4. Before we start with the coding of the EJB and the client, we configure the applicationserver. Open the admin console via right click on the application server under services (Start the server first, if not done yet). You remember the default admin password for glassfish ? “adminadmin”.You better change if your box is open to outside world.

MyJMS: View Admin Console

In the admin console we create the ressources for the JMS topic.

MyJMS: Add Resources

Create a destination resource with JNDI name “jms/topic” and Resource type “javax.jms.topic” (rest default settings).
Create a connection factory with the JNDI name “jms/TopicFactory” (rest default settings, but remove username and password).

5. Now we take care of the application client who will send a message to the topic destination.
The IDE created a main.java template for us.

MyJMS: main.java template

Resource injection by adding these 4 lines

@Resource(mappedName=”jms/TopicFactory”)
private static ConnectionFactory topicFactory;

@Resource(mappedName=”jms/Topic”)
private static Topic topic;

MyJMS: Resource Injection

Adding code to create a connection an send message

Connection topicConnection = null;
Session session = null;
MapMessage message = null;
MessageProducer producer = null;

try {
topicConnection = topicFactory.createConnection();
session = topicConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
producer = session.createProducer(topic);
message = session.createMapMessage();

message.setString(“lastname”, “Smith”);
message.setString(“firstname”, “John”);
message.setString(“id”, “0100”);

producer.send(message);
}
catch (Exception e) {…

MyJMS: Send a message

6. Now we create a message-driven bean that consumes the message. Let’s call it MessageBean

MyJMS: Create new message-driven bean

MyJMS: New message-driven bean

We create it in the package ejb and connect it to the server destination we created earlier. Netbeans creates a basic template for us.

MyJMS: MDB Skeleton

We need to inject the resources again:

@Resource(mappedName=”jms/TopicFactory”)
private ConnectionFactory topicFactory;
@Resource(mappedName=”jms/Topic”)
private Topic topic;

And we add some code to onMessage method:

MapMessage msg = null;
try {

msg = (MapMessage)message;
System.out.println(“—————————————-“);
System.out.println(msg.getString(“lastname”));
System.out.println(msg.getString(“firstname”));
System.out.println(msg.getString(“id”));
System.out.println(“—————————————-“);
}
catch (Exception e) {…

MyJMS: Read the message

7. Lets run it:

Glassfish Log:

—————————————-
Smith
John
0100
—————————————-

Conclusion: This is the most basic version of a messaging application. Please note there is no proper error handling or any business logic or whatsoever. There is no documentation in the above code because some of the abstract commands are so sophisticated that the tutorial would become a compendium and you are back to square one: It is too much to swallow.

My recommendation: Get something simple up and running and then start tweaking and start to understand.

Potential Problems:

• You might hit a cast error when trying to receive the message. Change the JMS settings from EMBEDDED to LOCAL. Dont ask me why.
  DirectConsumer:Caught Exception delivering messagecom.sun.messaging.jmq.io.Packet cannot be cast to com.sun.messaging.jms.ra.DirectPacket
  

  Glassfish Configuration: JMS settings