Misplaced Pages

Jakarta Messaging: Difference between revisions

Article snapshot taken from Wikipedia with creative commons attribution-sharealike license. Give it a read and then ask your questions in the chat. We can research this topic together.
Browse history interactively← Previous editContent deleted Content addedVisualWikitext
Revision as of 13:37, 9 March 2008 editWerdan7 (talk | contribs)Pending changes reviewers, Rollbackers4,464 editsm Reverted edits by 122.169.14.159 (talk) to last version by Shadanan← Previous edit Latest revision as of 09:29, 24 November 2024 edit undoDujo (talk | contribs)Extended confirmed users1,082 edits →Provider implementations: Simplify wiki link 
(405 intermediate revisions by more than 100 users not shown)
Line 1: Line 1:
{{Short description|Java application programming interface}}
{{Cleanup|date=February 2007}}
The '''Jakarta Messaging''' API (formerly '''Java Message Service''' or '''JMS''' API) is a ] ] (API) for ]. It provides generic messaging models, able to handle the ], that can be used to facilitate the sending and receiving of messages between ]s.<ref>Curry, Edward. 2004. . In Middleware for Communications, ed. Qusay H Mahmoud, 1-28. Chichester, England: John Wiley and Sons. {{doi|10.1002/0470862084.ch1}}. {{ISBN|978-0-470-86206-3}}</ref> Jakarta Messaging is a part of ] and was originally defined by a specification developed at Sun Microsystems before being guided by the ].<ref>{{cite web |url=https://jcp.org/en/jsr/detail?id=914 |title=JSR 914: Java Message Service (JMS) API |website=The Java Community Process Program |access-date=July 31, 2018}}</ref>

The '''Java Message Service''' ('''JMS''') ] is a ] ] (MOM) API for sending messages between two or more ]. JMS is a part of the ], and is defined by a specification developed under the ] as JSR 914.


== General idea of messaging == == General idea of messaging ==
{{seealso|Message-oriented middleware|Message passing}} {{See also|Message-oriented middleware|Message passing}}

Messaging is a form of ] distributed communication, where in this context the term 'communication' can be understood as an exchange of messages between software components. Message-oriented technologies attempt to relax ''tightly coupled'' communication (such as ] network ], ] or ]) by the introduction of an intermediary component, which in this case would be a queue. The latter approach allow software components to communicate 'indirectly' with each other. Benefits of this include message senders not needing to have precise knowledge of their receivers, since communication is performed using the queue.
Messaging is a form of '']'' distributed communication, where in this context the term 'communication' can be understood as an exchange of messages between software components. Message-oriented technologies attempt to relax ''tightly coupled'' communication (such as ] network ], ] or ]) by the introduction of an intermediary component. This approach allows software components to communicate with each other indirectly. Benefits of this include message senders not needing to have precise knowledge of their receivers.

The advantages of messaging include the ability to integrate heterogeneous platforms, reduce system bottlenecks, increase scalability, and respond more quickly to change.<ref>Richards et al., pages 3–5.</ref>

=== Version history ===


* '''JMS 1.0'''<ref name="jms-101-spec" />
== Version history ==
* '''JMS 1.0.1''' (October 5, 1998)<ref name="jms-101-spec">{{cite web |url=http://java.sun.com/products/jms/jms-101-spec.pdf |title=Java Message Service |date=October 5, 1998 |publisher=] |archive-url=https://web.archive.org/web/19990224001845/http://java.sun.com/products/jms/jms-101-spec.pdf |archive-date=1999-02-24 |access-date=July 31, 2018 |url-status=live }}</ref>
* '''JMS 1.0.2b''' (], ])
* '''JMS 1.0.1a''' (October 30, 1998)<ref>{{cite web |url=http://java.sun.com/products/jms/docs.html |title=Java Message Service Documentation |date=October 30, 1998 |publisher=Sun Microsystems |archive-url=https://web.archive.org/web/19990224001845/http://java.sun.com/products/jms/docs.html |archive-date=1999-02-24 |access-date=July 31, 2018 |url-status=live }}</ref><ref>{{cite web |url=http://www.javasoft.com/products/jms/jms-101a-src.zip |title=Java Message Service Source - Version 1.0.1a |date=October 29, 1998 |publisher=Sun Microsystems |archive-url=https://web.archive.org/web/20000816170233/http://www.javasoft.com/products/jms/jms-101a-src.zip |archive-date=August 16, 2000 |access-date=July 31, 2018 |format=ZIP |url-status=dead }}</ref>
* '''JMS 1.1''' (], ])
* '''JMS 1.0.2''' (December 17, 1999)<ref>{{cite web |url=http://java.sun.com/products/jms/jms1_0_2-spec.pdf |title=Java Message Service |date=November 9, 1999 |publication-date=December 17, 1999 |publisher=Sun Microsystems |archive-url=https://web.archive.org/web/20000823085445/http://java.sun.com/products/jms/jms1_0_2-spec.pdf |archive-date=2000-08-23 |access-date=July 31, 2018 |url-status=live }}</ref>
* '''JMS 1.0.2a''' (December 23, 1999)<ref>{{cite web |url=http://java.sun.com/products/jms/docs.html |title=Java Message Service Documentation |date=December 23, 1999 |publisher=Sun Microsystems |archive-url=https://web.archive.org/web/20000229161639/http://java.sun.com/products/jms/docs.html |archive-date=2000-02-29 |access-date=July 31, 2018 |url-status=live }}</ref>
* '''JMS 1.0.2b''' (August 27, 2001)<ref>{{cite web |url=http://download.oracle.com/otn-pub/jcp/7543-jms-1.0.2b-spec-oth-JSpec/jms-1_0_2b-spec.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://download.oracle.com/otn-pub/jcp/7543-jms-1.0.2b-spec-oth-JSpec/jms-1_0_2b-spec.pdf |archive-date=2022-10-09 |url-status=live |title=Java Message Service |date=August 27, 2001 |publisher=Sun Microsystems |access-date=July 31, 2018}}</ref>
* '''JMS 1.1''' (April 12, 2002)<ref>{{cite web |url=https://github.com/javaee/jms-spec/raw/9383d33ff79a156d09fb5c9c0ccdfd6b844b1d54/jms1.1/specification/jms-1_1-fr-spec.pdf |archive-url=https://ghostarchive.org/archive/20221009/https://github.com/javaee/jms-spec/raw/9383d33ff79a156d09fb5c9c0ccdfd6b844b1d54/jms1.1/specification/jms-1_1-fr-spec.pdf |archive-date=2022-10-09 |url-status=live |title=Java Message Service |date=April 12, 2002 |publisher=Sun Microsystems |access-date=July 31, 2018}}</ref>
* '''JMS 2.0''' (May 21, 2013)<ref>{{cite web |url=https://github.com/javaee/jms-spec/raw/9383d33ff79a156d09fb5c9c0ccdfd6b844b1d54/jms2.0/specification/word/JMS20.pdf |archive-url=https://ghostarchive.org/archive/20221009/https://github.com/javaee/jms-spec/raw/9383d33ff79a156d09fb5c9c0ccdfd6b844b1d54/jms2.0/specification/word/JMS20.pdf |archive-date=2022-10-09 |url-status=live |title=Java Message Service |date=March 20, 2013 |publisher=] |access-date=July 31, 2018}}</ref><ref>{{cite web |url=https://javaee.github.io/jms-spec/pages/JMS20FinalRelease |title=JMS 2.0 Final Release |date=June 9, 2017 |website=Java Message Service Specification |access-date=July 31, 2018}}</ref>
* '''JMS 2.0a''' (March 16, 2015)<ref>{{cite web |url=https://github.com/javaee/jms-spec/raw/9383d33ff79a156d09fb5c9c0ccdfd6b844b1d54/jms2.0a/specification/word/JMS20.pdf |archive-url=https://ghostarchive.org/archive/20221009/https://github.com/javaee/jms-spec/raw/9383d33ff79a156d09fb5c9c0ccdfd6b844b1d54/jms2.0a/specification/word/JMS20.pdf |archive-date=2022-10-09 |url-status=live |title=Java Message Service |date=March 10, 2015 |publisher=Oracle |access-date=July 31, 2018}}</ref><ref>{{cite web |url=https://javaee.github.io/jms-spec/pages/JMS20RevA |title=JMS 2.0 errata release (Rev a) |date=July 5, 2017 |website=Java Message Service Specification |access-date=July 31, 2018}}</ref>

JMS 2.0 is currently maintained under the ] as ] 343.<ref>{{cite web |url=https://jcp.org/en/jsr/detail?id=343 |title=JSR 343: Java Message Service 2.0 |website=The Java Community Process Program |access-date=July 31, 2018}}</ref>

JMS 3.0 is under early development as part of Jakarta EE.<ref>{{cite web |url=https://www.tomitribe.com/blog/jms-3-0-get-involved/ |title=JMS 3.0: Get Involved! |website=Tomitribe |first=Richard |last=Monson-Haefel |date=December 6, 2018 |access-date=July 17, 2020}}</ref>


== Elements == == Elements ==

The following are JMS elements:
The following are JMS elements:<ref name="oraclejms"></ref>


; JMS provider ; JMS provider
: An implementation of the JMS interface for a ] (MOM). Providers are implemented as either a Java JMS implementation or an adapter to a non-Java MOM. : An implementation of the JMS interface for message-oriented middleware (MOM). Providers are implemented as either a Java JMS implementation or an adapter to a non-Java MOM.
; JMS client ; JMS client
: An application or process that produces and/or receives messages. : An application or process that produces and/or receives messages.
; JMS producer ; JMS producer/publisher
: A JMS client that creates and sends messages. : A JMS client that creates and sends messages.
; JMS consumer ; JMS consumer/subscriber
: A JMS client that receives messages. : A JMS client that receives messages.
; JMS message ; JMS message
: An object that contains the data being transferred between JMS clients. : An object that contains the data being transferred between JMS clients.
; JMS queue ; JMS queue
: A staging area that contains messages that have been sent and are waiting to be read. As the name ''queue'' suggests, the messages are delivered in the order sent. A message is removed from the queue once it has been read. : A staging area that contains messages that have been sent and are waiting to be read (by only one consumer). As the name queue suggests, the messages are delivered in the order sent. A JMS queue guarantees that each message is processed only once.
; JMS topic ; JMS topic
: A distribution mechanism for publishing messages that are delivered to multiple subscribers. : A distribution mechanism for publishing messages that are delivered to multiple subscribers.


== Models == == Models ==
The JMS API supports two models: The JMS API supports two distinct models:
* Point-to-point
* ] or queuing model
* ] model * Publish-and-subscribe


===Point-to-point model===
In the point-to-point or queuing model, a ''producer'' posts messages to a particular queue and a ''consumer'' reads messages from the queue. Here, the producer knows the destination of the message and posts the message directly to the consumer's queue. It is characterized by following:
Under the ''point-to-point'' messaging system, messages are routed to individual consumers who maintain queues of incoming messages. This messaging type is built on the concept of ]s, senders, and receivers. Each message is addressed to a specific queue, and the receiving clients extract messages from the queues established to hold their messages. While any number of producers can send messages to the queue, each message is guaranteed to be delivered, and consumed by one consumer. Queues retain all messages sent to them until the messages are consumed or until the messages expire. If no consumers are registered to consume the messages, the queue holds them until a consumer registers to consume them.
* Only one consumer will get the message
* The producer does not have to be running at the time the consumer consumes the message, nor does the consumer need to be running at the time the message is sent
* Every message successfully processed is acknowledged by the consumer


===Publish-and-subscribe model===
The publish/subscribe model supports publishing messages to a particular message topic. ''Subscribers'' may register interest in receiving messages on a particular message topic. In this model, neither the ''publisher'' nor the subscriber know about each other. A good metaphor for it is anonymous bulletin board. The following are characteristics of this model:
The '']'' model supports publishing messages to a particular message "topic". ''Subscribers'' may register interest in receiving messages ''published'' on a particular message topic. In this model, neither the publisher nor the subscriber knows about each other. A good analogy for this is an anonymous bulletin board.
* Multiple consumers can get the message
* There is a timing dependency between publishers and subscribers. The publisher has to create a subscription in order for clients to be able to subscribe. The subscriber has to remain continuously active to receive messages, unless it has established a durable subscription. In that case, messages published while the subscriber is not connected will be redistributed whenever it reconnects.


* Zero or more consumers will receive the message.
Using Java, JMS provides a way of separating the application from the transport layer of providing data. The same Java ] can be used to communicate with different JMS providers by using the ] information for the desired provider. The classes first use a ''connection factory'' to connect to the queue or topic, and then use populate and send or publish the messages. On the receiving side, the clients then receive or subscribe to the messages.
* There is a timing dependency between publishers and subscribers. The publisher has to create a message topic for clients to subscribe. The subscriber has to remain continuously active to receive messages, unless it has established a durable subscription. In that case, messages published while the subscriber is not connected will be redistributed whenever it reconnects.


JMS provides a way of separating the application from the ] of providing data. The same Java ] can be used to communicate with different JMS providers by using the ] (JNDI) information for the desired provider. The classes first use a ''connection factory'' to connect to the queue or topic, and then use populate and send or publish the messages. On the receiving side, the clients then receive or subscribe to the messages.
== Application programming interface ==


== URI scheme ==
The JMS API is provided in the ] {{Javadoc:EE|package=javax.jms|javax/jms}}.
RFC 6167 defines a <code>jms:</code> ] for the Java Message Service.

=== {{Javadoc:EE|javax/jms|ConnectionFactory}} interface ===

An administered object that a client uses to create a connection to the JMS provider. JMS clients access the connection factory through portable interfaces so the code does not need to be changed if the underlying implementation changes. Administrators configure the connection factory in the Java Naming and Directory Interface (]) namespace so that JMS clients can look them up. Depending on the type of message, users will use either a queue connection factory or topic connection factory.

=== {{Javadoc:EE|javax/jms|Connection}} interface ===

Once a connection factory is obtained, a connection to a JMS provider can be created. A connection represents a communication link between the application and the messaging server. Depending on the connection type, connections allow users to create sessions for sending and receiving messages from a queue or topic.

=== {{Javadoc:EE|javax/jms|Destination}} interface ===

An administered object that encapsulates the identity of a message destination, which is where messages are delivered and consumed. It is either a queue or a topic. The JMS administrator creates these objects, and users discover them using ]. Like the connection factory, the administrator can create two types of destinations: queues for Point-to-Point and topics for Publish/Subscribe.

=== {{Javadoc:EE|javax/jms|MessageConsumer}} interface ===

An object created by a session. It receives messages sent to a destination. The consumer can receive messages synchronously (blocking) or asynchronously (non-blocking) for both queue and topic-type messaging.

=== {{Javadoc:EE|javax/jms|MessageProducer}} interface ===

An object created by a session that sends messages to a destination. The user can create a sender to a specific destination or create a generic sender that specifies the destination at the time the message is sent.

=== {{Javadoc:EE|javax/jms|Message}} interface ===

An object that is sent between consumers and producers; that is, from one application to another. A message has three main parts:
# A message header (required): Contains operational settings to identify and route messages
# A set of message properties (optional): Contains additional properties to support compatibility with other providers or users. It can be used to create custom fields or filters (selectors).
# A message body (optional): Allows users to create five types of messages (text message, map message, bytes message, stream message, and object message).

The message interface is extremely flexible and provides numerous ways to customize the contents of a message.

=== {{Javadoc:EE|javax/jms|Session}} interface ===

Represents a single-threaded context for sending and receiving messages. A session is single-threaded so that messages are serialized, meaning that messages are received one-by-one in the order sent. The benefit of a session is that it supports transactions. If the user selects transaction support, the session context holds a group of messages until the transaction is committed, then delivers the messages. Before committing the transaction, the user can cancel the messages using a rollback operation. A session allows users to create message producers to send messages, and message consumers to receive messages.


== Provider implementations == == Provider implementations ==


<!--****** <!--******
Misplaced Pages is not a repository for lists, directories or Advocacy of commercial products and/or websites; add only products that are notable enough to have their own Misplaced Pages article Misplaced Pages is not a repository for lists, directories or Advocacy of commercial products and/or websites; add only products that are notable enough to have their own Misplaced Pages article.
******--> ******-->


In order to use JMS, one must have a JMS provider that can manage the sessions and queues. There are ], ] and ] providers. To use JMS, one must have a JMS provider that can manage the sessions, queues and topics. Starting from Java EE version 1.4, a JMS provider has to be contained in ''all'' Java EE application servers. This can be implemented using the message inflow management of the ], which was first made available in that version.


'''Articles about open source providers''': The following is a list of common JMS providers:
* ] ]
* ] from The OpenJMS Group
* ] from ]
* ], from ]


* ]'s
'''Articles about proprietary providers:'''
* ]
* ]
* ]
* ]
* ], using ]<ref>{{cite web|title=Apache Qpid™: Open Source AMQP Messaging|url=http://qpid.apache.org/}}</ref>
* ] ] Java JMS from ]
* ] (formerly MQSeries, then WebSphere MQ)
* ] from ]
* ]'s Service Integration Bus (SIBus)<ref>{{cite web|last=Wallis|first=Graham|title=Choosing a messaging system: WebSphere MQ vs. the WebSphere Application Server Service Integration Bus|url=http://www.ibm.com/developerworks/websphere/library/techarticles/1109_wallis/1109_wallis.html|work=IBM developerWorks}}</ref>
* ] ... also available as ]
* ] and ] from ]
* ]
* ] from ] * ] from the ]
* ] from ] * ] from ]
* ] from ] (formerly MQSeries) * ] from the OpenJMS Group
* ] and ]
* PubSub+ from ]
* ] from ]
* ]<ref> {{cite web|title=TIBCO Product Documentation - TIBCO Enterprise Message Service|url=https://docs.tibco.com/products/tibco-enterprise-message-service}}</ref>


==See also==
* ]s
* ] &mdash; the concept underlying JMS
* ]
** ]
* Messaging technologies that do ''not'' implement the JMS API include:
** ] (AMQP) &mdash; standardized message queue protocol with multiple independent implementations
** ] (DDS) &mdash; An ] standardized real-time messaging system with over ten implementations that have demonstrated interoperability between publishers and subscribers
** ] &mdash; similar technology, implemented for ]


==References==
An exhaustive comparison matrix of JMS providers is available at: http://www.theserverside.com/reviews/matrix.tss
{{Reflist}}


==Further reading==
All Java EE application servers from version 1.4 and later are required to contain a JMS provider. This can be implemented using the message inflow management of the ], which was first made available in version 1.4.
* {{Cite book |first=Mark |last=Richards |author2=Richard Monson-Haefel |author3=David A. Chappell |year=2009 |title=Java Message Service, Second Edition |publisher=O'Reilly |isbn=978-0-596-52204-9}}


== External links == == External links ==
<!--***** No links to individual JMS implementations *****-->
*

*
{{Wikibooks|Java EE Programming|Java Message Service}}
* (JMS 1.0 and 1.1)
* {{Official website}}
*
{{DEFAULTSORT:Message Service}} *
* {{Javadoc:EE|package=javax.jms|javax/jms}} API ] documentation
*
*

{{Jakarta EE}}


] ]
] ]
] ]
]

==See also==
* ] - a book about using messaging, such as JMS, to integrate applications

Other types of messaging technologies, which do not implement the JMS API:
* ] - commoditized messaging service provided by ] for a per-use fee. It allows users to rent access to messaging without having to maintain their own server.
* ] - similar technology, implemented for ]

]
]
]
]
]
]
]
]
]
]
]
]

Latest revision as of 09:29, 24 November 2024

Java application programming interface

The Jakarta Messaging API (formerly Java Message Service or JMS API) is a Java application programming interface (API) for message-oriented middleware. It provides generic messaging models, able to handle the producer–consumer problem, that can be used to facilitate the sending and receiving of messages between software systems. Jakarta Messaging is a part of Jakarta EE and was originally defined by a specification developed at Sun Microsystems before being guided by the Java Community Process.

General idea of messaging

See also: Message-oriented middleware and Message passing

Messaging is a form of loosely coupled distributed communication, where in this context the term 'communication' can be understood as an exchange of messages between software components. Message-oriented technologies attempt to relax tightly coupled communication (such as TCP network sockets, CORBA or RMI) by the introduction of an intermediary component. This approach allows software components to communicate with each other indirectly. Benefits of this include message senders not needing to have precise knowledge of their receivers.

The advantages of messaging include the ability to integrate heterogeneous platforms, reduce system bottlenecks, increase scalability, and respond more quickly to change.

Version history

  • JMS 1.0
  • JMS 1.0.1 (October 5, 1998)
  • JMS 1.0.1a (October 30, 1998)
  • JMS 1.0.2 (December 17, 1999)
  • JMS 1.0.2a (December 23, 1999)
  • JMS 1.0.2b (August 27, 2001)
  • JMS 1.1 (April 12, 2002)
  • JMS 2.0 (May 21, 2013)
  • JMS 2.0a (March 16, 2015)

JMS 2.0 is currently maintained under the Java Community Process as JSR 343.

JMS 3.0 is under early development as part of Jakarta EE.

Elements

The following are JMS elements:

JMS provider
An implementation of the JMS interface for message-oriented middleware (MOM). Providers are implemented as either a Java JMS implementation or an adapter to a non-Java MOM.
JMS client
An application or process that produces and/or receives messages.
JMS producer/publisher
A JMS client that creates and sends messages.
JMS consumer/subscriber
A JMS client that receives messages.
JMS message
An object that contains the data being transferred between JMS clients.
JMS queue
A staging area that contains messages that have been sent and are waiting to be read (by only one consumer). As the name queue suggests, the messages are delivered in the order sent. A JMS queue guarantees that each message is processed only once.
JMS topic
A distribution mechanism for publishing messages that are delivered to multiple subscribers.

Models

The JMS API supports two distinct models:

  • Point-to-point
  • Publish-and-subscribe

Point-to-point model

Under the point-to-point messaging system, messages are routed to individual consumers who maintain queues of incoming messages. This messaging type is built on the concept of message queues, senders, and receivers. Each message is addressed to a specific queue, and the receiving clients extract messages from the queues established to hold their messages. While any number of producers can send messages to the queue, each message is guaranteed to be delivered, and consumed by one consumer. Queues retain all messages sent to them until the messages are consumed or until the messages expire. If no consumers are registered to consume the messages, the queue holds them until a consumer registers to consume them.

Publish-and-subscribe model

The publish-and-subscribe model supports publishing messages to a particular message "topic". Subscribers may register interest in receiving messages published on a particular message topic. In this model, neither the publisher nor the subscriber knows about each other. A good analogy for this is an anonymous bulletin board.

  • Zero or more consumers will receive the message.
  • There is a timing dependency between publishers and subscribers. The publisher has to create a message topic for clients to subscribe. The subscriber has to remain continuously active to receive messages, unless it has established a durable subscription. In that case, messages published while the subscriber is not connected will be redistributed whenever it reconnects.

JMS provides a way of separating the application from the transport layer of providing data. The same Java classes can be used to communicate with different JMS providers by using the Java Naming and Directory Interface (JNDI) information for the desired provider. The classes first use a connection factory to connect to the queue or topic, and then use populate and send or publish the messages. On the receiving side, the clients then receive or subscribe to the messages.

URI scheme

RFC 6167 defines a jms: URI scheme for the Java Message Service.

Provider implementations

To use JMS, one must have a JMS provider that can manage the sessions, queues and topics. Starting from Java EE version 1.4, a JMS provider has to be contained in all Java EE application servers. This can be implemented using the message inflow management of the Java EE Connector Architecture, which was first made available in that version.

The following is a list of common JMS providers:

See also

References

  1. Curry, Edward. 2004. "Message-Oriented Middleware". In Middleware for Communications, ed. Qusay H Mahmoud, 1-28. Chichester, England: John Wiley and Sons. doi:10.1002/0470862084.ch1. ISBN 978-0-470-86206-3
  2. "JSR 914: Java Message Service (JMS) API". The Java Community Process Program. Retrieved July 31, 2018.
  3. Richards et al., pages 3–5.
  4. ^ "Java Message Service" (PDF). Sun Microsystems. October 5, 1998. Archived (PDF) from the original on 1999-02-24. Retrieved July 31, 2018.
  5. "Java Message Service Documentation". Sun Microsystems. October 30, 1998. Archived from the original on 1999-02-24. Retrieved July 31, 2018.
  6. "Java Message Service Source - Version 1.0.1a". Sun Microsystems. October 29, 1998. Archived from the original (ZIP) on August 16, 2000. Retrieved July 31, 2018.
  7. "Java Message Service" (PDF). Sun Microsystems (published December 17, 1999). November 9, 1999. Archived (PDF) from the original on 2000-08-23. Retrieved July 31, 2018.
  8. "Java Message Service Documentation". Sun Microsystems. December 23, 1999. Archived from the original on 2000-02-29. Retrieved July 31, 2018.
  9. "Java Message Service" (PDF). Sun Microsystems. August 27, 2001. Archived (PDF) from the original on 2022-10-09. Retrieved July 31, 2018.
  10. "Java Message Service" (PDF). Sun Microsystems. April 12, 2002. Archived (PDF) from the original on 2022-10-09. Retrieved July 31, 2018.
  11. "Java Message Service" (PDF). Oracle. March 20, 2013. Archived (PDF) from the original on 2022-10-09. Retrieved July 31, 2018.
  12. "JMS 2.0 Final Release". Java Message Service Specification. June 9, 2017. Retrieved July 31, 2018.
  13. "Java Message Service" (PDF). Oracle. March 10, 2015. Archived (PDF) from the original on 2022-10-09. Retrieved July 31, 2018.
  14. "JMS 2.0 errata release (Rev a)". Java Message Service Specification. July 5, 2017. Retrieved July 31, 2018.
  15. "JSR 343: Java Message Service 2.0". The Java Community Process Program. Retrieved July 31, 2018.
  16. Monson-Haefel, Richard (December 6, 2018). "JMS 3.0: Get Involved!". Tomitribe. Retrieved July 17, 2020.
  17. Java Message Service (JMS)
  18. "Apache Qpid™: Open Source AMQP Messaging".
  19. Wallis, Graham. "Choosing a messaging system: WebSphere MQ vs. the WebSphere Application Server Service Integration Bus". IBM developerWorks.
  20. "TIBCO Product Documentation - TIBCO Enterprise Message Service".

Further reading

  • Richards, Mark; Richard Monson-Haefel; David A. Chappell (2009). Java Message Service, Second Edition. O'Reilly. ISBN 978-0-596-52204-9.

External links

Jakarta EE specifications
Web app
Enterprise app
Web services
Other
Removed
Related
Categories: