Email	Print Reprint
	add to:
	Del.icio.us Digg Google Furl	Slashdot Y! MyWeb Blink
	TABLE OF CONTENTS What Is Messaging? JMS Message Paradigms Sample E-mail Sender Application Sample E-mail Reader Application

Sample E-mail Sender Application

The queue application I present here includes two JMS client applications—one that sends simulated e-mail messages to an e-mail inbox, and another that reads the e-mail messages off the queue. The EmailSender class in Listing One is a message producer that sends messages to a simulated e-mail inbox, which is simply a JMS queue that is read by the e-mail reader application at a later time. (The complete source code for the sender/reader application is available electronically; see www.ddj.com/code/.)

package emaildemo;
import javax.jms.*;
import javax.naming.*;

public class EmailSender 
{
    private Connection connection = null;
    private Session session = null;
    private MessageProducer prod = null;

    public EmailSender()
    {
        try {
            InitialContext jndi = new InitialContext();
           // Lookup a JMS connection factory
           ConnectionFactory conFactory =
                (ConnectionFactory)jndi.lookup("ConnectionFactory");
            // Create a JMS connection
            connection = conFactory.createConnection("","");
            // Create a JMS session object
            session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
            // Get the JMS queue that represents the simulated inbox
           Destination inbox = (Destination)jndi.lookup("Inbox");
           if ( inbox == null )
                inbox = session.createQueue("Inbox");
            // Create a producer to place messages into the inbox
            prod = session.createProducer(inbox);
            // The Connection must be started for messages to fly
            connection.start();
        }
        catch ( Exception e ) {
            e.printStackTrace();
        }
    }
    public void sendEmail(String subject, String body) throws Exception
    { ... }
    public static void main(String[] args) 
    { ... }
}

The EmailSender class initializes the JMS session in its constructor, and contains one additional method that lets the caller send e-mail messages to the queue representing the simulated e-mail inbox.

In the constructor, the first step is to use Java Naming and Directory Interface (java.sun.com/products/jndi) to get access to the JMS provider's javax.jms.ConnectionFactory object. The provider-specific JNDI details are typically placed within a configuration file named jndi.properties. The Java VM automatically looks for the presence of this file when you instantiate the InitialContext class.

Once a ConnectionFactory object is obtained, a call to its createConnection method returns a JMS javax.jms.Connection object. This object represents an actual connection to the JMS provider. Because it's threadsafe and consumes a considerable amount of system resources to maintain, your application should require only one active Connection object during its lifetime. Opening multiple connections to a JMS provider is usually unnecessary and a waste of resources.

Next, via a call to the Connection object's createSession method, the code creates a javax.jms.Session object. A Session object represents a working message session, and can only be used by one thread at a time within your code. Therefore, you should create a Session object for each message producer and consumer thread in your application. The Session object is used as a factory to create javax.jms.Destination, javax.jms.Producer, javax.jms.Consumer, and javax.jms.Message objects.

The Session object is used to create a reference to the "Inbox" queue by looking it up via JNDI and creates it on the fly if it's not found. Next, a message producer is created for the "Inbox" queue, which is used to send simulated e-mail messages. Finally, a call is made to the Connection object's start method to begin the flow of messages for the queue (and all destinations created through this JMS connection).

The sample application instantiates the EmailSender class (available electronically) and calls its sendEmail method twice to simulate sending two individual e-mail messages to the "Inbox" queue. The sendEmail method first creates a plain-old Java object (POJO) that represents the e-mail message, of class Email. Next, the Session object (which was created in the constructor) is used to create a javax.jms.ObjectMessage object that in turn is used to encapsulate the Email POJO. Finally, the JMS message is actually sent via a call to the send method on the queue's Producer object.

Running the e-mail sender application results in the output in Figure 4. Because the simulated inbox is implemented as a JMS queue, the reader application does not need to be running at the same time as the sender.

[Click image to view at full size]

Figure 4: Running e-mail sender application.

All of the messages sent to the queue will remain in the queue until the reader application executes and removes them.

Previous Page | 1 What Is Messaging? | 2 JMS Message Paradigms | 3 Sample E-mail Sender Application | 4 Sample E-mail Reader Application Next Page

RELATED ARTICLES Widget SDK Released for BlackBerry Agitar Updates JUnit Tool G1: Java's Garbage First Garbage Collector Perforce Releases Pure Java API for SCM Perforce Releases Java Version of Plug-in for Eclipse		TOP 5 ARTICLES No Top Articles.