消息队列之ActiveMQ（Java编码实现ActiveMQ通讯）

最新推荐文章于 2022-11-16 00:43:20 发布

爪哇国猿首

最新推荐文章于 2022-11-16 00:43:20 发布

阅读量449

点赞数 1

分类专栏：学习笔记文章标签： ActiveMQ

本文链接：https://blog.csdn.net/qq_40583885/article/details/102941206

版权

学习笔记专栏收录该内容

13 篇文章 0 订阅

订阅专栏

第一部分介绍ActiveMQ的安装，第二部分通过Java编码实现ActiveMQ的通讯，并对比Queue队列与Topic队列两大模式的区别
如果对消息队列的概念还不是很清楚的可以参考我的转载博文：
关于消息队列的应用场景

1.ActiveMQ的安装和控制台

1.1 什么是ActiveMQ

ActiveMQ是一种开源的基于JMS（Java Message Servie）规范的一种消息中间件的实现，ActiveMQ的设计目标是提供标准的，面向消息的，能够跨越多语言和多系统的应用集成消息通信中间件。

1.2 CentOS 7安装

1.2.1 官网下载

在这里插入图片描述

1.2.2 解压安装

①将下载的安装包拷贝至centos系统中的/opt目录下并解压tar -zxvf apache-activemq-5.15.9-bin.tar.gz
在这里插入图片描述
②创建目录mkdir /myactiveMQ并将解压后的activemq拷贝至该目录中一份cp -r apache-activemq-5.15.9 /myactiveMQ

1.2.3 普通启动和停止

cd /myactiveMQ/apache-activemq-5.15.9/bin
在这里插入图片描述

①普通启动

./activemq start

ps -ef | grep activemq

netstat -anp|grep 61616
在这里插入图片描述
②普通关闭

./activemq stop
在这里插入图片描述

③带运行日志的启动方式

./activemq start > /myactiveMQ/run_activemq.log
在这里插入图片描述

1.2.4 Apache ActiveMQ控制台

http://192.168.140.128:8161/admin/（确认linux防火墙已经关闭systemctl stop firewalld）

默认的用户名和密码是admin/admin
在这里插入图片描述

备注：采用61616端口提供JMS服务，采用8161端口提供管理控制台服务

控制台说明

在这里插入图片描述


Number Of Pending Messages	等待消费的消息	这个是当前未出队列的数量。公式 = 总接收数 - 总出队列数
Number Of Consumers	消费者数量	消费者端的消费者数量
Messages Enqueued	进队消息数	进入队列的总数量,包括出队列的。这个数量只增不减
Messages Dequeued	出队消息数	可以理解为是消费者消费掉的数量

2.Java编码实现ActiveMQ通讯★

（1）构建maven项目，并引入依赖。

<dependencies>
    <!-- activemq所需要的jar包配置-->
    <dependency>
        <groupId>org.apache.activemq</groupId>
        <artifactId>activemq-all</artifactId>
        <version>5.15.9</version>
    </dependency>
    <dependency>
        <groupId>org.apache.xbean</groupId>
        <artifactId>xbean-spring</artifactId>
        <version>3.16</version>
    </dependency>
    <!-- 下面是junit/log4j等基础通用配置-->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.25</version>
    </dependency>
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.2.3</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.16.18</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>

（2）JMS编码总体架构

在这里插入图片描述

（3）JMS支持的两种消息传递模型

JMS支持两种消息传递模型：点对点（point-to-point，简称PTP）和发布/订阅（publish/subscribe,简称pub/sub）。这两种消息传递模型非常相似，但有以下区别:

PTP消息传递模型规定了一条消息只能够传递给一个接收方。
Pub/sub消息传递模型允许一条消息传递给多个接收方

①点对点特性图解
在这里插入图片描述
②发布/订阅特性图解

2.1 点对点消息传递案例

在点对点的消息传递域中，目的地(Destiantion)被称为队列（queue）

点对点消息传递域的特点如下：

（1）每个消息只能有一个消费者，类似1对1的关系。好比个人快递自己领取自己的。
（2）消息的生产者和消费者之间没有时间上的相关性。无论消费者在生产者发送消息的时候是否处于运行状态，消费者都可以提取消息。好比我们的发送短信，发送者发送后不见得接收者会即收即看。
（3）消息被消费后队列中不会再存储，所以消费者不会消费到已经被消费掉的消息。

在这里插入图片描述

上手案例：

生产者类

/*
 *@auther xiaoshenlong
 *@create 2019-11-05 14:30
 *生产者向消息队列存入消息
 */
public class JMSProduce
{
    public static final String ACTIVEMQ_URL = "tcp://192.168.1.135:61616";
    public static final String QUEUE_NAME = "myQueue-01";

    public static void main(String[] args) throws JMSException
    {
        //1 创建连接工厂,使用默认用户名密码，编码不再体现
        ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ACTIVEMQ_URL);
        //2 获得连接并启动
        Connection connection = activeMQConnectionFactory.createConnection();
        connection.start();
        //3 创建会话,此步骤有两个参数，第一个是否以事务的方式提交，第二个默认的签收方式
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        //4 创建队列
        Queue queue = session.createQueue(QUEUE_NAME);
        //5 创建生产者
        MessageProducer messageProducer = session.createProducer(queue);
        for(int i=1; i<=6; i++)//生产6条消息给MQ
        {
            //6 创建消息
            TextMessage message = session.createTextMessage("message--"+i);
            //7 通过消息生产者发布消息
            messageProducer.send(message);
        }
        //8 关闭资源
        messageProducer.close();
        session.close();
        connection.close();

        System.out.println("**********消息发送到MQ完毕");
    }
}

运行结果：

在这里插入图片描述

查看控制台：

在这里插入图片描述

通过查看控制台我们发现有6条消息在消息队列中排队等待消费

消费者类：

消费者1：（同步阻塞方式(receive())）

/**
 *@auther xiaoshenlong
 *@create 2019-11-05 15:26
 */
public class JMSConsumer
{
    public static final String ACTIVEMQ_URL = "tcp://192.168.1.135:61616";
    public static final String QUEUE_NAME = "myQueue-01";

    public static void main(String[] args) throws JMSException
    {
        //1 创建连接工厂,使用默认用户名密码，编码不再体现
        ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ACTIVEMQ_URL);
        //2 获得连接并启动
        Connection connection = activeMQConnectionFactory.createConnection();
        connection.start();
        //3 创建会话,此步骤有两个参数，第一个是否以事务的方式提交，第二个默认的签收方式
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        //4 创建队列
        Queue queue = session.createQueue(QUEUE_NAME);
        //5 创建消费者
        MessageConsumer messageConsumer = session.createConsumer(queue);
        //6 用来接收消息
        TextMessage textMessage = null;
        while(true)
        {
            textMessage = (TextMessage) messageConsumer.receive();
            if(null != textMessage)
            {
                System.out.println("*****消费者接收到消息："+textMessage.getText());
            }else{
                break;
            }
        }
        //7 关闭所有连接
        messageConsumer.close();
        session.close();
        connection.close();
    }
}

运行结果：

在这里插入图片描述

查看控制台：

在这里插入图片描述

消费者2：（异步非阻塞方式(监听器onMessage())）

/**
 *@auther xiaoshenlong
 *@create 2019-11-05 15:26
 */
public class JMSConsumer2
{
    public static final String ACTIVEMQ_URL = "tcp://192.168.1.135:61616";
    public static final String QUEUE_NAME = "myQueue-01";

    public static void main(String[] args) throws JMSException
    {
        //1 创建连接工厂,使用默认用户名密码，编码不再体现
        ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ACTIVEMQ_URL);
        //2 获得连接并启动
        Connection connection = activeMQConnectionFactory.createConnection();
        connection.start();
        //3 创建会话,此步骤有两个参数，第一个是否以事务的方式提交，第二个默认的签收方式
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        //4 创建队列
        Queue queue = session.createQueue(QUEUE_NAME);
        //5 创建消费者
        MessageConsumer messageConsumer = session.createConsumer(queue);
        //6 用来接收消息（创建消息的监听）
        messageConsumer.setMessageListener(new MessageListener() {
            @Override
            public void onMessage(Message message) {
                if(message instanceof TextMessage){
                    try {
                        String text = ((TextMessage) message).getText();
                        System.out.println("*****接收到MQ队列消息："+text);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        //7 关闭所有连接
        messageConsumer.close();
        session.close();
        connection.close();
    }
}

启动生产者，启动消费者2观察运行结果
在这里插入图片描述

启动消费者2后运行结果:
在这里插入图片描述

观察控制台：

在这里插入图片描述

我们发现，启动消费者2后并没有收到消息，并且通过观察控制台，生产者生产6条消息仍然在消息队列中等待消费，那为什么通过监听器接收消息的消费方式会出现这种情况？这是由于MQ自身的特点—消息的不确定性，发送的消息不一定会及时的被消费者获取到，所以采用监听器的方式消费数据应该主动引入延迟性的消息轮询。

修改消费者2：

由于启动监听的方式一次不一定能监听获取到生产者生产的消息，因此需要使消费者2在收到消息之前都不能关闭。加入如下代码后，使监听器一直启动扫描，直到扫描到生产者生产的消息。
在这里插入图片描述
再次启动消费者2：

查看控制台：

在这里插入图片描述

两种消费方式的特点：

①同步阻塞方式(receive())
订阅者或接收者调用MessageConsumer的receive()方法来接收消息，receive方法在能够接收到消息之前（或超时之前）将一直阻塞。

②异步非阻塞方式(监听器onMessage())
订阅者或接收者通过MessageConsumer的setMessageListener(MessageListener
listener)注册一个消息监听器，当消息到达之后，系统自动调用监听器MessageListener的onMessage(Message
message)方法。

关于队列实现生产和消费的三个问题：

1、先启动生产者生产，再启动1号消费者，问：1号消费者能消费吗？yes

2、先生产，启动1号消费者，再启动2号消费者问：

2.1 1号消费者可以消费吗？ Yes

2.2 2号消费者可以消费吗？ No
3、先启动2个消费者，再生产6条消息，如何消费

3.1 2个消费者都有6条 No

3.2 先到先得，6条都给一个人 No

3.3 一人一半 Yes

2.2 发布/订阅消息传递案例

在发布订阅消息传递域中，目的地(Destiantion)被称为主题（topic）

发布/订阅消息传递域的特点如下：

（1）生产者将消息发布到topic中，每个消息可以有多个消费者，属于1：N的关系
（2）生产者和消费者之间有时间上的相关性。订阅某一个主题的消费者只能消费自它订阅之后发布的消息。
（3）生产者生产时，topic不保存消息它是无状态的不落地，假如无人订阅就去生产，那就是一条废消息，所以，一般先启动消费者再启动生产者。

JMS 规范允许客户创建持久订阅，这在一定程度上放松了时间上的相关性要求。持久订阅允许消费者消费它在未处于激活状态时发送的消息。一句话，好比我们的微信公众号订阅

在这里插入图片描述

上手案例：

发布主题生产者类

/*
 *@auther xiaoshenlong
 *@create 2019-11-05 14:30
 *生产者向消息队列存入消息
 */
public class JMSProduce
{
    public static final String ACTIVEMQ_URL = "tcp://192.168.1.135:61616";
    public static final String TOPIC_NAME = "myTopic-01";
    public static void main(String[] args) throws JMSException
    {
        //1 创建连接工厂,使用默认用户名密码，编码不再体现
        ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ACTIVEMQ_URL);
        //2 获得连接并启动
        Connection connection = activeMQConnectionFactory.createConnection();
        connection.start();
        //3 创建会话,此步骤有两个参数，第一个是否以事务的方式提交，第二个默认的签收方式
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        //4 创建主题
        Topic topic = session.createTopic(TOPIC_NAME);
        //5 创建生产者
        MessageProducer messageProducer = session.createProducer(topic);
        for(int i=1; i<=6; i++)//生产6条消息给MQ
        {
            //6 创建主题消息
            TextMessage message = session.createTextMessage("Topic--message--"+i);
            //7 通过消息生产者发布消息
            messageProducer.send(message);
        }
        //8 关闭资源
        messageProducer.close();
        session.close();
        connection.close();

        System.out.println("**********发送主题消息到MQ完毕");
    }
}

运行结果：

在这里插入图片描述

查看控制台：

在这里插入图片描述

订阅主题消费者类：

/**
 *@auther xiaoshenlong
 *@create 2019-11-05 15:26
 */
public class JMSConsumer2
{
    public static final String ACTIVEMQ_URL = "tcp://192.168.1.135:61616";
    public static final String TOPIC_NAME = "myTopic-01";

    public static void main(String[] args) throws JMSException, InterruptedException {
        //1 创建连接工厂,使用默认用户名密码，编码不再体现
        ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ACTIVEMQ_URL);
        //2 获得连接并启动
        Connection connection = activeMQConnectionFactory.createConnection();
        connection.start();
        //3 创建会话,此步骤有两个参数，第一个是否以事务的方式提交，第二个默认的签收方式
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        //4 创建队列
        Topic topic = session.createTopic(TOPIC_NAME);
        //5 创建消费者
        MessageConsumer messageConsumer = session.createConsumer(topic);
        //6 用来接收消息（创建消息的监听）
        messageConsumer.setMessageListener(new MessageListener() {
            @Override
            public void onMessage(Message message) {
                if(message instanceof TextMessage){
                    try {
                        String text = ((TextMessage) message).getText();
                        System.out.println("*****接收到MQ主题消息："+text);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        Thread.sleep(Long.MAX_VALUE);

        //7 关闭
        messageConsumer.close();
        session.close();
        connection.close();

    }
}

运行结果：

在这里插入图片描述

查看控制台：

在这里插入图片描述

我们发现订阅主题消费者并没有消费订阅消息，如果在不关闭订阅主题消费者的前提下再次运行生产者：

在这里插入图片描述

再次查看控制台：
在这里插入图片描述

结论：在发布/订阅消息传递中需要先启动订阅再启动生产，不然发送的消息是废消息

关于主题实现生产和消费的三个问题：

1、先启动发布主题生产者，再启动订阅主题消费者，问：消费者能消费吗？No

2、先启动订阅主题消费者，再启动发布主题生产者，问：消费者能消费码？Yes

3、先启动2个消费者，再生产6条消息，如何消费

3.1 2个消费者都有6条 Yes

3.2 先到先得，6条都给一个人 No

3.3 一人一半 No

2.3 两大模式的比较

在这里插入图片描述

爪哇国猿首

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
消息队列之ActiveMQ（Java编码实现ActiveMQ通讯）

第一部分介绍ActiveMQ的安装，第二部分通过Java编码实现ActiveMQ的通讯，并对比Queue队列与Topic队列两大模式的区别如果对消息队列的概念还不是很清楚的可以参考我的转载博文：关于消息队列的应用场景1.ActiveMQ的安装和控制台1.1 什么是ActiveMQActiveMQ是一种开源的基于JMS（Java Message Servie）规范的一种消息中间件的实现...
复制链接

扫一扫