Enterprise JavaBeans 3.0 by Bill Burke, Richard Monson-Haefel, Linda DeMichiel (Foreword by)

From Barnes & Noble

The Barnes & Noble Review
Ask around the newsgroups or your local Java user group, and you'll find virtually unanimous praise for Enterprise Javabeans, Second Edition. It's the EJB guide for serious developers. And it's now been fully updated for Sun's EJB 1.1 specification — while also retaining the extensive 1.0 information thousands of developers have come to rely on.

Richard Monson-Haefel begins by introducing generic component models, distributed objects, and component transaction monitors, then shows how EJB implements these elements to support the construction of powerful, scalable, portable enterprise software. You'll review EJB's architecture, discover how EJB-compliant servers manage enterprise beans at runtime, then walk through building your first enterprise beans.

Once you know the basics, Monson-Haefel digs far deeper into real-world bean development, showing how enterprise beans are accessed and used by remote clients; how to develop container-managed and bean-managed entity beans; how to develop stateless and stateful session beans; and how to work with EJB's powerful transactional model.

As you'd expect from one of the world's leading distributed software architects, there's a full chapter on design strategies for maximizing efficiency and simplifying development. You'll also find extensive coverage of EJB 1.1's new XML-based deployment descriptors, which describe the classes that make up a bean and how it should be managed at runtime.

The book is full of code which should work on any EJB-compliant server. (But, as has happened a time ortwo,Sun's own reference implementation has proven buggy: it doesn't properly manage compound primary keys in Container-Managed Persistence. Pending Sun's promised fix, Monson-Haefel has posted Sun-specific code at www.ejbnow.com/j2eeri_problems.html.)

None of that takes away from Monson-Haefel's remarkable accomplishment. This superbly readable, immensely practical guide is a must-have for every serious enterprise Java developer.

—bncom editor

From the Publisher

If you're up on the latest Java technologies, then you know that Enterprise JavaBeans (EJB) 3.0 is the hottest news in Java this year. In fact, EJB 3.0 is being hailed as the new standard of server-side business logic programming. And O'Reilly's award-winning book on EJB has been refreshed just in time to capitalize on the technology's latest rise in popularity.

This fifth edition, written by Bill Burke and Richard Monson-Haefel, has been updated to capture the very latest need-to-know Java technologies in the same award-winning fashion that drove the success of the previous four strong-selling editions. Bill Burke, Chief Architect at JBoss, Inc., represents the company on the EJB 3.0 and Java EE 5 specification committees. Richard Monson-Haefel is one of the world's leading experts on Enterprise Java.

"Enterprise JavaBeans 3.0," 5th Edition is organized into two parts: the technical manuscript followed by the JBoss workbook. The technical manuscript explains what EJB is, how it works, and when to use it. The JBoss workbook provides step-by-step instructions for installing, configuring, and running the examples from the manuscript on the JBoss 4.0 Application Server.

Although EJB makes application development much simpler, it's still a complex and ambitious technology that requires a great deal of time to study and master. But now, thanks to "Enterprise JavaBeans 3.0," 5th Edition, you can overcome the complexities of EJBs and learn from hundreds of practical examples that are large enough to test key concepts but small enough to be taken apart and explained in the detail that you need. Now you can harness the complexity of EJB with just a single resource by your side.

Booknews

Explains the underlying technology, Java classes and interfaces, component model, and runtime behavior of Enterprise JavaBeans. Previous knowledge of Java is assumed. The second edition has been updated to cover changes in version 1.1. Annotation c. Book News, Inc., Portland, OR (booknews.com)

Internet Bookwatch

Now in a new and completely updated edition, Enterprise Javabeans continues to be an essential reference book for all Java users. Richard Monson-Haefel covers Enterprise JavaBeans 1.1 and 1.0; developing entity beans and session beans; container-managed and bean-managed persistence; XML deployment descriptors; the JNDI Enterprise Naming Context (ENC); transaction management; design strategies; bean life cycle; and the relationship between EJB and Java 2, Enterprise Edition (J2EE). Enterprise Javabeans is thoroughly "user friendly" and will enable even the novice to build complex, mission-critical systems using snap-together software components that model business object sand processes addressing such issues as object persistence, security, and transaction management on entrepreneurial, informational, and personal websites. Highly recommended for all Java users.

Product Details

• Table of Contents
• Read an Excerpt

Table of Contents

Read an Excerpt

Chapter 13: Message-Driven Beans

This chapter is divided into two subsections: "JMS as a Resource" and "Message-Driven Beans." The first section describes the Java Message Service (JMS) and its role as a resource that is available to any enterprise bean (session, entity, or message-driven). Readers unfamiliar with JMS should read the first section before proceeding to the second section.

The second section in this chapter provides an overview of the new enterprise bean type--the message-driven bean. A message-driven bean is an asynchronous bean activated by message delivery. In EJB 2.0, vendors are required to support JMS-based message-driven bean, that receive JMS messages from specific topics or queues and process those messages as they are delivered.

All EJB 2.0 vendors must, by default, support a JMS provider. Most EJB 2.0 vendors have a JMS provider built in, but some may also support other JMS providers. Regardless of how the EJB 2.0 vendor provides the JMS service, having one is a requirement if the vendor expects to support message-driven beans. The advantage of this forced adoption of JMS is that EJB developers can expect to have a working JMS provider on which messages can be both sent and received.

JMS as a Resource

JMS is a standard vendor-neutral API that is part of the J2EE platform and can be used to access enterprise messaging systems. Enterprise messaging systems (a.k.a. message-oriented middleware) facilitate the exchange of messages among software applications over a network. JMS is analogous to JDBC: whereas JDBC is an API that can be used to access many different relational databases, JMS provides the same vendor-independent access to enterprise messaging systems. Many enterprise messaging products currently support JMS, including IBM's MQSeries, BEA's WebLogic JMS service, Sun Microsystems' iPlanet Message Queue, and Progress' SonicMQ, to name a few. Software applications that use the JMS API for sending or receiving messages are portable across brands of JMS vendors.

Java applications that use JMS are called JMS clients, and the messaging system that handles routing and delivery of messages is called the JMS provider. A JMS application is a business system composed of many JMS clients and, generally, one JMS provider.

A JMS client that sends a message is called a producer, while a JMS client that receives a message is called a consumer. A single JMS client can be both a producer and a consumer. When we use the term consumer or producer, we mean a JMS client that receives messages or sends messages, respectively.

In EJB, enterprise beans of all types can use JMS to send messages to various destinations. Those messages are consumed by other Java applications or message-driven beans. JMS facilitates sending messages from enterprise beans by using a messaging service, sometimes called a message broker or router. Message brokers have been around for a couple of decades--the oldest and most established being IBM's MQSeries--but JMS is fairly new and is specifically designed to deliver a variety of message types from one Java application to another.

Reimplementing the TravelAgent EJB with JMS

We can modify the TravelAgent EJB developed in Chapter 12 so that it uses JMS to alert some other Java application that a reservation has been made. The following code shows how to modify the bookPassage( ) method so that the TravelAgent EJB will send a simple text message based on the description information from the TicketDO object:

public TicketDO bookPassage(CreditCardDO card, double price)
    throws IncompleteConversationalState {
                   
    if (customer == null || cruise == null || cabin == null) {
        throw new IncompleteConversationalState(  );
    }
    try {
        ReservationHomeLocal resHome = (ReservationHomeLocal)
            jndiContext.lookup("java:comp/env/ejb/ReservationHomeLocal");
 
        ReservationLocal reservation =
            resHome.create(customer, cruise, cabin, price, new Date(  ));
                
        Object ref = jndiContext.lookup
            ("java:comp/env/ejb/ProcessPaymentHomeRemote");
 
        ProcessPaymentHomeRemote ppHome = (ProcessPaymentHomeRemote)
            PortableRemoteObject.narrow(ref, ProcessPaymentHomeRemote.class);
            
        ProcessPaymentRemote process = ppHome.create(  );
        process.byCredit(customer, card, price);
 
        TicketDO ticket = new TicketDO(customer,cruise,cabin,price);
 
        String ticketDescription = ticket.toString(  );
 
        TopicConnectionFactory factory = (TopicConnectionFactory)
            jndiContext.lookup("java:comp/env/jms/TopicFactory");
        
        Topic topic = (Topic)
            jndiContext.lookup("java:comp/env/jms/TicketTopic");
 
        TopicConnection connect = factory.createTopicConnection(  );
 
        TopicSession session = connect.createTopicSession(true,0);
 
        TopicPublisher publisher = session.createPublisher(topic);
 
        TextMessage textMsg = session.createTextMessage(  );
        textMsg.setText(ticketDescription);
        publisher.publish(textMsg);
        connect.close(  );
 
        return ticket;
    } catch(Exception e) {
        throw new EJBException(e);
    }
}

To be able to send a message, we needed to add a lot of new code. However, while it may look a little overwhelming at first, the basics of JMS are not all that complicated.

TopicConnectionFactory and Topic

In order to send a JMS message we need a connection to the JMS provider and a destination address for the message. The connection to the JMS provider is made possible by a JMS connection factory; the destination address of the message is identified by a Topic object. Both the connection factory and the Topic object are obtained from the TravelAgent EJB's JNDI ENC:

TopicConnectionFactory factory = (TopicConnectionFactory)
    jndiContext.lookup("java:comp/env/jms/TopicFactory");
        
Topic topic = (Topic)
    jndiContext.lookup("java:comp/env/jms/TicketTopic");

The TopicConnectionFactory in JMS is similar in function to the DataSource in JDBC. Just as the DataSource provides a JDBC connection to a database, the TopicConnectionFactory provides a JMS connection to a message router.¹

The Topic object itself represents a network-independent destination to which the message will be addressed. In JMS, messages are sent to destinations--either topics or queues--instead of directly to other applications. A Topic is analogous to an email list or newsgroup; any application with the proper credentials can receive messages from and send messages to a Topic. When a JMS client receives messages from a Topic, the client is said to subscribe to that Topic. JMS decouples applications by allowing them to send messages to each other through a destination, which serves as virtual channel. This example uses a Topic type destination, but JMS also supports Queue type destinations. The difference between these types is explained in more detail later.

TopicConnection and TopicSession

The TopicConnectionFactory is used to create a TopicConnection, which is an actual connection to the JMS provider...