ActiveMQ高级详解与使用

一、常见的消息中间件产品对比

特性	ActiveMQ	RabbitMQ	RocketMQ	Kafka
开发语言	Java	Erlang	Java	Scala
单击吞吐量	万级	万级	10万级	10万级
时效性	毫秒级	微秒级	毫秒级	毫秒级
可用性	高（支持主从架构）	高（支持主从架构）	非常高（分布式架构）	非常高（分布式架构）
功能特性	成熟的产品，在很多公司得到应用；有较多的文档；各种协议支持较好	基于Erlang开发，所以并发能力很强，性能极其好，延时很低，管理界面丰富	MQ功能比较完备，扩展性佳	想一些教习查询，消息回溯等功能没有提供，但在大数据领域应用广泛

二、JMS具有两种通信模式：

① Point-to-Point Messaging Domain （点对点）

每个消息只有一个消费者，发送者和接收者在时间上是没有时间的约束，也就是说发送者在发送完消息之后，不管接收者有没有接受消息，都不会影响发送方发送消息到消息队列中。
发送方不管是否在发送消息，接收方都可以从消息队列中获取到消息，接收方在接收完消息之后，需要向消息队列应答成功。

点对点模型的特点：

• 每个消息只有一个消费者（Consumer）(即一旦被消费，消息就不再在消息队列中)；
• 发送者和接收者之间在时间上没有依赖性，也就是说当发送者发送了消息之后，不管接收者有没有 正在运行，它不会影响到消息被发送到队列；
• 接收者在成功接收消息之后需向队列应答成功。

② Publish/Subscribe Messaging Domain （发布/订阅模式）

一个消息可以传递个多个订阅者（即：一个消息可以有多个接受方），发布者与订阅者具有时间约束，针对某个主题（Topic）的订阅者，它必须创建一个订阅者之后，才能消费发布者的消息，而且为了消费消息，订阅者必须保持运行的状态。
为了缓和这样严格的时间相关性，JMS允许订阅者创建一个可持久化的订阅。这样，即使订阅者没有被激活（运行），它也能接收到发布者的消息。

发布/订阅模型的特点：

• 每个消息可以有多个消费者；
• 发布者和订阅者之间有时间上的依赖性（先订阅主题，再来发送消息）。
• 订阅者必须保持运行的状态，才能接受发布者发布的消息；

三、ActiveMQ生产者&消费者演示Demo

1. P2P模式(生产者)

public class Producer {
    public static void main(String[] args) throws JMSException {
        //1.创建连接工厂
        ConnectionFactory factory = new ActiveMQConnectionFactory(
                "tcp://192.168.66.133:61616");

        //2.创建连接
        Connection connection = factory.createConnection();
        //3.打开连接
        connection.start();

        //4.创建session
        /**
        * 参数一：是否开启事务操作
        * 参数二：消息确认机制
        */
        Session session = connection.createSession(false,
                Session.AUTO_ACKNOWLEDGE);

        //5.创建目标地址（Queue:点对点消息，Topic：发布订阅消息）
        Queue queue = session.createQueue("queue01");

        //6.创建消息生产者
        MessageProducer producer = session.createProducer(queue);

        //7.创建消息
        //createTextMessage: 文本类型
        TextMessage textMessage = session.createTextMessage("test message");
        //8.发送消息
        producer.send(textMessage);
        System.out.println("消息发送完成");
        //9.释放资源
        session.close();
        connection.close();
    }
}

2. P2P模式(消费者)

public class Consumer2 {
    public static void main(String[] args) throws JMSException {
        //1.创建连接工厂
        ConnectionFactory factory = new ActiveMQConnectionFactory(
                "tcp://192.168.66.133:61616");

        //2.创建连接
        Connection connection = factory.createConnection();
        //3.打开连接
        connection.start();

        //4.创建session
        Session session = connection.createSession(false,
                Session.AUTO_ACKNOWLEDGE);

        //5.指定目标地址
        Queue queue = session.createQueue("queue01");

        //6.创建消息的消费者
        MessageConsumer consumer = session.createConsumer(queue);
        //7.设置消息监听器来接收消息
        consumer.setMessageListener(new MessageListener() {
                //处理消息
                @Override
                public void onMessage(Message message) {
                    if (message instanceof TextMessage) {
                        TextMessage textMessage = (TextMessage) message;

                        try {
                            System.out.println("接收的消息（2）：" +
                                textMessage.getText());
                        } catch (JMSException e) {
                            e.printStackTrace();
                        }
                    }
                }
            });

        //注意：在监听器的模式下千万不要关闭连接，一旦关闭，消息无法接收
    }
}

3. Pub/Sub模式(生成者)

public class TopicProducer {
    public static void main(String[] args) throws Exception {
        //1.创建连接工厂
        ConnectionFactory factory = new ActiveMQConnectionFactory(
                "tcp://192.168.12.132:61616");

        //2.创建连接
        Connection connection = factory.createConnection();
        //3.打开连接
        connection.start();

        //4.创建session
        Session session = connection.createSession(false,
                Session.AUTO_ACKNOWLEDGE);

        //5.创建目标地址（Queue:点对点消息，Topic：发布订阅消息）
        Topic topic = session.createTopic("sms");

        //6.创建消息生产者
        MessageProducer producer = session.createProducer(topic);

        //7.创建消息
        TextMessage message = session.createTextMessage("发短信...");
        //8.发送消息
        producer.send(message);
        System.out.println("发送消息：发短信...");
        session.close();
        ;
        connection.close();
    }
}

4. Pub/Sub模式(消费者)

public class TopicConsumer {
    public static void main(String[] args) throws Exception {
        //1.创建连接工厂
        ConnectionFactory factory = new ActiveMQConnectionFactory(
                "tcp://192.168.12.132:61616");

        //2.创建连接
        Connection connection = factory.createConnection();
        //3.打开连接
        connection.start();

        //4.创建session
        Session session = connection.createSession(false,
                Session.AUTO_ACKNOWLEDGE);

        //5.创建目标地址（Queue:点对点消息，Topic：发布订阅消息）
        Topic topic = session.createTopic("sms");

        //6.创建消息的消费者
        MessageConsumer consumer = session.createConsumer(topic);
        //7.配置消息监听器
        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();
                    }
                }
            });
    }
}

四、SpringBoot与ActiveMQ整合

1. 引包

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.1.RELEASE</version>
    <relativePath/>
</parent>
<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.targer>1.8</maven.compiler.targer>
</properties>
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
	    <groupId>org.springframework.boot</groupId>
	    <artifactId>spring-boot-starter-activemq</artifactId>
    </dependency>
    <dependency>
	    <groupId>org.springframework.boot</groupId>
	    <artifactId>spring-boot-starter-test</artifactId>
	    <scope>test</scope>
    </dependency>
</dependencies>

2. 配置：

server:
	port: 9001 #端口
spring:
	application:
		name: activemq-producer # 服务名称
		
# springboot与activemq整合配置
	activemq:
		broker-url: tcp://192.168.66.133:61616 # 连接地址
		user: admin # activemq用户名
		password: admin # activemq密码
		
# 指定发送模式 （点对点 false ， 发布订阅 true）
jms:
	pub-sub-domain: false

3. 生产者

/**
* 演示SpringBoot与ActiveMQ整合- 消息生产者
*/
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ProducerApplication.class)
public class SpringBootProducer {
    //JmsMessagingTemplate: 用于工具类发送消息
    @Autowired
    private JmsMessagingTemplate jmsMessagingTemplate;

    @Test
    public void ptpSender() {
        /**
        * 参数一：队列的名称或主题名称
        * 参数二：消息内容
        */
        jmsMessagingTemplate.convertAndSend("springboot_queue",
            "spring boot message");
    }
}

4. 消费者

/**
* 用于监听消息类（既可以用于队列的监听，也可以用于主题监听）
*/
@Component // 放入IOC容器

public class MsgListener {
    /**
    * 用于接收消息的方法
    * destination: 队列的名称或主题的名称
    */
    @JmsListener(destination = "${activemq.name}")
    public void receiveMessage(Message message) {
        if (message instanceof TextMessage) {
            TextMessage textMessage = (TextMessage) message;

            try {
                System.out.println("接收消息：" + textMessage.getText());
            } catch (JMSException e) {
                e.printStackTrace();
            }
        }
    }
}

五、ActiveMQ消息组成

JMS协议组成结构：

结构	描述
JMS Provider	消息中间件/消息服务器
JMS Producer	消息生产者
JMS Consumer	消息消费者
JMS Message	消息（重要）

1. JMS消息头

结构	描述
JMSDestination	消息发送的 Destination，在发送过程中由提供者设置
JMSMessageID	唯一标识提供者发送的每一条消息。这个字段是在发送过程中由提供者设置的，客户机只能在消息发送后才能确定消息的 JMSMessageID
JMSDeliveryMode	消息持久化。包含值 DeliveryMode.PERSISTENT 或者DeliveryMode.NON_PERSISTENT。
JMSTimestamp	提供者发送消息的时间，由提供者在发送过程中设置
JMSExpiration	消息失效的时间，毫秒，值 0 表明消息不会过期，默认值为0
JMSPriority	消息的优先级，由提供者在发送过程中设置。优先级 0 的优先级最低，优先级 9 的优先级最高。0-4为普通消息，5-9为加急消息。ActiveMQ不保证优先级高就一定先发送，只保证了加急消息必须先于普通消息发送。默认值为4
JMSCorrelationID	通常用来链接响应消息与请求消息，由发送消息的 JMS 程序设置。
JMSReplyTo	请求程序用它来指出回复消息应发送的地方，由发送消息的 JMS 程序设置
JMSType	JMS 程序用它来指出消息的类型。
JMSRedelivered	消息的重发标志，false，代表该消息是第一次发生，true，代表该消息为重发消息

2. JMS消息体
JMS 定义了五种不同的消息正文格式，以及调用的消息类型，允许你发送并接收一些不同形式的数据，提供现有消息格式的一些级别的兼容性。

	 - TextMessage -- 一个字符串对象  
	 - MapMessage -- 一套名称-值对
	 - ObjectMessage -- 一个序列化的 Java 对象
	 - BytesMessage -- 一个字节的数据流
	 - StreamMessage -- Java原始值的数据流

演示Demo：

生产者Demo：

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ActiveMqApplication.class)
public class SpringBootProducerTest {
    @Autowired
    private JmsTemplate jmsTemplate;
    @Test
    public void ptpSender(){
        /**
         * 参数一：队列的名称或主题名称
         * 参数二：消息内容
         */
        jmsTemplate.convertAndSend("springboot_queue","spring boot message");
    }

    /**
     * 发送TextMessage消息
     */
    @Test
    public void testMessage(){
        jmsTemplate.send("springboot_queue", new MessageCreator() {
            @Override
            public Message createMessage(Session session) throws JMSException {
                TextMessage textMessage = session.createTextMessage("文本消息");
                return textMessage;
            }
        });
    }

    /**
     * 发送MapMessage消息
     */
    @Test
    public void mapMessageTest(){
        jmsTemplate.send("springboot_queue", new MessageCreator() {
            @Override
            public Message createMessage(Session session) throws JMSException {
                MapMessage mapMessage = session.createMapMessage();
                mapMessage.setString("name","张三");
                mapMessage.setInt("age",20);
                return mapMessage;
            }
        });
    }

    /**
     * 发送ObjectMessage消息
     */
    @Test
    public void objectMessageTest(){
        jmsTemplate.send("springboot_queue", new MessageCreator() {
            @Override
            public Message createMessage(Session session) throws JMSException {
                UserVo user = new UserVo();
                user.setUserName("小苍");
                user.setAge("18");
                ObjectMessage objectMessage = session.createObjectMessage(user);
                return objectMessage;
            }
        });
    }

    /**
     * 发送BytesMessage消息
     */
    @Test
    public void bytesMessageTest(){
        jmsTemplate.send("springboot_queue", new MessageCreator() {
            @Override
            public Message createMessage(Session session) throws JMSException {
                BytesMessage bytesMessage = session.createBytesMessage();
                try {
                    File file = new File("d:/spring.jpg");
                    FileInputStream in = new FileInputStream(file);
                    byte[] bytes = new byte[(int)file.length()];
                    in.read(bytes);
                    bytesMessage.writeBytes(bytes);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return bytesMessage;
            }
        });
    }

    /**
     * 发送StreamMessage消息
     */
    @Test
    public void streamMessageTest(){
        jmsTemplate.send("springboot_queue", new MessageCreator() {
            @Override
            public Message createMessage(Session session) throws JMSException {
                StreamMessage streamMessage = session.createStreamMessage();
                streamMessage.writeString("你好，ActiveMQ");
                streamMessage.writeInt(20);
                return streamMessage;
            }
        });
    }
}

消费者Demo：

@Component
public class MessageConsumer {

    /**
     * 用于接收消息的方法
     * destination: 队列的名称或主题的名称
     */
    @JmsListener(destination = "${activemq.name}")
    public void receiveMessage(Message message){
        if(message instanceof TextMessage){
            TextMessage textMessage = (TextMessage)message;
            try {
                System.out.println("接收消息：" + textMessage.getText());
            } catch (JMSException e) {
                e.printStackTrace();
            }
        }
        else if(message instanceof MapMessage)
        {
            MapMessage mapMessage = (MapMessage)message;
            try {
                System.out.println("接收消息：" + mapMessage.getString("name"));
                System.out.println("接收消息：" + mapMessage.getString("age"));
            } catch (JMSException e) {
                e.printStackTrace();
            }
        }
        else if(message instanceof ObjectMessage)
        {
            ObjectMessage objectMessage = (ObjectMessage)message;
            try {
                System.out.println("接收消息：" + ((UserVo)objectMessage.getObject()).toString());
            } catch (JMSException e) {
                e.printStackTrace();
            }
        }
        else if(message instanceof BytesMessage)
        {
            BytesMessage bytesMessage = (BytesMessage)message;
            byte[] buf = null;
            FileOutputStream out = null;
            try {
                out = new FileOutputStream("d:/abc.jpg");
                buf = new byte[(int)bytesMessage.getBodyLength()];
                bytesMessage.readBytes(buf);

                out.write(buf);
                out.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        else if(message instanceof StreamMessage)
        {
            StreamMessage streamMessage = (StreamMessage)message;
            try {
                String str = streamMessage.readString();
                int i = streamMessage.readInt();
                System.out.println(str);
                System.out.println(i);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

3. 消息持久化

ActiveMQ提供了以下三种的消息存储方式：
（1） Memory 消息存储-基于内存的消息存储。
（2） 基于日志消息存储方式，KahaDB是ActiveMQ的默认日志存储方式，它提供了容量的提升和恢复
能力。
（3） 基于JDBC的消息存储方式-数据存储于数据库（例如：MySQL）中。

JDBC消息存储：

1）application.yml

server:
	port: 9001
spring:
	activemq:
		broker-url: tcp://172.16.98.145:61616
		user: admin
		password: admin
	jms:
		pub-sub-domain: false # false：点对点队列模式， true：发布/订阅模式
		template:
			delivery-mode: persistent # 持久化

activemq:
	name: springboot-queue

2）修改activemq.xml

<!--配置数据库连接池-->
<bean name="mysql-ds" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
	<property name="driverClassName" value="com.mysql.jdbc.Driver" />
	<property name="url" value="jdbc:mysql://localhost:3306/ty" />
	<property name="username" value="root" />
	<property name="password" value="123"/>
</bean>

<!--JDBC Jdbc用于master/slave模式的数据库分享 -->
<persistenceAdapter>
	<jdbcPersistenceAdapter dataSource="#mysql-ds"/>
</persistenceAdapter>

3）拷贝mysql及durid数据源的jar包到activemq的lib目录下

4）重启activemq，之后数据库中会出现activemq的相关表

4. 消息事务
消息事务，是保证消息传递原子性的一个重要特征，和JDBC的事务特征类似。

一个事务性发送，其中一组消息要么能够全部保证到达服务器，要么都不到达服务器。
生产者、消费者与消息服务器直接都支持事务性；ActionMQ的事务主要偏向在生产者的应用。

针对异常的消息，会进去死信队列 ActiveMQ.DLQ （DLQ - 死信队列(Dead Letter Queue) 用来保存处理失败或者过期的消息）。

生产者事务Demo：

    @Test
    @Transactional
    public void sendMessage(){
        for(int i = 1;i <= 10; i++) {
            //模拟异常
            if(i == 6){
                int a = 10 / 0;
            }
            jmsTemplate.convertAndSend("springboot_queue", "消息---"+i);
        }
    }

消费者事务Demo：

@Component
public class MessageConsumerTransactional {
    /**
     * 接收消息
     */
    @JmsListener(destination="${activemq.name}")
    public void receiveMessage(TextMessage textMessage, Session session){
        try {
            System.out.println("消息内容：" + textMessage.getText() + ",是否重发：" + textMessage.getJMSRedelivered());
            //模拟异常
            int i = 10/0;
            //提交事务
            session.commit();
        } catch (JMSException e) {
            try {
                //回滚事务
                session.rollback();
            } catch (JMSException e1) {
            }
            e.printStackTrace();
        }
    }
}

5. 消息确认机制

JMS消息只有在被确认之后，才认为已经被成功地消费了。消息的成功消费通常包含三个阶段：客户接收消息、客户处理消息和消息被确认。在事务性会话中，当一个事务被提交的时候，确认自动发生。在非事务性会话中，消息何时被确认取决于创建会话时的应答模式（acknowledgement mode）。
该参数有以下三个可选值：

值	描述
Session.AUTO_ACKNOWLEDGE	当客户成功的从receive方法返回的时候，或者从MessageListener.onMessage方法成功返回的时候，会话自动确认客户收到的消息
Session.CLIENT_ACKNOWLEDGE	客户通过消息的acknowledge方法确认消息。需要注意的是，在这种模式中，确认是在会话层上进行：确认一个被消费的消息将自动确认所有已被会话消费的消息。例如，如果一个消息消费者消费了10个消息，然后确认第5个消息，那么所有10个消息都被确认
Session.DUPS_ACKNOWLEDGE	该选择只是会话迟钝确认消息的提交。如果JMS provider失败，那么可能会导致一些重复的消息。如果是重复的消息，那么JMS provider必须把消息头的JMSRedelivered字段设置为true

注意：消息确认机制与事务机制是冲突的，只能选其中一种。所以演示消息确认前，先关闭事务。

1）auto_acknowledge 自动确认

如果消费方接收消息失败，JMS服务器会重发消息，默认重发6次。

自动确认演示Demo：

@Configuration
public class ActiveMQConfig {

    @Bean
    public PlatformTransactionManager transactionManager(ConnectionFactory connectionFactory) {
        return new JmsTransactionManager(connectionFactory);
    }

    @Bean(name="jmsQueryListenerFactory")
    public DefaultJmsListenerContainerFactory jmsListenerContainerFactory(ConnectionFactory connectionFactory){
        DefaultJmsListenerContainerFactory factory=new DefaultJmsListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory);
        // 不开启事务操作
        factory.setSessionTransacted(false);
        //自动确认 - 1 ; 手动确认 - 4 ;
        factory.setSessionAcknowledgeMode(1);
        return factory;
    }
}

@Component
public class MessageConsumerAck {

    /**
     * auto_acknowledge 自动确认
     */
    @JmsListener(destination="${activemq.name}",containerFactory = "jmsQueryListenerFactory")
    public void receiveMessage(TextMessage textMessage){
        try {
            System.out.println("消息内容：" + textMessage.getText() + ",是否重发：" + textMessage.getJMSRedelivered());
            throw new RuntimeException("test");
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }
}

2）dups_ok_acknowledge

类似于 auto_acknowledge 确认机制，为自动批量确认而生，而且具有“延迟”确认的特点，ActiveMQ
会根据内部算法，在收到一定数量的消息自动进行确认。 在此模式下，可能会出现重复消息，如果消费方不允许重复消费，不建议使用！

3）client_acknowledge 手动确认

手动确认演示Demo：

@Configuration
public class ActiveMQConfig {

    @Bean
    public PlatformTransactionManager transactionManager(ConnectionFactory connectionFactory) {
        return new JmsTransactionManager(connectionFactory);
    }

    @Bean(name="jmsQueryListenerFactory")
    public DefaultJmsListenerContainerFactory jmsListenerContainerFactory(ConnectionFactory connectionFactory){
        DefaultJmsListenerContainerFactory factory=new DefaultJmsListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory);
        // 不开启事务操作
        factory.setSessionTransacted(false);
        //自动确认 - 1 ; 手动确认 - 4 ;
        factory.setSessionAcknowledgeMode(4);
        return factory;
    }
}

@Component
public class MessageConsumerAck {
    /**
     * client_acknowledge 手动确认
     */
    @JmsListener(destination="${activemq.name}",containerFactory = "jmsQueryListenerFactory")
    public void receiveMessage(TextMessage textMessage){
        try {
            System.out.println("消息内容：" + textMessage.getText() + ",是否重发：" + textMessage.getJMSRedelivered());
            // 确认收到消息，一旦消息确认，消息不会重新发送
            textMessage.acknowledge(); 
            throw new RuntimeException("test");
        } catch (JMSException e) {
            e.printStackTrace();
        }
    }
}

五、ActiveMQ消息投递方式

1. 异步投递
消息生产者使用持久（Persistent）传递模式发送消息的时候，Producer.send() 方法会被阻塞，直到broker 发送一个确认消息给生产者(ProducerAck)，这个确认消息暗示broker已经成功接收到消息并把消息保存到二级存储中。

使用异步，在brokerURL中增加 jms.alwaysSyncSend=false&jms.useAsyncSend=true属性

1）如果设置了alwaysSyncSend=true系统将会忽略useAsyncSend设置的值都采用同步

2）当alwaysSyncSend=false时，“NON_PERSISTENT”(非持久化)、事务中的消息将使用“异步发送”

3）当alwaysSyncSend=false时，如果指定了useAsyncSend=true，“PERSISTENT”类型的消息使用异步发送。如果useAsyncSend=false，“PERSISTENT”类型的消息使用同步发送。

1.在连接上配置 new ActiveMQConnectionFactory("tcp://locahost:61616?jms.useAsyncSend=true");

2.通过 ConnectionFactory((ActiveMQConnectionFactory)connectionFactory).setUseAsyncSend(true);

3.通过 connection((ActiveMQConnection)connection).setUseAsyncSend(true);

注意：如果是Spring或SpringBoot项目，通过修改JmsTemplate的默认参数实现异步或同步投递

总结： 默认情况(alwaysSyncSend=false,useAsyncSend=false)，非持久化消息、事务内的消息均采用异步发送；对于持久化消息采用同步发送。

2. 同步投递
如果应用程序能够容忍一些消息的丢失，那么可以使用异步发送。异步发送不会在受到broker的确认之前一直阻塞 Producer.send方法。