消息队列学习-ActiveMQ（一）

1 前言

1 前言

1.1 是什么

MQ = 消息中间件

1.2 消息中间件的特性要求：

api发送和接受
MQ的高可用性
MQ的集群和容错配置
MQ的持久化
延迟发送/定时投递
签收机制
Spring整合
…

1.3 产品种类

Kafka
RabbitMQ
RocketMQ
ActiveMQ
其他

1.4 能干嘛

存在的问题：

系统之间接口耦合比较严重
面对大流量并发时，容易被冲垮
等待同步存在性能问题

要达到的目标：

解耦
削峰
异步

2 安装步骤

2.1 官网下载

2.2 复制到opt目录下面

2.3 解压缩apache-activemq-5.15.9-bin.tar.gz

2.4 在根目录下mkdir /myacitveMQ

2.5 cp -r apache-activemq-5.15.9 /myacitveMQ

2.6 普通启动mq: ./activemq start (关闭 stop)

2.7 mq的默认端口是：61616

2.8 三种查看进程的方法 1)ps -ef|grep “activemq”|grep -v grep 2)lsof -i:61616 3)netstat -anp|grep 61616

2.9 带日志启动 ./activemq start > xxx.log

3 启动控制台

目标：windows访问虚拟机上的activemq控制台

（1）查询window IP及虚拟机IP

//windows
ipconfig

// linux
ifconfig

（2）测试两个地址可以相互ping即可
windows:

linux:

（3）关闭window防火墙、linux防火墙
命令如下：

// windows 自己点吧...
// linux
service iptables stop  或 systemctl stop firewalld

（4）访问activemq控制台

// 1. 虚拟机linux启动activemq
./activemq start
// 2. windows浏览器访问 http://192.168.188.128:8161/

注：
（1）默认的用户名和密码是admin和admin
（2）采用61616端口提供JMS服务
（3）采用8161端口提供管理控制台服务

4 Java编码实现ActiveMQ通信

4.1 IDEA建maven工程

4.2 pom.xml

		<!--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>

		<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>

4.3 JMS编码总体架构

4.4 粗说目的地Destination（队列或主体）

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

点对点消息传递域的特点
（1）每个消息只能有一个消费者，类似1对1的关系。
（2）消息的生产者和消费者之间没有时间上的相关性。无论消费者在生产者发送消息的时候是否处于运行状态，消费者都可以提取信息。
（3）消息被消费后，队列中不会再存储，所以消费者不会消费到已经被消费掉的信息。

生产者代码：

package com.sky.activemq;

import org.apache.activemq.ActiveMQConnectionFactory;

import javax.jms.*;

public class JmsProduce {
    private static final String ActiveMQ_URL = "tcp://192.168.188.128:61616";
    private static final String QUEUE_NAME = "queue01";

    public static void main(String[] args) throws JMSException {
        // 1. 创建连接工厂，按照给定的URL地址，采用默认用户名和密码
        ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ActiveMQ_URL);
        // 2. 通过连接工厂，获得连接connection并启动
        Connection connection = activeMQConnectionFactory.createConnection();
        connection.start();

        // 3. 创建会话session
        // 两个参数，第一个叫事务/第二个叫签收
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        // 4. 创建目的地（具体是队列还是主题）
        Queue queue = session.createQueue(QUEUE_NAME);
        // 5. 创建消息的生产者
        MessageProducer messageProducer = session.createProducer(queue);
        // 6. 通过使用messageProducer生产3条消息发送到MQ队列里
        for (int i = 1; i <= 3; i++) {
            // 7. 创建消息
            TextMessage textMessage = session.createTextMessage("msg--->" + i);
            // 8. 通过messageProducer发送给mq
            messageProducer.send(textMessage);
        }
        // 9. 关闭资源
        messageProducer.close();
        session.close();
        connection.close();

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

运行代码，执行结果如下：

在查看控制台：

消费者代码：（Receive()）

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

package com.sky.activemq;

import org.apache.activemq.ActiveMQConnectionFactory;

import javax.jms.*;

public class JmsConsumer {
    private static final String ActiveMQ_URL = "tcp://192.168.188.128:61616";
    private static final String QUEUE_NAME = "queue01";

    public static void main(String[] args) throws JMSException {
        // 1. 创建连接工厂，按照给定的URL地址，采用默认用户名和密码
        ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ActiveMQ_URL);
        // 2. 通过连接工厂，获得连接connection并启动
        Connection connection = activeMQConnectionFactory.createConnection();
        connection.start();

        // 3. 创建会话session
        // 两个参数，第一个叫事务/第二个叫签收
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        // 4. 创建目的地（具体是队列还是主题）
        Queue queue = session.createQueue(QUEUE_NAME);
        // 5.创建消费者
        MessageConsumer messageConsumer = session.createConsumer(queue);
        while (true) {
            TextMessage textMessage = (TextMessage) messageConsumer.receive();
            if (textMessage != null) {
                System.out.println("****消费者收到消息：msg---" + textMessage.getText());
            }else {
                break;
            }
        }
        messageConsumer.close();
        session.close();
        connection.close();

    }
}

运行代码，执行结果如下：

查看队列控制台：

消费者代码：（监听方式）

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

package com.sky.activemq;

import org.apache.activemq.ActiveMQConnectionFactory;

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

public class JmsConsumer {
    private static final String ActiveMQ_URL = "tcp://192.168.188.128:61616";
    private static final String QUEUE_NAME = "queue01";

    public static void main(String[] args) throws JMSException, IOException {
        // 1. 创建连接工厂，按照给定的URL地址，采用默认用户名和密码
        ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ActiveMQ_URL);
        // 2. 通过连接工厂，获得连接connection并启动
        Connection connection = activeMQConnectionFactory.createConnection();
        connection.start();

        // 3. 创建会话session
        // 两个参数，第一个叫事务/第二个叫签收
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        // 4. 创建目的地（具体是队列还是主题）
        Queue queue = session.createQueue(QUEUE_NAME);
        // 5.创建消费者
        MessageConsumer messageConsumer = session.createConsumer(queue);


        /*
        while (true) {
            TextMessage textMessage = (TextMessage) messageConsumer.receive();
            if (textMessage != null) {
                System.out.println("****消费者收到消息：msg---" + textMessage.getText());
            }else {
                break;
            }
        }*/

        // 通过监听的方式来消费消息
        messageConsumer.setMessageListener(new MessageListener() {
            @Override
            public void onMessage(Message message) {
                if (message instanceof TextMessage) {
                    TextMessage textMessage = (TextMessage) message;
                    try {
                        System.out.println("****消费者收到消息：ListenerMsg---" + textMessage.getText());
                    } catch (JMSException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        System.in.read();

        messageConsumer.close();
        session.close();
        connection.close();
    }
}

结果同上面类似，不再截图。

情景小节

先生产，只启动1号消费者。问题：1号消费者能消费信息吗？Y
先生产，先启动1号消费者，在启动2号消费者。
问题1：1号消费者可以消费吗？Y
问题2：2号消费者可以消费吗？N
先启动2个消费者，再生产6个消息，请问，消费情况如何？一人一半

4.6 在发布订阅消息传递域中，目的地被称为主体(topic)

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

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

生产者代码：

package com.sky.activemq;

import org.apache.activemq.ActiveMQConnectionFactory;

import javax.jms.*;

public class JmsProduce_Topic {
    private static final String ActiveMQ_URL = "tcp://192.168.188.128:61616";
    private static final String TOPIC_NAME = "topic01";

    public static void main(String[] args) throws JMSException {
        // 1. 创建连接工厂，按照给定的URL地址，采用默认用户名和密码
        ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ActiveMQ_URL);
        // 2. 通过连接工厂，获得连接connection并启动
        Connection connection = activeMQConnectionFactory.createConnection();
        connection.start();
        // 3. 创建会话session
        // 两个参数，第一个叫事务/第二个叫签收
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        // 4. 创建目的地（具体是队列还是主题）
        Topic topic = session.createTopic(TOPIC_NAME);
        // 5. 创建消息的生产者
        MessageProducer messageProducer = session.createProducer(topic);
        // 6. 通过使用messageProducer生产3条消息发送到MQ队列里
        for (int i = 1; i <= 3; i++) {
            // 7. 创建消息
            TextMessage textMessage = session.createTextMessage("TOPIC_NAME--->" + i);
            // 8. 通过messageProducer发送给mq
            messageProducer.send(textMessage);
        }
        // 9. 关闭资源
        messageProducer.close();
        session.close();
        connection.close();

        System.out.println("***********TOPIC_NAME消息发布到MQ完成");
    }
}

消费者代码：

package com.sky.activemq;

import org.apache.activemq.ActiveMQConnectionFactory;

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

public class JmsConsumer_Topic {
    private static final String ActiveMQ_URL = "tcp://192.168.188.128:61616";
    private static final String TOPIC_NAME = "topic01";

    public static void main(String[] args) throws JMSException, IOException {
        System.out.println("我是2号消费者");

        // 1. 创建连接工厂，按照给定的URL地址，采用默认用户名和密码
        ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ActiveMQ_URL);
        // 2. 通过连接工厂，获得连接connection并启动
        Connection connection = activeMQConnectionFactory.createConnection();
        connection.start();

        // 3. 创建会话session
        // 两个参数，第一个叫事务/第二个叫签收
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        // 4. 创建目的地（具体是队列还是主题）
        Topic topic = session.createTopic(TOPIC_NAME);
        // 5.创建消费者
        MessageConsumer messageConsumer = session.createConsumer(topic);

        // 通过监听的方式来消费消息
        messageConsumer.setMessageListener((message) -> {
            if (message instanceof TextMessage) {
                    TextMessage textMessage = (TextMessage) message;
                    try {
                        System.out.println("****消费者收到topic消息：" + textMessage.getText());
                    } catch (JMSException e) {
                        e.printStackTrace();
                    }
                }
        });

        System.in.read();

        messageConsumer.close();
        session.close();
        connection.close();
    }
}

先执开启两个消费者，在生产三条消息，执行结果如下：

4.7 两大模式的比较

比较项目	Topic模式队列	Queue模式队列
工作模式	“订阅-发布模式”，如果当前没有订阅，消息将会被丢弃，如果有多个订阅者都会收到消息	“负载均衡”模式，如果当前没有消费者，消费者也不会丢弃；如果有多个消费者，那么一条消息也只会发送给其中一个消费者，并且要求消费者ack消息
有无状态	无状态	Queue数据默认会在mq服务器上以文件形式保存，比如Active MQ一般保存在$AMQ_HOME\data\kr-store\data 下面，也可以配置成DB存储。
传递完整性	如果每日哟订阅者，消息会被丢弃	消息不会被丢弃
处理效率	由于消息要按照订阅者的数量进行复制，所以处理性能会随着订阅者的增加而明显降低，并且还要结合不同消息协议自身的性能差异	由于一条消息只能发送给一个消费者，所以就算消费者就算再多，性能也不会有明显降低。当然不同的消息协议的具体性能也是有差异的

未完待续…

消息队列学习-ActiveMQ（一）