Java Message Service

184 Pages·2001·1.067 MB·English

by  Richard Monson-Haefel, David Chappell

Java Message Service
Richard Monson-Haefel
David A. Chappell

Publisher: O'Reilly

First Edition January 2001

ISBN: 0-596-00068-5, 238 pages

This book is a thorough introduction to Java Message Service (JMS) from Sun
Microsystems. It shows how to build applications using the point-to-point and publish-and-
subscribe models; use features like transactions and durable subscriptions to make
applications reliable; and use messaging within Enterprise JavaBeans. It also introduces a
new EJB type, the MessageDrivenBean, that is part of EJB 2.0, and discusses integration

of messaging into J2EE.
Team[oR]
Table of Contents
Preface..............................................................................................................................1
What Is the Java Message Service?.................................................................................1
Who Should Read This Book?........................................................................................1
Organization...................................................................................................................2
Software and Versions....................................................................................................3
Conventions ...................................................................................................................4
Comments and Questions...............................................................................................4
Acknowledgments..........................................................................................................5

Chapter 1. Understanding the Messaging Paradigm......................................................6
1.1 Enterprise Messaging................................................................................................7
1.2 The Java Message Service (JMS)..............................................................................9
1.3 Application Scenarios.............................................................................................11
1.4 RPC Versus Asynchronous Messaging ...................................................................15

Chapter 2. Developing a Simple Example.....................................................................19
2.1 The Chat Application..............................................................................................19

Chapter 3. Anatomy of a JMS Message.........................................................................33
3.1 Headers...................................................................................................................34
3.2 Properties................................................................................................................38
3.3 Message Selectors...................................................................................................40
3.4 Message Types.......................................................................................................42

Chapter 4. Publish-and-Subscribe Messaging...............................................................53
4.1 Getting Started with the B2B Application...............................................................53
4.2 Temporary Topics...................................................................................................60
4.3 Durable Subscriptions.............................................................................................61
4.4 Publishing the Message Persistently........................................................................63
4.5 JMSCorrelationID...................................................................................................64
4.6 Request and Reply..................................................................................................65
4.7 Unsubscribing.........................................................................................................68

Chapter 5. Point-to-Point Messaging.............................................................................69
5.1 Point-to-Point and Publish-and-Subscribe...............................................................69
5.2 The QWholesaler and QRetailer..............................................................................71
5.3 Creating a Queue Dynamically ...............................................................................78
5.4 Load Balancing Using Multiple QueueSessions......................................................79
5.5 Examining a Queue.................................................................................................80

Chapter 6. Guaranteed Messaging, Transactions, Acknowledgments & Failures......84
6.1 Guaranteed Messaging............................................................................................84
6.2 Message Acknowledgments....................................................................................85
6.3 Message Groups and Acknowledgment...................................................................91
6.4 Transacted Messages..............................................................................................95
6.5 Lost Connections..................................................................................................104
6.6 Dead Message Queues..........................................................................................106
Chapter 7. Deployment Considerations.......................................................................108
7.1 Performance, Scalability, and Reliability..............................................................108
7.2 To Multicast or Not to Multicast...........................................................................112
7.3 Security................................................................................................................116
7.4 Connecting to the Outside World..........................................................................118
7.5 Bridging to Other Messaging Systems..................................................................120

Chapter 8. J2EE, EJB, and JMS..................................................................................122
8.1 J2EE Overview.....................................................................................................122
8.2 J2EE: A United Platform......................................................................................125
8.3 The JMS Resource in J2EE...................................................................................126
8.4 The New Message-Driven Bean in EJB 2.0...........................................................128

Chapter 9. JMS Providers............................................................................................133
9.1 IBM: MQSeries....................................................................................................133
9.2 Progress: SonicMQ...............................................................................................134
9.3 Fiorano: FioranoMQ.............................................................................................135
9.4 Softwired: iBus.....................................................................................................136
9.5 Sun Microsystems: Java Message Queue..............................................................138
9.6 BEA: WebLogic Server........................................................................................139
9.7 ExoLab: OpenJMS................................................................................................140
Appendix A. The Java Message Service API...............................................................141
A.1 Common Facilities...............................................................................................141
A.2 Point-to-Point API...............................................................................................150
A.3 Publish-and-Subscribe API..................................................................................153

Appendix B. Message Headers.....................................................................................156

Appendix C. Message Properties.................................................................................167
C.1 Property Names....................................................................................................167
C.2 Property Values....................................................................................................167
C.3 Read-Only Properties...........................................................................................169
C.4 Property Value Conversion..................................................................................169
C.5 Nonexistent Properties.........................................................................................171
C.6 Property Iteration.................................................................................................171
C.7 JMS-Defined Properties.......................................................................................171
C.8 Provider-Specific Properties.................................................................................173

Appendix D. Message Selectors....................................................................................174
D.1 Identifiers............................................................................................................174
D.2 Literals.................................................................................................................174
D.3 Comparison Operators.........................................................................................175
D.4 Arithmetic Operators............................................................................................177
D.5 Declaring a Message Selector..............................................................................178
D.6 Not Delivered Semantics......................................................................................179

Colophon.......................................................................................................................180
Java Message Service
Preface
What Is the Java Message Service?
When Java™ was first introduced, most of the IT industry focused on its graphical user
interface characteristics and the competitive advantage it offered in terms of distribution
and platform independence. Today, the focus has broadened considerably: Java has been
recognized as an excellent platform for creating enterprise solutions, specifically for
developing distributed server-side applications. This shift has much to do with Java's
emerging role as a universal language for producing implementation-independent
abstractions for common enterprise technologies. The JDBC™ API is the first and most
familiar example. JDBC provides a vendor-independent Java interface for accessing SQL
relational databases. This abstraction has been so successful that it's difficult to find a
relational database vendor that doesn't support JDBC. Java abstractions for enterprise
technologies have expanded considerably to include JNDI (Java Naming and Directory
Interface™) for abstracting directory services, JMX (Java Management Extensions) for
abstracting access to computer devices on a network, and JMS™ (Java Message Service)
for abstracting access to different Message-Oriented Middleware products.
JMS has quickly become a de facto industry standard. In its second version, most
enterprise messaging vendors now support the JMS specification, making for a large
selection of JMS providers to choose from.
The Java Message Service is a Java API implemented by enterprise messaging vendors to
provide Java applications with a common and elegant programming model that is portable
across messaging systems. Enterprise messaging systems are used to send notification of
events and data between software applications. There are two common programming
models supported by the JMS API: publish-and-subscribe and point-to-point. Each model
provides benefits and either or both may be implemented by JMS providers.
JMS and enterprise messaging systems provide Java developers with an asynchronous
messaging system that allows systems to interact without requiring them to be tightly
coupled. Messages can be delivered to systems that are not currently running and
processed when it's convenient. The decoupled, asynchronous characteristics of enterprise
messaging make JMS an extremely powerful and critical enterprise API. JMS is used by
Java developers in Enterprise Application Integration, Business-to-Business (B2B)
projects, and distributed computing in general.
As JMS quickly moves into the forefront as one of the most important J2EE technologies,
understanding how JMS works and when to use it will become the hallmark of the most
successful distributed computing professionals. Choosing to read this book to learn about
JMS may be one of the smartest career moves you ever make.
Who Should Read This Book?
This book explains and demonstrates the fundamentals of the Java Message Service. This
book provides a straightforward, no-nonsense explanation of the underlying technology,
Java classes and interfaces, programming models, and various implemenations of the JMS
specification.
1
Java Message Service
Although this book focuses on the fundamentals, it's no "dummy's" book. While the JMS
API is easy to learn, the API abstracts fairly complex enterprise technology. Before
reading this book, you should be fluent with the Java language and have some practical
experience developing business solutions. Experience with messaging systems is not
required, but you must have a working knowledge of the Java language. If you are
unfamiliar with the Java language, we recommend that you pick up a copy of Learning
Java™ by Patrick Neimeyer and Jonathan Knudsen (O'Reilly). If you need a stronger
background in distributed computing, we recommend Java™ Distributed Computing by
Jim Farley (O'Reilly).
Organization
Here's how the book is structured. The first chapter explains messaging systems,
centralized and distributed architectures, and how and why JMS is important. Chapter 2
through Chapter 5 go into detail about developing JMS clients using the two messaging
models, publish-and-subscribe and point-to-point. Chapter 6 and Chapter 7 should be
considered "advanced topics," covering deployment and administration of messaging
systems. Chapter 8 is an overview of the Java™ 2, Enterprise Edition (J2EE) with regard
to JMS, including coverage of the new message-driven bean in Enterprise JavaBeans 2.0.
Finally, Chapter 9 provides a summary of several JMS vendors and their products.
Chapter 1
Defines enterprise messaging and common architectures used by messaging vendors.
JMS is defined and explained, as are its two programming models, publish-and-
subscribe and point-to-point.
Chapter 2
Walks the reader through the development of a simple publish-and-subscribe JMS
client.
Chapter 3
Provides a detailed examination of the JMS message, the most important part of the
JMS API.
Chapter 4
Examines the publish-and-subscribe programming model through the development
of a B2B JMS application.
Chapter 5
Examines the point-to-point programming models through the enhancement of the
B2B JMS application developed in Chapter 4.
2
Java Message Service
Chapter 6
Provides an in-depth explanation of advanced topics, including guaranteed
messaging, transactions, acknowledgments, and failures.
Chapter 7
Provides an in-depth examination of features and issues that should be considered
when choosing vendors and deploying JMS applications.
Chapter 8
Provides an overview of the Java™ 2, Enterprise Edition (J2EE) with regard to JMS,
and also includes coverage of the new JMS-based bean in Enterprise JavaBeans 2.0.
Chapter 9
Provides a summary of several JMS vendors and their products, including: IBM's
MQSeries, Progress' SonicMQ, Fiorano's FioranoMQ, Softwired's iBus, Sun's JMQ,
BEA's WebLogic, and Exolab's OpenJMS.
Appendix A
Provides a quick reference to the classes and interfaces defined in the JMS package.
Appendix B
Provides detailed information about message headers.
Appendix C
Provides detailed information about message properties.
Appendix D
Provides detailed information about message selectors.
Software and Versions
This book covers the Java Message Service Version 1.0.2. It uses Java language features
from the Java 1.1 platform. Because the focus of this book is to develop vendor-
independent JMS clients and applications, we have stayed away from proprietary
extensions and vendor-dependent idioms. Any JMS-compliant provider can be used with
this book; you should be familiar with that provider's specific installation, deployment, and
runtime management procedures to work with the examples. To find out the details of
installing and running JMS clients for a specific JMS provider, consult your JMS vendor's
documentation; these details aren't covered by the JMS specification.
3
Java Message Service
Examples developed in this book are available through the book's catalog page at
http://www.oreilly.com/catalog/javmesser/examples. The examples are organized by
chapter. Special source code modified for specific vendors is also provided. These vendor-
specific examples include a readme.txt file that points to documentation for downloading
and installing the JMS provider, as well as specific instructions on setting up the provider
for each example.
Conventions
Italic is used for filenames, pathnames, hostnames, domain names, URLs, email addresses,
and new terms where they are defined.
is used for code examples and fragments, class, variable, and method
Constant width
names, Java keywords used within the text, SQL commands, table names, column names,
and XML elements and tags.
is used for emphasis in some code examples.
Constant width bold
is used to indicate text that is replaceable.
Constant width italic
The term "JMS provider" is used to refer to a vendor that implements the JMS API to
provide connectivity to their enterprise messaging service. The term "JMS client" refers to
Java components or applications that use the JMS API and a JMS provider to send and
receive messages. "JMS application" refers to any combination of JMS clients that work
together to provide a software solution.
Comments and Questions
We have tested and verified the information in this book to the best of our ability, but you
may find that features have changed (or even that we have made mistakes!). Please let us
know about any errors you find, as well as your suggestions for future editions, by writing
to:
O'Reilly & Associates, Inc.
101 Morris Street
Sebastopol, CA 95472
[phone] (in the United States or Canada)
[phone] (international or local)
[phone] (fax)
We have a web page for this book, where we list errata, examples, or any additional
information. You can access this page at:
http://www.oreilly.com/catalog/javmesser/
To comment or ask technical questions about this book, send email to:
[email protected]
4
Java Message Service
For more information about our books, conferences, software, Resource Centers, and the
O'Reilly Network, see our web site at:
http://www.oreilly.com
Richard Monson-Haefel maintains a web site for the discussion of JMS and related
distributed computing technologies (http://www.jMiddleware.com). jMiddleware.com
provides news about this book as well as code tips, articles, and an extensive list of links to
JMS resources.
David Chappell hosts a similar site, the SonicMQ Developers Exchange, which can be
found at http://www.sonicmq.com/developers/.
Acknowledgments
While there are only two names on the cover of this book, the credit for its development
and delivery is shared by many individuals. Michael Loukides, our editor, was pivotal to
the success of this book. Without his experience, craft, and guidance, this book would not
have been possible.
Many expert technical reviewers helped ensure that the material was technically accurate
and true to the spirit of the Java Message Service. Of special note are Joseph Fialli, Anne
Thomas Manes, and Chris Kasso of Sun Microsystems, Andrew Neumann and Giovanni
Boschi of Progress, Thomas Haas of Softwired, Mikhail Rizkin of International Systems
Group, and Jim Alateras of ExoLab. The contributions of these technical experts are
critical to the technical and conceptual accuracy of this book. They brought a combination
of industry and real-world experience to bear, and helped to make this the best book on
JMS published today.
Thanks also to Mark Hapner of Sun Microsystems, the primary architect of Java 2,
Enterprise Edition, who answered several of our most complex questions. Thanks to all the
participants in the JMS-INTEREST mailing list hosted by Sun Microsystems for their
interesting and informative postings.

5
Java Message Service
Chapter 1. Understanding the Messaging Paradigm
Computers and people can communicate by using messaging systems to exchange
messages over electronic networks. The most ubiquitous messaging system today is email,
which facilitates communication among people. While email is an important human-to-
human messaging system, this book is not about email. Instead, this book is concerned
with messaging systems that allow different software applications to communicate with
each other. These application-to-application messaging systems, when used in business
systems, are generically referred to as enterprise messaging systems, or Message-Oriented
Middleware (MOM).
Enterprise messaging systems allow two or more applications to exchange information in
the form of messages. A message, in this case, is a self-contained package of business data
and network routing headers. The business data contained in a message can be anything -
depending on the business scenario - and usually contains information about some
business transaction. In enterprise messaging systems, messages inform an application of
some event or occurrence in another system.
Using Message-Oriented Middleware, messages are transmitted from one application to
another across a network. MOM products ensure that messages are properly distributed
among applications. In addition, MOMs usually provide fault tolerance, load balancing,
scalability, and transactional support for enterprises that need to reliably exchange large
quantities of messages.
MOM vendors use different message formats and network protocols for exchanging
messages, but the basic semantics are the same. An API is used to create a message, give it
a payload (application data), assign it routing information, and then send the message. The
same API is used to receive messages produced by other applications.
In all modern enterprise messaging systems, applications exchange messages through
virtual channels called destinations. When a message is sent, it's addressed to a destination,
not a specific application. Any application that subscribes or registers an interest in that
destination may receive that message. In this way, the applications that receive messages
and those that send messages are decoupled. Senders and receivers are not bound to each
other in any way and may send and receive messages as they see fit.
All MOM vendors provide application developers with an API for sending and receiving
messages. While a MOM vendor implements its own networking protocols, routing, and
administration facilities, the basic semantics of the developer API provided by different
MOMs are the same. This similarity in APIs makes the Java Message Service possible.
The Java Message Service (JMS) is a vendor-agnostic Java API that can be used with
many different MOM vendors. JMS is analogous to JDBC in that application developers
reuse the same API to access many different systems. If a vendor provides a compliant
service provider for JMS, then the JMS API can be used to send and receive messages to
that vendor. For example, you can use the same JMS API to send messages using Progress'
SonicMQ as you do IBM's MQSeries. It is the purpose of this book to explain how
enterprise messaging systems work and in particular how the Java Message Service is used
6