Messaging is playing an increasingly important role in enterprise computing. Its advantages are a natural result of several factors: the trend towards peer-to-peer computing, greater platform heterogeneity, and greater modularity, coupled with the trend away from synchronous communication between processes.
In its effort to stay on top of important industry trends, Sun announced April 1998 (at the JavaOne Developer Conference) its plans to publish the Java Message Service (JMS) API, an interface for using existing enterprise messaging systems in a uniform manner. The version 1.0 specification, which was released in July, provides a set of interfaces and associated semantics that define how a JMS client accesses the facilities of an enterprise messaging product.
Since its release, almost twenty vendors have stepped up to endorse the specification (including companies like IBM, Oracle, and BEA) and many companies have produced implementations.
Table of Contents
1 Messaging and JMS
1.1 What is messaging?
1.2 Different types of message architectures
1.3 Existing JMS provider
2 Java Messaging Service API
2.1 Overview
2.2 What JMS does not include
2.3 JMS details
2.4 JMS message model
2.5 JMS common facilities
2.6 JMS point-to-point model
2.7 JMS publish/subscribe model
2.8 Remaining API
3 Overview Infomatec Messaging Queue
3.1 Overview
3.2 UML design
3.3 JNDI
3.4 RMI
4 The basic message system
4.1 Overview
4.2 Create connection
4.3 Send messages
4.4 Storing of objects
4.5 Receive messages
4.6 Close connection
5 Extension of IMQ
5.1 Acknowledgement
5.2 Basic Publish/Subscribe
5.3 Request/Reply
5.4 Message types
5.5 QueueBrowser
5.6 Error handling
5.7 Dynamic class loading
5.8 Distribution of class files
5.9 Log file
5.10 Authentification
5.11 Server command line
5.12 IMQ and Applets
6 Administration
6.1 Properties files
6.2 Administrative objects
6.3 Administration tool
7 The Infomatec package
7.1 JNDI browser
7.2 ServerInfo
7.3 IMQ dependent administrative objects
8 Using and testing IMQ
8.1 Setting up the system
8.2 Example and test programs
9 Enhancements
9.1 Remaining Features
9.2 Sockets
9.3 RMI over IIOP
9.4 Multiple server system
9.5 RMI and firewalls
Research Objectives and Themes
This master thesis aims to evaluate the Java Message Service (JMS) API version 1.0.2 and provides a functional implementation (IMQ) that supports key enterprise messaging features. The research explores the design and realization of a robust middleware solution, including wire protocols and message handling mechanisms.
- Evaluation of existing JMS middleware specifications and providers.
- Implementation of point-to-point and publish/subscribe messaging models.
- Integration of RMI and Sockets for efficient network communication.
- Development of administrative tools and JNDI-based object management.
Excerpt from the Book
2.3.1 Architecture
A JMS application is composed of the following parts:
JMS Clients – These are the Java language programs that send and receive messages.
Non-JMS Clients – These are clients that use a message systems native client API instead of JMS. If the application predated the availability of JMS it is likely that it will include both JMS and non-JMS clients.
Messages – Each application defines a set of messages that are used to communicate information between its clients.
JMS Provider – This is a messaging system that implements JMS in addition to the other administrative and control functionality required of a full featured messaging product.
Administered Objects – Administered objects are preconfigured JMS objects created by an administrator for the use of clients.
Summary of Chapters
1 Messaging and JMS: Introduces the fundamentals of messaging in enterprise computing and discusses the role and goal of the JMS API specification.
2 Java Messaging Service API: Defines the core architectural components of JMS, including clients, providers, and message delivery models like Point-to-Point and Publish/Subscribe.
3 Overview Infomatec Messaging Queue: Outlines the development goals for the IMQ prototype, detailing the use of JNDI, RMI, and UML-based design notations.
4 The basic message system: Describes the architectural planning and implementation steps for connecting clients to the server and handling message distribution.
5 Extension of IMQ: Covers advanced features added to the base system, including acknowledgement modes, request/reply patterns, and error handling.
6 Administration: Explains the configuration management of the IMQ system through properties files and dedicated administrative objects.
7 The Infomatec package: Details custom extensions like JNDI browser functionality and provider-specific configurations.
8 Using and testing IMQ: Provides guidance on setting up the environment and summarizes results from performance tests of the implementation.
9 Enhancements: Discusses potential future improvements, such as socket-based protocols, RMI over IIOP, and strategies for handling firewalls.
Keywords
Java Message Service, JMS, Messaging Middleware, Point-to-Point, Publish/Subscribe, JNDI, RMI, Sockets, Software Architecture, Distributed Systems, Enterprise Application, Message Queue, API Implementation, Network Protocols
Frequently Asked Questions
What is the core focus of this thesis?
The work focuses on the evaluation and practical implementation of the Java Message Service (JMS) API version 1.0.2 to create a functional enterprise messaging prototype.
Which messaging models are supported?
The implementation supports both primary JMS models: the Point-to-Point (PTP) model and the Publish/Subscribe (Pub/Sub) model.
What is the primary objective?
The main goal is to deliver a stable messaging platform (IMQ) that provides a unified interface for developers while supporting multiple wire protocols.
What methodology was applied for the implementation?
The development followed a rigorous UML-based design process, ensuring modularity and adherence to established industry design patterns.
What are the primary technical components covered in the main section?
The main sections address connection management, message storage strategies, concurrent thread processing, and administrative configuration via JNDI.
Which keywords summarize the document?
Key terms include JMS, Middleware, Distributed Systems, RMI, Sockets, and JNDI.
How does the prototype handle server crashes?
The system utilizes features like the unreferenced() method in RMI to detect client failures and ensure that resources are cleaned up appropriately.
Is the IMQ system capable of operating through firewalls?
The thesis explores HTTP tunneling as a solution to allow RMI-based communication to traverse firewalls, although it notes specific limitations regarding callback functionality.
- Quote paper
- Michael Dempfle (Author), 2000, Evaluation and Implementation of the Java Messaging Service (JMS), Munich, GRIN Verlag, https://www.grin.com/document/32274