ActiveMQ-JMS（三）：接收消息

示例功能介绍

创建一个消息队列的消费者，从消息队列里读取消息。

实现思路

先创建一个生产者，向消息队列hello-world-queue发送消息。然后创建一个消费者，消费者与hello-world-queue队列绑定，向该消费者注册一个回调对象。就可以在回调对象的回调函数里收到消息了。
消费者必须与一个指定的消息队列绑定，这一点与生产者不同。生产者可以绑定，也可以不绑定。不绑定的时候，发送消息时指定目的队列。

创建工程

用eclipse创建一个maven工程，工程类型使用maven-archetype-quickstart。

导入jar包

通过maven导入javax.jms包

<!-- https://mvnrepository.com/artifact/javax.jms/javax.jms-api -->
<dependency>
    <groupId>javax.jms</groupId>
    <artifactId>javax.jms-api</artifactId>
    <version>2.0.1</version>
</dependency>

通过maven导入ActiveMQ的client包

<!-- https://mvnrepository.com/artifact/org.apache.activemq/activemq-client -->
<dependency>
    <groupId>org.apache.activemq</groupId>
    <artifactId>activemq-client</artifactId>
    <version>5.14.0</version>
</dependency>

发送消息

发送消息的详细说明参见ActiveMQ学习笔记（二）

        ConnectionFactory factory = new ActiveMQConnectionFactory("tcp://localhost:61616");
        connection = factory.createConnection();
        try {
            connection.start();
        } catch (JMSException jmse) {
            connection.close();
            throw jmse;
        }
        session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        producer = session.createProducer(null);
        Destination destination = session.createQueue("hello-world-queue");
        TextMessage message = session.createTextMessage();
        message.setText(letter);
        System.out.println("Sending: " + message.getText() + " on destination: " + destination);
        producer.send(destination, message);

接收消息

实现javax.jms.MessageListener接口的onMessage(Message message)函数。在函数中把消息的内容，打印到控制台。

public void onMessage(Message message) {
        TextMessage textMessage = (TextMessage) message;
        try {
            System.out.println(textMessage.getText());
        } catch (JMSException e) {
            e.printStackTrace();
        }

创建ActiveMQ连接工厂，创建jms连接和jms会话。

        factory = new ActiveMQConnectionFactory(brokerURL);
        connection = factory.createConnection();
        try {
            connection.start();
        } catch (JMSException jmse) {
            connection.close();
            throw jmse;
        }
        session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);

注册回调对象。本对象实现了MessageListener，所以用this做回调对象。注册回调对象后，在onMessage里就可以收到消息。
注意：onMessage函数是在另外一个线程里调用的，要考虑并发问题。如果使用另外一个对象作为回调对象，就不存在并发问题。这里为了简单，没有采用单独的回调对象的方法。

         Destination destination = session.createQueue("hello-world-queue");
        consumer = session.createConsumer(destination);
        consumer.setMessageListener(this);

完整代码

App.java

package practise.activemq;

import java.util.Map;
import java.util.concurrent.CountDownLatch;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnectionFactory;

/**
 * Hello world!
 *
 */
public class App {

    public static void main(String[] args) throws JMSException {

        System.out.println("启动生产者");
        Sender sender = new Sender();
        sender.start();

        /**/
        System.out.println("启动消费者");
        Consumer consumer = new Consumer();
        consumer.start();

        Map<Thread, StackTraceElement[]> maps = Thread.getAllStackTraces();
        System.out.println(String.format("当前线程数=%d", maps.size()));
        System.out.println("Exit!");
    }

}

Consumer.java

package practise.activemq;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MessageConsumer;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.MessageListener;
import javax.jms.Message;
import org.apache.activemq.ActiveMQConnectionFactory;

public class Consumer implements MessageListener {
    /**
     * 一下均是ActiveMQ相关的成员变量
     */
    protected static String brokerURL = "tcp://localhost:61616";
    protected static ConnectionFactory factory;
    protected Connection connection;
    protected Session session;
    protected MessageConsumer consumer;

    /**
     * 创建一个新的实例 App.在构造函数里初始化消息队列的参数
     *
     * @throws JMSException
     */
    public Consumer() throws JMSException {
        factory = new ActiveMQConnectionFactory(brokerURL);
        connection = factory.createConnection();
        try {
            connection.start();
        } catch (JMSException jmse) {
            connection.close();
            throw jmse;
        }
        session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    }

    public void onMessage(Message message) {
        TextMessage textMessage = (TextMessage) message;
        try {
            System.out.println(textMessage.getText());
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }

    public void start() throws JMSException {
        Destination destination = session.createQueue("hello-world-queue");
        consumer = session.createConsumer(destination);
        consumer.setMessageListener(this);
    }
}

Sender.java

package practise.activemq;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnectionFactory;

/**
 * Hello world!
 *
 */
public class Sender {
    /**
     * 一下均是ActiveMQ相关的成员变量
     */
    protected static String brokerURL = "tcp://localhost:61616";
    protected static transient ConnectionFactory factory;
    protected transient Connection connection;
    protected transient Session session;
    protected transient MessageProducer producer;

    /**
     * 创建一个新的实例 App.在构造函数里初始化消息队列的参数
     *
     * @throws JMSException
     */
    public Sender() throws JMSException {
        factory = new ActiveMQConnectionFactory(brokerURL);
        connection = factory.createConnection();
        try {
            connection.start();
        } catch (JMSException jmse) {
            connection.close();
            throw jmse;
        }
        session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        // producer可以绑定到一个地址，也可以不帮定。本例里没有绑定，而是在发送消息的时候，通过参数，传入地址。
        producer = session.createProducer(null);
    }

    public void close() throws JMSException {
        if (connection != null) {
            connection.close();
        }
    }

    public static void start() throws JMSException {
        System.out.println("Hello World!");
        Sender publisher = new Sender();
        int total = 0;
        while (total < 10) {
            publisher.sendMessage(String.format("hello-%d", total));
            System.out.println("Published '" + total + "' messages");
            try {
                Thread.sleep(100);
            } catch (InterruptedException x) {}
            total++;
        }
        publisher.close();
    }

    protected void sendMessage(String letter) throws JMSException {
        Destination destination = session.createQueue("hello-world-queue");
        TextMessage message = session.createTextMessage();
        message.setText(letter);
        System.out.println("Sending: " + message.getText() + " on destination: " + destination);
        producer.send(destination, message);
    }
}