ActiveMQ（消息中间件）java客户端使用

ActiveMQ（java客户端使用）

一、导包

二、测试代码

package cn.e3mall.activemq;

import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.command.ActiveMQTextMessage;
import org.junit.Test;

import javax.jms.*;
import java.io.IOException;

/**
 * 消息中间件ActiveMQ测试
 * Author: xushuai
 * Date: 2018/5/25
 * Time: 20:48
 * Description:
 */
public class ActiveMqTest {

    /*
     * 消息发送步骤：
     *           1、创建一个连接工厂对象，使用ActiveMQ服务的ip和端口号构建(端口号为：61616，且协议固定为tcp)
     *           2、使用工厂对象获取连接对象
     *           3、使用连接对象开启连接
     *           4、使用连接对象创建Session对象，并设置是否开启事务、应答方式
     *              |- 应答方式有三种，分别为：
     *           5、使用Session对象创建一个Destination对象。有两种消息形式：Queue和Topic
     *           6、使用Session对象创建一个消息生产者对象。（接收消息时，则创建消息消费者对象）
     *           7、创建消息对象。（接收消息）
     *           8、发送消息。（接收消息时，无此步骤）
     *           9、关闭资源
     */


    /**
     * 测试Queue消息发送
     * @auther: xushuai
     * @date: 2018/5/25 21:07
     * @throws: Exception
     */
    @Test
    public void testQueueProducer() throws Exception {
        //创建连接工厂对象
        ConnectionFactory connectionFactory =
                new ActiveMQConnectionFactory("tcp://192.168.25.128:61616");
        //获取连接对象
        Connection connection = connectionFactory.createConnection();
        //开启连接
        connection.start();
        //使用连接对象获取Session对象,并设置参数
        /*
         * 参数介绍
         *        第一个参数(参数类型boolean)：是否开启事务。(一般不开启事务：false)
         *        第二个参数(参数类型int)：应答模式。(一般设置为自动应答：AUTO_ACKNOWLEDGE)
         *                应答模式分为三种：
         *                          AUTO_ACKNOWLEDGE(自动应答)
         *                          CLIENT_ACKNOWLEDGE(手动应答)
         *                          DUPS_OK_ACKNOWLEDGE
         *
         *   注意：当开启事务的时候，第二个参数值设置哪一种都一样，即第二个参数无意义。
         */
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        //使用Session对象创建Destination对象,其中参数为：消息队列的名称
        Queue queue = session.createQueue("test-queue");
        //使用session创建消息生产者对象
        MessageProducer producer = session.createProducer(queue);
        //创建消息对象
        TextMessage message = new ActiveMQTextMessage();
        message.setText("这是一个测试消息");
        //发送消息
        producer.send(message);
        //关闭资源
        producer.close();
        session.close();
        connection.close();
    }


    /**
     * 测试Queue消息接收
     * @auther: xushuai
     * @date: 2018/5/25 21:12
     * @throws: Exception
     */
    @Test
    public void testQueueConsumer() throws Exception {
        //创建连接工厂对象
        ConnectionFactory connectionFactory =
                new ActiveMQConnectionFactory("tcp://192.168.25.128:61616");
        //获取连接对象
        Connection connection = connectionFactory.createConnection();
        //开启连接
        connection.start();
        //使用连接对象获取Session对象,并设置参数
        Session session = 
                connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        //使用Session对象创建Destination对象,其中参数为：消息队列的名称
        Queue queue = session.createQueue("test-queue");
        //创建消息消费者对象
        MessageConsumer consumer = session.createConsumer(queue);
        //接收消息
        consumer.setMessageListener(new MessageListener() {
            //接收到消息的事件
            @Override
            public void onMessage(Message message) {
                //简单打印一下
                TextMessage textMessage = (TextMessage) message;
                try {
                    System.out.println(textMessage.getText());
                } catch (JMSException e) {
                    e.printStackTrace();
                }
            }
        });
        //接收键盘输入，当在控制台输入回车时结束。（为了让该方法一直处于执行状态）
        System.in.read();
        //关闭资源
        consumer.close();
        session.close();
        connection.close();
    }

    /**
     * 测试Topic消息发送
     * @auther: xushuai
     * @date: 2018/5/25 21:33
     * @throws: Exception
     */
    @Test
    public void testTopicProducer() throws Exception{
        //创建连接工厂对象
        ConnectionFactory connectionFactory =
                new ActiveMQConnectionFactory("tcp://192.168.25.128:61616");
        //获取连接对象
        Connection connection = connectionFactory.createConnection();
        //开启连接
        connection.start();
        //使用连接对象获取Session对象,并设置参数
        Session session = 
                connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        //使用Session对象创建Destination对象,其中参数为：消息队列的名称
        Topic topic = session.createTopic("test-topic");
        //使用session创建消息生产者对象
        MessageProducer producer = session.createProducer(topic);
        //创建消息对象
        TextMessage message = new ActiveMQTextMessage();
        message.setText("这是一个测试消息(topic)");
        //发送消息
        producer.send(message);
        //关闭资源
        producer.close();
        session.close();
        connection.close();
    }

    /**
     * 测试Topic消息接收
     * @auther: xushuai
     * @date: 2018/5/25 21:12
     * @throws: Exception
     */
    @Test
    public void testTopicConsumer() throws Exception {
        //创建连接工厂对象
        ConnectionFactory connectionFactory =
                new ActiveMQConnectionFactory("tcp://192.168.25.128:61616");
        //获取连接对象
        Connection connection = connectionFactory.createConnection();
        //开启连接
        connection.start();
        //使用连接对象获取Session对象,并设置参数
        Session session = 
                connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        //使用Session对象创建Destination对象,其中参数为：消息队列的名称
        Topic topic = session.createTopic("test-Topic");
        //创建消息消费者对象
        MessageConsumer consumer = session.createConsumer(topic);
        //接收消息
        consumer.setMessageListener(new MessageListener() {
            //接收到消息的事件
            @Override
            public void onMessage(Message message) {
                //简单打印一下
                TextMessage textMessage = (TextMessage) message;
                try {
                    System.out.println(textMessage.getText());
                } catch (JMSException e) {
                    e.printStackTrace();
                }
            }
        });
        System.out.println("消费者1已启动");
        //System.out.println("消费者2已启动");
        //接收键盘输入，当在控制台输入回车时结束。（为了让该方法一直处于执行状态）
        System.in.read();
        //关闭资源
        consumer.close();
        session.close();
        connection.close();
    }
}

三、测试结果

testQueueProducer（）测试结果：

testQueueConsumer（）测试结果：

当消费了这个消息过后，后台中的该消息也会随之被删除。

testTopicProducer（）测试结果：

testTopicConsumer（）测试结果（这里启动了两个）：

再次调用testTopicProducer（）方法：

总结：

（1）Queue，只能有一个消费者，即点对点。且Queue会缓存发送的消息，直到该消息被消费掉，服务端才会删除该消息。

（2）Topic，可以有多个消费者，即广播。Topic的消费者必须在消息生产者发送消息之前运行，否则生产者发送的消息，消费者无法接收到，即服务端不会缓存消息，发送出去之后立即删除该消息。

注意：Topic也可以进行消息持久化，但需要单独配置。