JMS is the message communication API standard of the Java platform, supporting point-to-point and publish/subscribe models, and ActiveMQ is the message middleware it implements; 1. Start ActiveMQ service and listen to the default port; 2. Add activemq-client dependency in the Maven project; 3. Create producers to send messages to queues through ConnectionFactory; 4. Create consumers to receive messages asynchronously through MessageListener; this combination realizes system decoupling, traffic peak cutting, reliable delivery and asynchronous processing, which is suitable for traditional Java enterprise applications. Although there are more modern alternatives, they still have learning and use value.

In modern distributed systems, asynchronous communication is a key means to improve system decoupling, scalability and responsiveness. Java Message Service (JMS) combined with ActiveMQ is a classic combination of asynchronous messaging, especially suitable for enterprise-level Java applications.

What are JMS and ActiveMQ?

JMS is an API standard for sending and receiving messages in the Java platform, supporting two message models:

• Point-to-point (Queue) : The message is sent to the queue and a consumer processes a message.
• Publish/Subscribe (Topic) : The message is posted to a topic, and multiple subscribers can receive the same message.

ActiveMQ is an open source, JMS specification-based messaging middleware (message broker) developed by Apache. It supports multiple protocols (such as OpenWire, STOMP, MQTT) and can run across platforms, making it ideal for building loosely coupled asynchronous systems.

How to implement asynchronous communication using JMS ActiveMQ?

To use JMS to communicate asynchronously with ActiveMQ, the following steps are usually included:

1. Start ActiveMQ Service

First, download and start the service from the Apache ActiveMQ official website :

 bin/activemq start

By default, ActiveMQ listens to tcp://localhost:61616 and provides a web console http://localhost:8161 .

2. Add Maven dependencies

In your Java project (such as using Maven), add the following dependencies:

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

3. Create a message producer (Producer)

The producer sends messages to a queue or topic:

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

public class MessageProducer {
    private static final String BROKER_URL = "tcp://localhost:61616";
    private static final String QUEUE_NAME = "example.queue";

    public static void main(String[] args) throws JMSException {
        ConnectionFactory factory = new ActiveMQConnectionFactory(BROKER_URL);
        Connection connection = factory.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();
        connection.close();
    }
}

4. Create a message consumer

Consumers receive messages asynchronously, usually using MessageListener to implement:

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

public class MessageConsumer {
    public static void main(String[] args) throws JMSException {
        ConnectionFactory factory = new ActiveMQConnectionFactory(BROKER_URL);
        Connection connection = factory.createConnection();
        connection.start();

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

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

        // Keep the program running and wait for messages (may be in a more elegant way in actual applications)
        System.out.println("Waiting for messages...");
    }
}

Note: After the consumer uses setMessageListener , the message processing is asynchronous and will not block the main thread.

Usage scenarios and advantages

• System decoupling : Producers do not need to know the existence of consumers.
• Traffic peak cutting : In high concurrency scenarios, the message queue can buffer requests.
• Reliable delivery : ActiveMQ supports persistent messages to ensure that messages are not lost.
• Asynchronous processing : time-consuming operations such as sending emails and log processing can be placed in the queue for asynchronous execution.

Things to note

• Connection Management : It is recommended to use connection pools (such as PooledConnectionFactory ) in production environments.
• Transaction and confirmation mode : Select Session.SESSION_TRANSACTED or manually confirm according to reliability requirements.
• Exception handling : When a network is interrupted or a consumer crash, the reconnection and retry mechanisms need to be reasonably configured.
• Persistent subscription : For the Topic model, if the consumer is offline, he/she can receive missed messages through a persistent subscription.

Basically that's it. JMS ActiveMQ is not the latest technology (now more modern options such as Kafka and RabbitMQ), but it is still widely used in traditional Java EE or Spring projects, especially suitable for scenarios that require standard JMS support. Mastering it is very helpful for understanding the principles of message middleware.

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