"Developers have long faced the daunting task of moving data between heterogeneous systems. One impediment to exchanging information has been the difficulty of getting humans to agree on precisly how to exchange and format that data. Java Message Service solves part of this problem by providing a means of interacting with existing J2EE applications or legacy systems in a neutral manner."
"In this article I will provide a brief introduction to MDB and the J2EE Connector Architecture (JCA), examining how MDBs can be deployed with the JCA 1.5 resource adapter to use a JMS provider. I will also provide some best practices for using MDBs with resource adapters."
"As with all examples in this book, example code and instructions specific to several vendors is provided in the book download at O'Reilly's web site. You will need to install and configure your JMS provider according to the instructions provided by your vendor."
"JMS (Java Messaging Service) is an interface implemented by most J2EE containers in order to provide point-to-point queuing and topic-based (publish/subscribe) functionality. JMS is frequently used by enterprise and back-end applications for distributed communication and collaboration. PHP is a powerful scripting language popular for use with Apache's CGI facility. Although efforts are being made to develop PHP as a back-end scripting language, its use is still very much confined to front-end applications. Combining the strengths of PHP--easy and fast web development, and compatibility with many types of databases--with those of JMS, which is the standard for communication with back-end enterprise applications, creates a powerful and easy-to-use tool for both Java and PHP developers."
"These problems are created but unfortunately not solved through the Web services architecture. Web services must be combined with additional technology for robust enterprise messaging. One very strong candidate is the Java Message Service (JMS). JMS provides a reliable, scalable, and loosely coupled architecture for messaging. The combination of Web services with JMS creates an architecture that can communicate across the Internet, reliably handle data, and integrate with backend systems."
"These requirements are adequately met by the CORBA Notification products available from several messaging vendors. In response to the demonstrated need to integrate CORBA Notification and JMS, the OMG (Object Management Group) is currently working on standardizing interworking. Vendors such as PrismTech are also working ahead of the standards efforts to produce commercial solutions."
"XML is a non-proprietary way to represent data. But it's just a standard of data representation. As such it lacks the ability to move over the "wire". So the question becomes how to transport XML documents. JMS is an answer. It facilitates the transport of XML documents."
"The servlet will connect to the OpenJMS server, create a TopicPublisher using the topic form parameter, publish count messages, and then close the connection. On successful completion, the user should see the following response in their browser."
"This document explains how the power of EJBs can be leveraged using asynchronous Java Messaging technology. The document explains the limitations inherent in the EJB architecture and illustrates how (if you can't wait until EJB 2.0) you can use any JMS implementation to provide support for asynchronous EJB method invocation. In particular, the example code shows how this can be achieved using Fiorano's implementation of JMS. The reader is expected to be familiar with the basic concepts and working of JMS and EJB."
"Learn about some of the application architectural issues in applications that use messaging and JMS in general. This article examines state vs application decoupling in JMS applications, looks at synchronous vs asynchronous use cases, examines some architectural anti-patterns, and discusses the consequences of certain JMS topologies with respect to transactional requirements. It also recommends some better architectures and solutions."
"This article illustrates how to program using the new features of the Java Message Service (JMS) 1.1 API. The new features in JMS 1.1 are demonstrated through a sample application."
"The Java Message Service (JMS), which is designed by Sun Microsystems and several other companies under the Java Community Process as JSR 914, is the first enterprise messaging API that has received wide industry support. The Java Message Service (JMS) was designed to make it easy to develop business applications that asynchronously send and receive business data and events. It defines a common enterprise messaging API that is designed to be easily and efficiently supported by a wide range of enterprise messaging products. JMS supports both messaging models: point-to-point (queuing) and publish-subscribe."
"Project JXTA defines a set of protocols that can be used to construct peer-to-peer systems using any of the centralized, brokered and decentralized approaches. J2EE is intended for server-side computing, which suggests it is most suited for a centralized peer-to-peer system. A good way to get a better appreciation of the differences is to study a simple example application. This first article will introduce a very simple JMS chat application for the exchange of messages between users. The choice of a chat application is deliberate because Project JXTA already supplies a demonstration application called myJXTA (which is also known by its former name of InstantP2P) that includes a sophisticated chat capability."
"Messaging systems are used to build highly reliable, scalable, and flexible distributed applications. This article discusses messaging systems in general, providing an overview of their features and types, and then describes how developers can write message-based applications using Java Message Service (JMS)."
"This is the second of two articles that compare the peer-to-peer (P2P) features provided by the initial implementation of Project JXTA technology with those provided by the JavaTM Message Service (JMS). Part 1 introduced the concept of peer-to-peer computing and included some example code for a JMS application, JMSChat, to illustrate how you can develop a form of simple peer-to-peer application with existing messaging technology."
"Although the reasons for its complexity are sound, the relationships among JMS classes make writing code to the JMS API tedious and confusing at times. Applying the Facade pattern offers a solution to this problem."
"This article describes the process of developing with WMQ and JMS, focusing on point-to-point messaging. By walking through the following steps, it teaches how to use a Java class written with the JMS interfaces:"
"un Microsystems' Java Message Service (JMS) is about to have a huge impact on the messaging middleware business. This venerable industry, which provides the plumbing for transaction processing and data movement at many large IT sites, has been hobbled by proprietary vendor APIs to the middleware layer."
"The Need for Concurrency in EJB Concurrent processing in EJB is a necessity for various applications. For example, say you have a database containing various commodity prices. Each commodity has more than one price, so you want to identify the minimum price. Assume that identifying a minimum price requires exhaustive calculations, which are implemented by a SessionBean. The SessionBean has a method that accepts a commodity and finds its minimum price."
"This tutorial provides an overview of the Java Message Service (JMS) and offers the basics for developing programs that use it. JMS provides a way for Java? programs to access an enterprise messaging system, also known as message oriented middleware (MOM). MOM provides a mechanism for integrating applications in a loosely coupled, flexible manner by providing asynchronous delivery of data between applications in an indirect way through an intermediary. Note: This tutorial has been updated to include changes in JMS version 1.1."
"In this installment of J2EE pathfinder, we'll address each of these points. We'll start with an overview of enterprise messaging, where we'll look at the role of messaging in your enterprise, as well as some of the challenges in establishing reliable communication. Next, we'll take an architectural view, with a quick look at how J2EE messaging technologies work together with message-oriented middleware in a typical enterprise network. From there, we'll move into a more specific discussion of the Java Message Service (JMS), J2EE's messaging package. We'll review the basic goals and functions of each of the three types of J2EE messaging clients and you'll get an idea of where each one shines, and where it falls short. We'll close with a breakdown of common messaging scenarios and solutions, which will help you choose the best J2EE messaging solution for your enterprise."
"The Java Message Service (JMS) API is an integral element of the J2EE platform. JMS 1.0.2 defines two separate types of messaging domains, point-to-point and publish/subscribe. The latest version of JMS, version 1.1, which will be part of J2EE 1.4 and will be required by EJB 2.1, unifies these domains. With JMS 1.1, a client no longer has to be implemented specifically for one domain or the other. Instead, JMS clients can be implemented to work with destinations from either domain. This significantly simplifies the JMS API and offers developers an opportunity to create more general, reusable messaging code. Once JMS providers and J2EE containers that implement JMS 1.1 become available, developers of JMS client code should start using the version 1.1 APIs in their new code, and may also benefit from porting their existing JMS 1.0.2 code to the new APIs."
"As in the previous articles of this series, I use a simple example to demonstrate the features of Spring JMS. You'll follow along as I develop a point to point (P2P) message-based system, using the Spring JMS framework to integrate with IBM's WebSphere MQ through a JMS Interface. Upon completing the exercise, you'll be able to send and receive simple text messages through the system."
"At first it might seem strange to mention platform-neutral data in the same paragraph as Java technology. After all, why do we need platform-neutral data when we're using JMS, which is a Java-based (and therefore platform-neutral) technology?"
"When operated within Geronimo, ActiveMQ provides support for MDBs, which are EJBs that consume JMS messages. The asynchronous nature of JMS enables MDBs to be activated on demand by the container to perform work within the J2EE server on behalf of clients. Geronimo benefits greatly from ActiveMQ's rich client support. Unlike session or entity EJBs, MDBs are not called through rigid EJB interfaces. Instead, a client can invoke MDB services by simply sending a JMS message to a destination. This significantly simplifies the coding of clients that consume EJB-based services. In fact, Geronimo inherits the ability to provide services to non-J2EE clients -- those supported by the stand-alone ActiveMQ server."
"Designing an effective event-driven software system that can respond to real-time changes and events in a timely manner is a complex task. An SOA, together with an effective event-driven interaction framework using Java reflection, can reduce complexities and add flexibility. The Geronimo platform provides APIs and tools, including a JMS provider, that you can use to build a powerful event-driven interaction framework."
"The methods outlined in this article are by no means comprehensive. My goal is to get you started on the path to implementing vendor-neutral JMS solutions. Furthermore, these techniques ought to improve your ability to integrate changes as you absorb new JMS implementations."
"Over the last two years, JMS and message-driven beans (MDBs) have grown into a core J2EE? technology, providing a foundation for building loosely coupled components into J2EE applications. JMS and messaging have become a foundation for asynchronous "service-oriented applications." The WebSphere Application Server V6 messaging platform is built on top of the Service Integration Bus (SIB), which is an implementation of an Enterprise Service Bus (ESB), a new way of connecting different applications together enabling seamless integration between components."
"Clearly, one cannot have an application server without some sort of messaging solution. In fact, you literally can't have a J2EE application server without a messaging solution; an implementation of the JMS standard is a requirement of the J2EE specification. In Apache Geronimo technology, this is accomplished through the integration of software from the ActiveMQ project."
"JMS, the Java Message Service, is an API that allows Java applications to access a wide range of MQ servers (or, in JMS parlance, providers) through a standardized interface, just as JDBC allows programs to access many different database servers through a common interface. Most J2EE containers include a JMS provider; in the future, all J2EE containers will. JMS can also be used without a J2EE container; several stand-alone JMS provider implementations are available on the market. In addition, the EJB 2.0 specification introduces a new type of EJB -- the message-driven bean -- which makes it very easy to create message-driven components that make use of entity and session beans."
"Messaging System applications do not communicate directly (in comparison to traditional systems (RMI based)), but with the help of MOM. If one component of the system wants to send the message to another component, it sends the given message to MOM, and MOM then sends the message to the addressee."
"As explained in the previous lesson entitled Digital Signatures 101 using Java a variety of protocols are available for the use of public-key cryptography and digital signatures to protect the authenticity, integrity, and confidentiality of a message. That lesson explained a simple and easily understood protocol. However, it was pointed out in that lesson that an improved protocol can be achieved through the use of message digests. The purpose of this lesson is to explain how to create a message using the SHA-1 Secure Hash Algorithm."
"In this article, I'll provide an overview of the changes to the support for messaging introduced by the 1.4 release of the J2EE specification. In particular, I'll look at the requirement for JMS 1.1 and the new restrictions imposed on its use, at the new concepts relating to message destinations, and at the significant changes that version 2.1 of the EJB spec makes to message-driven beans. This material will be of particular interest to developers and administrators with a knowledge of messaging in J2EE 1.3 who are looking to write new applications or migrate existing messaging applications to a J2EE 1.4-compliant application server."
