Jakarta Messaging

Jakarta Messaging
Name	Jakarta Messaging
Other names	JMS
Developer	Eclipse Foundation
Latest release	3.1
Programming language	Java
Platform	Java EE / Jakarta EE
License	Eclipse Public License
Website	Eclipse Foundation

Jakarta Messaging Jakarta Messaging is a Jakarta EE specification that standardizes asynchronous messaging for enterprise Java applications, originating from earlier Java platform efforts and maintained by the Eclipse Foundation; it defines APIs for message producers, consumers, and providers used across application servers such as WildFly, GlassFish, Apache TomEE, IBM WebSphere Application Server, and Oracle WebLogic Server. The specification enables integration between systems like Spring Framework, Hibernate, Apache Camel, Red Hat JBoss EAP, and Apache ActiveMQ brokers while interoperating with standards such as Java Message Service heritage, Java EE platform conventions, and Jakarta Transactions for transactional messaging.

Overview

Jakarta Messaging defines a vendor-neutral set of interfaces and semantics for point-to-point and publish–subscribe messaging patterns used by enterprise applications deployed on platforms like OpenJDK JVMs, Oracle JDK distributions, and cloud services including Amazon Web Services and Microsoft Azure. The specification supports messaging models that align with implementations such as Apache Artemis, RabbitMQ, IBM MQ, and Apache Kafka connectors, enabling integration with middleware products from Red Hat, IBM, Oracle Corporation, and Pivotal Software. Messaging interacts with application components in ecosystems featuring Jakarta EE, Spring Boot, Eclipse MicroProfile, Quarkus, and Micronaut.

History and Evolution

Jakarta Messaging traces lineage to original work on Java Community Process efforts, evolving from the Java Message Service developed under organizations including Sun Microsystems and later overseen during corporate transitions involving Oracle Corporation. The specification migrated to the Eclipse Foundation as part of the Jakarta EE stewardship change that followed negotiations with Eclipse Foundation leadership and contributors from vendors such as Red Hat, IBM, Fujitsu, and Tomitribe. Major revisions aligned with platform-wide renaming from Java EE to Jakarta EE and involved coordination with community projects including GlassFish reference implementations and contributors from Apache Software Foundation projects like Apache ActiveMQ and Apache Camel.

Architecture and Core Concepts

The architecture defines key roles: message producers, message consumers, destinations (queues and topics), connection factories, and sessions; these concepts are instantiated by providers such as Apache ActiveMQ Artemis and brokers like RabbitMQ when used via adapters. Messaging semantics include delivery modes (persistent, non-persistent), acknowledgement modes, message selectors, durable subscriptions, and message properties that facilitate integration with transaction coordinators like Jakarta Transactions and XA engines from Oracle Corporation or IBM. The model interoperates with standards including SOAP and RESTful services when bridged by integration tools such as Apache Camel, MuleSoft, and Spring Integration.

API and Programming Model

The API specifies interfaces for ConnectionFactory, Connection, Session, MessageProducer, MessageConsumer, and Message, with concrete message types such as TextMessage, ObjectMessage, BytesMessage, MapMessage, and StreamMessage; application developers using frameworks like Spring Framework or platforms like Jakarta EE and Quarkus create MDBs (message-driven beans) or listener containers to consume messages asynchronously. Error handling patterns align with retry and dead-letter queue strategies used by Amazon SQS, Google Cloud Pub/Sub, and enterprise brokers from IBM and Red Hat; developers integrate with build tools like Maven, Gradle, and CI/CD pipelines orchestrated by Jenkins, GitHub Actions, or GitLab CI. The programming model supports synchronous receive, asynchronous onMessage callbacks, and message-driven bean lifecycle integrated with containers such as WildFly or Payara Server.

Implementations and Providers

Several open-source and commercial providers implement the specification or provide adapters: Apache ActiveMQ, Apache ActiveMQ Artemis, RabbitMQ (software), IBM MQ, Red Hat AMQ, Oracle WebLogic JMS, Tibco EMS, Azure Service Bus connectors, and cloud-native services from Amazon Web Services and Google Cloud Platform. Reference implementations and test suites have been produced by projects like GlassFish and community efforts hosted by the Eclipse Foundation. Integration layers are offered by middleware vendors including Software AG, MuleSoft, and Confluent where Kafka connectors bridge semantics between record streams and JMS-style messaging.

Use Cases and Integration

Common use cases include enterprise integration patterns deployed in organizations such as Bank of America, Goldman Sachs, Deutsche Bank, and HSBC for trade processing, retail systems in companies like Walmart and Target for order orchestration, and telecommunications systems at vendors such as Ericsson and Nokia. Messaging is used in microservices architectures coordinated by Kubernetes, service meshes like Istio, and orchestration via Apache Kafka streams, enabling event-driven designs that work with data platforms including Elasticsearch, Cassandra, and MongoDB. Integration scenarios often employ Apache Camel, Spring Integration, Debezium, and enterprise service buses offered by Tibco or MuleSoft.

Security and Transaction Management

Security features are implemented through container-managed authentication, role-based access control compatible with OAuth 2.0, OpenID Connect, and TLS/SSL transport encryption as provided by Let’s Encrypt, Entrust, or enterprise PKI solutions from DigiCert; providers integrate with identity systems like Keycloak, Okta, and Microsoft Entra ID. Transaction management uses XA transactions coordinated by Jakarta Transactions implementations and transaction managers found in JBoss Transaction Service, Atomikos, and Bitronix to ensure exactly-once or at-least-once delivery semantics; for high-throughput streaming scenarios, teams use idempotent processing patterns and eventual consistency strategies aligned with designs documented by Martin Fowler and implemented with tooling from Confluent and Red Hat.

Category:Jakarta EE specifications