JMS with ActiveMQ enables asynchronous, loosely coupled communication in enterprise applications by using messaging; this tutorial demonstrates setting up ActiveMQ and implementing a point-to-point messaging example using the JMS API. 1. JMS is a Java API supporting two models: Point-to-Point (queues) where each message is consumed once, and Publish/Subscribe (topics) where multiple subscribers receive the same message. 2. ActiveMQ is chosen as it is an open-source, lightweight message broker that supports JMS and various protocols. 3. To install ActiveMQ, download the binary, extract it, start the broker using bin/activemq start, and verify via http://ipnx.cn/link/111eaa8b2f4a91d93cd60151bd3a8328 with default credentials admin/admin. 4. Set up a Java project with Maven by adding the activemq-client dependency (version 5.17.6). 5. Create a JMSProducer that connects to tcp://localhost:61616, creates a session, sends a text message to exampleQueue, and closes resources. 6. Create a JMSConsumer that connects to the same broker, listens on exampleQueue, synchronously receives the message within a 5-second timeout, prints it, and closes the connection. 7. Run the consumer first, then the producer to observe message delivery, highlighting that queues persist messages until consumed. 8. Key JMS components include ConnectionFactory, Connection, Session, Destination, MessageProducer, and MessageConsumer. 9. Optionally, use setMessageListener for asynchronous message consumption and keep the main thread alive to prevent premature exit. 10. This foundation supports advanced features like topics, durable subscriptions, selectors, and transactions, making JMS with ActiveMQ suitable for microservices, background processing, and event-driven systems.

Java Message Service (JMS) with ActiveMQ is a powerful combination for building asynchronous, loosely coupled, and scalable enterprise applications. In this tutorial, we’ll walk through the basics of JMS, set up ActiveMQ, and build a simple producer-consumer example using the JMS API.

What is JMS?

JMS (Java Message Service) is a Java API that allows applications to create, send, receive, and read messages. It enables distributed communication between applications or components using messages. JMS supports two messaging models:

• Point-to-Point (Queue): Messages are sent to a queue. One or more consumers can listen, but each message is processed by only one consumer.
• Publish/Subscribe (Topic): Messages are published to a topic. Multiple subscribers can receive the same message.

Why ActiveMQ?

Apache ActiveMQ is an open-source message broker that implements the JMS specification. It’s lightweight, supports multiple protocols (like AMQP, MQTT, STOMP), and works well in both small and large-scale systems.

Step 1: Install and Start ActiveMQ

1. Download ActiveMQ
   Go to http://ipnx.cn/link/7d648593ea5e08ebed0b0bc4c8071dce and download the latest binary release.

2. Extract the Archive

   

   tar -xzf apache-activemq-x.x.x-bin.tar.gz
   cd apache-activemq-x.x.x

3. Start the Broker

   bin/activemq start

4. Verify It’s Running
   Open your browser and go to:
   http://ipnx.cn/link/111eaa8b2f4a91d93cd60151bd3a8328
   Default login: admin / admin

Step 2: Set Up Your Java Project

You can use Maven to manage dependencies. Add the following to your pom.xml:

<dependencies>
    <dependency>
        <groupId>org.apache.activemq</groupId>
        <artifactId>activemq-client</artifactId>
        <version>5.17.6</version>
    </dependency>
</dependencies>

Step 3: Create a JMS Producer (Sender)

This class sends a message to a queue.

import javax.jms.*;
import org.apache.activemq.ActiveMQConnectionFactory;

public class JMSProducer {
    private static final String BROKER_URL = "tcp://localhost:61616";
    private static final String QUEUE_NAME = "exampleQueue";

    public static void main(String[] args) {
        ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(BROKER_URL);
        Connection connection = null;

        try {
            connection = connectionFactory.createConnection();
            connection.start();

            Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
            Destination destination = session.createQueue(QUEUE_NAME);
            MessageProducer producer = session.createProducer(destination);

            TextMessage message = session.createTextMessage("Hello from JMS Producer!");
            producer.send(message);

            System.out.println("Sent message: "   message.getText());

            producer.close();
            session.close();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                try {
                    connection.close();
                } catch (JMSException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Step 4: Create a JMS Consumer (Receiver)

This class listens for messages from the same queue.

import javax.jms.*;
import org.apache.activemq.ActiveMQConnectionFactory;

public class JMSConsumer {
    private static final String BROKER_URL = "tcp://localhost:61616";
    private static final String QUEUE_NAME = "exampleQueue";

    public static void main(String[] args) {
        ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(BROKER_URL);
        Connection connection = null;

        try {
            connection = connectionFactory.createConnection();
            connection.start();

            Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
            Destination destination = session.createQueue(QUEUE_NAME);
            MessageConsumer consumer = session.createConsumer(destination);

            // Synchronous receive (you can also use MessageListener for async)
            Message message = consumer.receive(5000); // wait up to 5 seconds
            if (message instanceof TextMessage) {
                TextMessage textMessage = (TextMessage) message;
                System.out.println("Received message: "   textMessage.getText());
            } else {
                System.out.println("Received: "   message);
            }

            consumer.close();
            session.close();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                try {
                    connection.close();
                } catch (JMSException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Step 5: Run the Example

1. Start ActiveMQ (if not already running).
2. Run JMSConsumer in one terminal.
3. Run JMSProducer in another.
4. You should see the message being sent and received.

? Tip: You can also run the consumer first, then the producer — the message will still be delivered because queues store messages until consumed.

Key Concepts Recap

• ConnectionFactory: Creates connections to the broker.
• Connection: A client’s connection to the JMS provider.
• Session: A single-threaded context for sending and receiving messages.
• Destination: Either a Queue (P2P) or Topic (Pub/Sub).
• MessageProducer: Sends messages to a destination.
• MessageConsumer: Receives messages from a destination.

Optional: Use a Message Listener (Asynchronous Consumer)

Instead of consumer.receive(), use a listener for event-driven consumption:

consumer.setMessageListener(new MessageListener() {
    public void onMessage(Message message) {
        if (message instanceof TextMessage) {
            try {
                System.out.println("Async received: "   ((TextMessage) message).getText());
            } catch (JMSException e) {
                e.printStackTrace();
            }
        }
    }
});

?? Don’t forget to keep the main thread alive (e.g., Thread.sleep(Long.MAX_VALUE);) if using async.

Conclusion

You’ve now built a basic JMS application using ActiveMQ. This foundation can be extended to support topics, durable subscriptions, message selectors, transactions, and more.

JMS with ActiveMQ is ideal for decoupling microservices, handling background tasks, or implementing event-driven architectures.

Basically, once you understand the producer-consumer pattern and how to configure the connection, the rest scales naturally.

The above is the detailed content of Java Message Service (JMS) with ActiveMQ Tutorial. For more information, please follow other related articles on the PHP Chinese website!