ActiveMQ5.x不多做介绍了，主要是SpringBoot的整合

特点：

1）支持来自Java，C，C ++，C＃，Ruby，Perl，Python，PHP的各种跨语言客户端和协议
2）支持许多高级功能，如消息组，虚拟目标，通配符和复合目标

3. 完全支持JMS 1.1和J2EE 1.4，支持瞬态，持久，事务和XA消息
4. Spring支持，ActiveMQ可以轻松嵌入到Spring应用程序中，并使用Spring的XML配置机制进行配置
5. 支持在流行的J2EE服务器（如TomEE，Geronimo，JBoss，GlassFish和WebLogic）中进行测试
6. 使用JDBC和高性能日志支持非常快速的持久化

下载：

http://activemq.apache.org/activemq-5153-release.html
实际开发推荐部署到Linux系统，具体操作网上也有教程
我这里为了方便，直接安装在本地Windows机器上
如果想了解更多，查看官方文档：

http://activemq.apache.org/getting-started.html
进入bin目录win64目录启动activemq.bat即可
访问localhost:8161进入首页
访问http://localhost:8161/admin/进入管理页面，默认用户名和密码都是admin

整合依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-activemq</artifactId>
        </dependency>
连接池

        <dependency>
            <groupId>org.apache.activemq</groupId>
            <artifactId>activemq-pool</artifactId>
        </dependency>

基本的配置

# ActiveMQ
spring.activemq.broker-url=tcp://127.0.0.1:61616
spring.activemq.user=admin
spring.activemq.password=admin
spring.activemq.pool.enabled=true
spring.activemq.pool.max-connections=100

使用ActiveMQ必须要在SpringBoot启动类中开启JMS，并进行配置

package org.dreamtech.avtivemq;

import javax.jms.ConnectionFactory;

import org.apache.activemq.ActiveMQConnectionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.core.env.Environment;
import org.springframework.jms.annotation.EnableJms;
import org.springframework.jms.core.JmsMessagingTemplate;
import org.springframework.jms.core.JmsTemplate;

@SpringBootApplication
@EnableJms
public class AvtivemqApplication {

    public static void main(String[] args) {
        SpringApplication.run(AvtivemqApplication.class, args);
    }

    @Autowired
    private Environment env;

    @Bean
    public ConnectionFactory connectionFactory() {
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory();
        connectionFactory.setBrokerURL(env.getProperty("spring.activemq.broker-url"));
        connectionFactory.setUserName(env.getProperty("spring.activemq.user"));
        connectionFactory.setPassword(env.getProperty("spring.activemq.password"));
        return connectionFactory;
    }

    @Bean
    public JmsTemplate genJmsTemplate() {
        return new JmsTemplate(connectionFactory());
    }

    @Bean
    public JmsMessagingTemplate jmsMessageTemplate() {
        return new JmsMessagingTemplate(connectionFactory());
    }
}

点对点模型：

• 首先实现消息的发送ProducerService

package org.dreamtech.avtivemq.service;
import javax.jms.Destination;
/**
 * 消息生产
 * @author Xu Yiqing
 */
public interface ProducerService {
    /**
     * 使用指定消息队列发送
     * @param destination
     * @param message
     */
    void sendMsg(Destination destination, final String message);
}

• ProducerServiceImpl

package org.dreamtech.avtivemq.service.impl;
import javax.jms.Destination;
import org.dreamtech.avtivemq.service.ProducerService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsMessagingTemplate;
import org.springframework.stereotype.Service;

@Service
public class ProducerServiceImpl implements ProducerService {
    @Autowired
    private JmsMessagingTemplate jmsTemplate;

    @Override
    public void sendMsg(Destination destination, String message) {
        jmsTemplate.convertAndSend(destination, message);
    }

}

-OrderController

package org.dreamtech.avtivemq.controller;

import javax.jms.Destination;

import org.apache.activemq.command.ActiveMQQueue;
import org.dreamtech.avtivemq.service.ProducerService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class OrderController {
    @Autowired
    private ProducerService producerService;
    
    @GetMapping("/order")
    private Object order(String msg) {
        Destination destination = new ActiveMQQueue("order.queue");
        producerService.sendMsg(destination,msg);
        return "order";
    }
}

访问：http://localhost:8080/order?msg=demo，然后查看ActiveMQ界面：

有生产者就就有消费者：监听消息队列

package org.dreamtech.avtivemq.jms;

import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Component;

@Component
public class OrderConsumer {
    /**
     * 监听指定消息队列
     * 
     * @param text
     */
    @JmsListener(destination = "order.queue")
    public void receiveQueue(String text) {
        System.out.println("[ OrderConsumer收到的报文 : " + text + " ]");
    }
}

由于实时监听，一启动SpringBoot就会打印：
[ OrderConsumer收到的报文 : demo ]

ActiveMQ消息发布和订阅

配置activemq的配置文件

server.port=10909
#activemq配置文件
#activeMQ地址
spring.activemq.broker-url=tcp://127.0.0.1:61616
#activeMQ用户名，根据实际情况配置
spring.activemq.user=admin
#activeMQ密码，根据实际情况配置
spring.activemq.password=admin
#是否启用内存模式（也就是不安装MQ，项目启动时同时也启动一个MQ实例）
spring.activemq.in-memory=false
#信任所有的包
spring.activemq.packages.trust-all=true
#如果是点对点（queue），那么此处默认应该是false，如果发布订阅，那么一定设置为true
spring.jms.pub-sub-domain=true

如果是点对点（queue），那么此处默认应该是spring.jms.pub-sub-domain=false，如果发布订阅，那么一定设置
spring.jms.pub-sub-domain=true
如果直接发送对象消息，那么必须设置spring.activemq.packages.trust-all为true；另外如果你想开始消息持久化就必须spring.activemq.in-memory=false选项。

对于发送对象消息，对象必须实现Serializable接口，并且必须在代码里指定serialVersionUID的值，否则在消费端序列化的时候报错

发布代码编写

import org.apache.activemq.command.ActiveMQTopic;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.jms.core.JmsMessagingTemplate;
 
/**
 *订阅模式的生产者
 **/
@Configuration
public class TopicProducter {
 
    @Autowired
    private JmsMessagingTemplate jmsMessagingTemplate;
 
    /**
     * @Description 将接受到的消息及消息模式(topic或queue)放到队列里面，然后消费
     * 者只需要正确的添加注解@JmsListener（destination = "目的地"），监听队列消息就会主动获取
     * @Param destination 目的地
     * @Param msg 消息
     * @Date  2019/3/21 14:46
     */
    public void sendMessage(String msg){
        ActiveMQTopic destination = new ActiveMQTopic("topic-my");
        jmsMessagingTemplate.convertAndSend(destination,msg);
    }
}

订阅模式消费者

import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Component;
 
/**
 * 订阅模式消费者
 */
@Component
public class TopicCustomer {
    /**
     * 创建2个消费者
     * @param text
     */
    @JmsListener(destination = "topic-my")
    public void subscriber(String text) {
        System.out.println("消费者1111111111111111111111消费+"+text);
    }
 
    @JmsListener(destination = "topic-my")
    public void subscriber1(String text) {
        System.out.println("消费者2222222222222222222222消费+"+text);
    }
}

控制层生成者

import com.study.demo.activemq.TopicProducter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
/**
 * 订阅模式生产者
 */
@RestController
public class TopicController {
 
    @Autowired
    private TopicProducter topicProducter;
 
    @RequestMapping("/publish")
    public String publish(String msg){
        topicProducter.sendMessage(msg);
        return "消息已经发布";
    }
 
}

最后检验结果

1>.启动Activemq
2>.启动springboot
3>.访问http://127.0.0.1:10909/publish?msg=发送消息

结果：

以上就是springboot 整合activemq 发布订阅模式

ActiveMQ的Queue与Topic区别

队列（Queue）和主题（Topic）是JMS支持的两种消息传递模型：

1、点对点（point-to-point，简称PTP）

Queue消息传递模型：
通过该消息传递模型，一个应用程序（即消息生产者）可以向另外一个应用程序（即消息消费者）发送消息。在此传递模型中，消息目的地类型是队列（即Destination接口实现类实例由Session接口实现类实例通过调用其createQueue方法并传入队列名称而创建）。消息首先被传送至消息服务器端特定的队列中，然后从此对列中将消息传送至对此队列进行监听的某个消费者。同一个队列可以关联多个消息生产者和消息消费者，但一条消息仅能传递给一个消息消费者。如果多个消息消费者正在监听队列上的消息，，JMS消息服务器将根据“先来者优先”的原则确定由哪个消息消费者接收下一条消息。如果没有消息消费者在监听队列，消息将保留在队列中，直至消息消费者连接到队列为止。这种消息传递模型是传统意义上的懒模型或轮询模型。在此模型中，消息不是自动推动给消息消费者的，而是要由消息消费者从队列中请求获得。

2、发布/订阅（publish/subscribe，简称pub/sub）

Topic消息传递模型：
通过该消息传递模型，应用程序能够将一条消息发送给多个消息消费者。在此传送模型中，消息目的地类型是主题（即Destination接口实现类实例由Session接口实现类实例通过调用其createTopic方法并传入主题名称而创建）。消息首先由消息生产者发布至消息服务器中特定的主题中，然后由消息服务器将消息传送至所有已订阅此主题的消费者。主题目标也支持长期订阅。长期订阅表示消费者已注册了主题目标，但在消息到达目标时该消费者可以处于非活动状态。当消费者再次处于活动状态时，将会接收该消息。如果消费者均没有注册某个主题目标，该主题只保留注册了长期订阅的非活动消费者的消息。与PTP消息传递模型不同，pub/sub消息传递模型允许多个主题订阅者接收同一条消息。JMS一直保留消息，直至所有主题订阅者都接收到消息为止。pub/sub消息传递模型基本上是一个推模型。在该模型中，消息会自动广播，消息消费者无须通过主动请求或轮询主题的方法来获得新的消息。
具体区别对比如下：