springboot入门之九 消息异步通信RabbitMq ActiveMq

1 RabbitMq

1.1 rabbitmq简介

RabbitMQ于2007年发布，是一个在AMQP(高级消息队列协议)基础上完成的，可复用的企业消息系统，是当前最主流的消息中间件之一。
特点

RabbitMQ是使用Erlang语言开发的开源消息队列系统，基于AMQP协议来实现。
AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全。
AMQP协议更多用在企业系统内，对数据一致性、稳定性和可靠性要求很高的场景，对性能和吞吐量的要求还在其次。
RabbitMQ的可靠性是非常好的，数据能够保证百分之百的不丢失。可以使用镜像队列，它的稳定性非常好。所以说在我们互联网的金融行业。对数据的稳定性和可靠性要求都非常高的情况下，我们都会选择RabbitMQ。当然没有kafka性能好，但是要比AvtiveMQ性能要好很多。也可以自己做一些性能的优化。
RabbitMQ可以构建异地双活架构，包括每一个节点存储方式可以采用磁盘或者内存的方式。

RabbitMQ的集群架构

图中说的就是，我们可以采用三个节点作为RabbitMQ的一组集群，当然可以有许多组。节点与节点之间采用mirror queue。基于这种方式，能够保证数据百分之百的不丢失。
前端可以去做负载均衡，比如负载均衡组件：HA-proxy ，进行TCP级别的负载。
如果想做一个高可用的话，就需要借助keepAlived做一个高可用的配置。
比如前端加一个虚拟的VIP，通过VIP路由到指定的负载均衡组件，再有它路由到RabbtMQ的某一个节点。
这就是整个RabbitMQ集群架构。
能够实现非常完善，高可用并且性能也十分好，稳定性超强。并且有各种集群恢复手段。

RabbitMQ是由Erlang语言编写的实现了高级消息队列协议（AMQP）的开源消息代理软件（也可称为 面向消息的中间件）。支持Windows、Linux/Unix、MAC OS X操作系统和包括JAVA在内的多种编程语言。

AMQP，即Advanced Message Queuing Protocol，一个提供统一消息服务的应用层标准高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。基于此协议的客户端与消息中间件可传递消息，并不受 客户端/中间件 不同产品，不同的开发语言等条件的限制
使用rabbitmq主要三种分发模式

1.1.1 工作队列模式(Work Queue)

避免立即做一个资源密集型任务，必须等待它完成，而是把这个任务安排到稍后再做。我们将任务封装为消息并将其发送给队列。后台运行的工作进程将弹出任务并最终执行作业。当有多个worker同时运行时，任务将在它们之间共享。

1.1.2 分发模式(Fanout Exchange)

一个生产者，多个消费者，每一个消费者都有自己的一个队列，生产者没有将消息直接发送到队列，而是发送到了交换机，每个队列绑定交换机，生产者发送的消息经过交换机，到达队列，实现一个消息被多个消费者获取的目的。需要注意的是，如果将消息发送到一个没有队列绑定的exchange上面，那么该消息将会丢失，这是因为在rabbitMQ中exchange不具备存储消息的能力，只有队列具备存储消息的能力。

1.1.3 通配符模式（Topic Exchange）

这种模式添加了一个路由键，生产者发布消息的时候添加路由键，消费者绑定队列到交换机时添加键值，这样就可以接收到需要接收的消息。
符号“#”匹配一个或多个词，符号“*”匹配不多不少一个词

1.2 rabbitmq安装

此处不展开

1.3 springboot整合

1.3.1 添加pom依赖。

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

    </dependencies>

在yml配置rabbitmq地址

1.3.2 rabbitmq配置文件

spring:
  rabbitmq :
    addresses : 192.168.0.5:5672
    username : admin
    password : 123456
    virtual-host : /
    connection-timeout : 15000
    #发送确认 对应RabbitTemplate.ConfirmCallback接口
    publisher-confirms: true
    #发送失败回退，对应RabbitTemplate.ReturnCallback接口
    publisher-returns: true
    listener.simple.acknowledge-mode : manual
    listener.simple.concurrency : 5
    listener.simple.max-concurrency : 10
    

一、普通工作队列模式

新建RabbitConf文件，用于配置我们rabbitmq相关的资源
代码如下

@Configuration
public class RabbitConf {

    // =================== 普通工作队列模式 模式 若不先声明， 必须生成者先发消息，否则消费者启动时会报错====================
    @Bean
    public Queue helloQueue() {
        return new Queue("hello");
    }

    @Bean
    public Queue testQueue() {
        return new Queue("test1");
    } 
}

定义了名为hello test的队列。然后我们创建生产者RabbitSender

@Component
public class RabbitSender {
    Logger log = LoggerFactory.getLogger(RabbitSender.class);

    // 自动注入RabbitTemplate模板类
    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void send(String queue, Object message) {
        // 消息发送失败返回到队列中, yml需要配置 publisher-returns: true
        rabbitTemplate.setMandatory(true);

        // rabbitTemplate.isConfirmListener();
        // rabbitTemplate.setConfirmCallback(confirmCallback);
        // rabbitTemplate.setReturnCallback(returnCallback);
        System.out.println("Sender : " + message);
        CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
        rabbitTemplate.convertAndSend(queue, message, correlationData);
    }

    public void sendByExchange(String exchange, String queue, Object message) {

        System.out.println("Sender : " + message);
        CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
        rabbitTemplate.convertAndSend(exchange, queue, message, correlationData);
    }

    // 发送消息方法调用: 构建Message消息
    public void send(String queue, Object message, Map<String, Object> properties) throws Exception {

        MessageHeaders mhs = new MessageHeaders(properties);
        Message msg = MessageBuilder.createMessage(message, mhs);
        // id + 时间戳 全局唯一 用于ack保证唯一一条消息,这边做测试写死一个。但是在做补偿策略的时候，必须保证这是全局唯一的消息
        CorrelationData correlationData = new CorrelationData("1234567890");
        rabbitTemplate.convertAndSend(queue, msg, correlationData);
        System.out.println("发送完成");
    }

    // 回调函数: confirm确认
    final ConfirmCallback confirmCallback = new RabbitTemplate.ConfirmCallback() {
        @Override
        public void confirm(CorrelationData correlationData, boolean ack, String cause) {
            System.err.println("correlationData: " + correlationData);
            System.err.println("ack: " + ack);
            if (!ack) {
                // 可以进行日志记录、异常处理、补偿处理等
                System.err.println("异常处理....");
            } else {
                // 更新数据库，可靠性投递机制
                System.err.println("发送confirm....");
            }
        }
    };

    // 回调函数: return返回
    final ReturnCallback returnCallback = new RabbitTemplate.ReturnCallback() {
        @Override
        public void returnedMessage(org.springframework.amqp.core.Message message, int replyCode, String replyText,
            String exchange, String routingKey) {
            System.err.println("return exchange: " + exchange + ", routingKey: " + routingKey + ", replyCode: "
                + replyCode + ", replyText: " + replyText);
        }
    };

}

这里注入一个AmqpTemplate来发布消息
接下来我们需要配置一下消费者。
创建RabbitConsumer

@Component
public class RabbitConsumer {
    @Autowired
    private MailService mailService;
   
    // #################普通工作模式########################

    @RabbitListener(queues = "hello")
    @RabbitHandler
    public void readHelloQueue(Message message, Channel channel) throws IOException {
        // 采用手动应答模式, 手动确认应答更为安全稳定
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), true);
        System.out.println("hello receive: " + new String(message.getBody()));
    }

    // #################异步发邮件实例########################
    @RabbitListener(queues = "test1")
    @RabbitHandler
    public void readMailQueue(String content) {
        String[] mailTo = {"407737980@qq.com"};

        // 发送html格式正文的邮件 整合thymeleaf模板
        Map<String, Object> variableMap = new HashMap<String, Object>();

        variableMap.put("subject", "hello ");
        variableMap.put("content", "hello !This is a test! ");

        String result = mailService.sendMsgByThymeleafTemplate(
            new MailEntity("hello freemark", "hello !This is a test! ", mailTo, variableMap));
        System.out.println("Receiver  message, send mail ");
    }
}

每一个注解的作用代码里面的注释说的很详细了我就不重复说了。
然后我们来测试，
首先在生产者工程新建一个测试类，用于生产消息。
代码如下

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootTeach10ApplicationTests {

    @Autowired
    private RabbitSender rabbitSender;
   

   

    /**
     * 普通工作 模式测试
     */
    @Test
    public void queueSend() {
        Date date = new Date();
        String dateString = new SimpleDateFormat("YYYY-mm-DD hh:MM:ss").format(date);
        System.out.println("[simple] send msg:" + dateString);
        // 注意 第一个参数是队列名称 第二个是消息内容
        rabbitSender.send("hello", dateString);
    }
 
   
}

首先启动测试类。

2020-03-27 15:53:47.170  INFO 73440 --- [           main] s.s.t.SpringbootTeach10ApplicationTests  : Started SpringbootTeach10ApplicationTests in 4.477 seconds (JVM running for 5.56)
[simple] send msg:2020-53-87 03:03:47
Sender : 2020-53-87 03:03:47
hello receive: 2020-53-87 03:03:47

消费者成功消费消息。

二、fanout模式

fanout属于广播模式，只要跟它绑定的队列都会通知并且接受到消息。
我们同理在RabbitConf中配置一下fanout模式的队列跟交换机。

//=================== fanout 模式  ====================

    @Bean
    public Queue fanoutA() {
        return new Queue("fanout.a");
    }

    @Bean
    public Queue fanoutB() {
        return new Queue("fanout.b");
    }

    @Bean
    public Queue fanoutC() {
        return new Queue("fanout.c");
    }

    /**
     * 定义个fanout交换器
     * @return
     */
    @Bean
    FanoutExchange fanoutExchange() {
        // 定义一个名为fanoutExchange的fanout交换器
        return new FanoutExchange("fanoutExchange");
    }

    /**
     * 将定义的fanoutA队列与fanoutExchange交换机绑定
     * @return
     */
    @Bean
    public Binding bindingExchangeWithA() {
        return BindingBuilder.bind(fanoutA()).to(fanoutExchange());
    }

    /**
     * 将定义的fanoutB队列与fanoutExchange交换机绑定
     * @return
     */
    @Bean
    public Binding bindingExchangeWithB() {
        return BindingBuilder.bind(fanoutB()).to(fanoutExchange());
    }

    /**
     * 将定义的fanoutC队列与fanoutExchange交换机绑定
     * @return
     */
    @Bean
    public Binding bindingExchangeWithC() {
        return BindingBuilder.bind(fanoutC()).to(fanoutExchange());
    }

在代码中我们配置了三个队列名、一个fanout交换机，并且将这三个队列绑定到了fanout交换器上。只要我们往这个交换机生产新的消息，那么这三个队列都会收到。

同理我们需要在RabbitConsumer类中增加消费方法
代码分别如下

   // #################fanout模式########################

    @RabbitListener(queues = "fanout.a")
    @RabbitHandler
    public void readFanoutAQueue(String content) {
        System.out.println("fanout.a Receiver  : " + content);
    }

    @RabbitListener(queues = "fanout.b")
    @RabbitHandler
    public void readFanoutBQueue(String content) {
        System.out.println("fanout.b Receiver  : " + content);
    }

    @RabbitListener(queues = "fanout.c")
    @RabbitHandler
    public void readFanoutCQueue(String content) {
        System.out.println("fanout.c Receiver  : " + content);
    }

然后编写一个名为testFanout()的方法启动我们的fanout生产方法，

    /**
     * fanout 模式测试
     */
    @Test
    public void fanoutSend() {
        Date date = new Date();
        String dateString = new SimpleDateFormat("YYYY-mm-DD hh:MM:ss").format(date);
        System.out.println("[fanout] send msg:" + dateString);
        // 注意 第一个参数是我们交换机的名称 ，第二个参数是routerKey 我们不用管空着就可以，第三个是你要发送的消息
        rabbitSender.sendByExchange("fanoutExchange", "", dateString);
    }

然后执行测试类

2020-03-27 16:10:19.275  INFO 68640 --- [           main] s.s.t.SpringbootTeach10ApplicationTests  : Started SpringbootTeach10ApplicationTests in 4.074 seconds (JVM running for 5.159)
[fanout] send msg:2020-10-87 04:03:19
Sender : 2020-10-87 04:03:19
fanout.a Receiver  : 2020-10-87 04:03:19
fanout.c Receiver  : 2020-10-87 04:03:19
fanout.b Receiver  : 2020-10-87 04:03:19

三个队列的消费都成功接收到消息。

三、topic模式，

同样，配置topic队列跟交换器，注意的是这里需要多配置一个bindingKey

 //#################topic模式########################

    @Bean
    public Queue topiocA() {
        return new Queue("topic.a");
    }

    @Bean
    public Queue topicB() {
        return new Queue("topic.b");
    }

    @Bean
    public Queue topicC() {
        return new Queue("topic.c");
    }

    /**
     * 定义个topic交换器
     * @return
     */
    @Bean
    TopicExchange topicExchange() {
        // 定义一个名为fanoutExchange的fanout交换器
        return new TopicExchange("topicExchange");
    }

    /**
     * 将定义的topicA队列与topicExchange交换机绑定
     * @return
     */
    @Bean
    public Binding bindingTopicExchangeWithA() {
        return BindingBuilder.bind(topiocA()).to(topicExchange()).with("topic.msg");
    }

    /**
     * 将定义的topicB队列与topicExchange交换机绑定
     * @return
     */
    @Bean
    public Binding bindingTopicExchangeWithB() {
        return BindingBuilder.bind(topicB()).to(topicExchange()).with("topic.#");
    }

    /**
     * 将定义的topicC队列与topicExchange交换机绑定
     * @return
     */
    @Bean
    public Binding bindingTopicExchangeWithC() {
        return BindingBuilder.bind(topicC()).to(topicExchange()).with("topic.*.z");
    }

topicA的key为topic.msg 那么他只会接收包含topic.msg的消息
topicB的key为topic.#那么他只会接收topic开头的消息
topicC的key为topic.*.Z那么他只会接收topic.B.z这样格式的消息

然后在RabbitConsumer新建队列的消费方法

 // #################topic模式########################

    @RabbitListener(queues = "topic.a")
    @RabbitHandler
    public void readTopicAQueue(String content) {
        System.out.println("topic.a Receiver  : " + content);
    }

    @RabbitListener(queues = "topic.b")
    @RabbitHandler
    public void readTopicBQueue(String content) {
        System.out.println("topic.b Receiver  : " + content);
    }

    @RabbitListener(queues = "topic.c")
    @RabbitHandler
    public void readTopicCQueue(String content) {
        System.out.println("topic.c Receiver  : " + content);
    }

同理为topic新建测试方法

    /**
     * topic 模式测试
     */
    @Test
    public void topicTopic1Send() {
        Date date = new Date();
        String dateString = new SimpleDateFormat("YYYY-mm-DD hh:MM:ss").format(date);
        dateString = "[topic.msg] send msg:" + dateString;
        System.out.println(dateString);
        // 注意 第一个参数是我们交换机的名称 ，第二个参数是routerKey topic.msg，第三个是你要发送的消息
        // 这条信息将会被 topic.a topic.b接收
        rabbitSender.sendByExchange("topicExchange", "topic.msg", dateString);
        rabbitSender.sendByExchange("topicExchange", "topic.good.msg", dateString);
        rabbitSender.sendByExchange("topicExchange", "topic.m.z", dateString);
    }

启动测试消费者，看看消息是不是按照规则被发送消息

2020-03-27 16:14:36.290  INFO 104536 --- [           main] s.s.t.SpringbootTeach10ApplicationTests  : Started SpringbootTeach10ApplicationTests in 4.381 seconds (JVM running for 5.463)
[topic.msg] send msg:2020-14-87 04:03:36
Sender : [topic.msg] send msg:2020-14-87 04:03:36
Sender : [topic.msg] send msg:2020-14-87 04:03:36
Sender : [topic.msg] send msg:2020-14-87 04:03:36
topic.a Receiver  : [topic.msg] send msg:2020-14-87 04:03:36
topic.b Receiver  : [topic.msg] send msg:2020-14-87 04:03:36
topic.c Receiver  : [topic.msg] send msg:2020-14-87 04:03:36
topic.b Receiver  : [topic.msg] send msg:2020-14-87 04:03:36
topic.b Receiver  : [topic.msg] send msg:2020-14-87 04:03:36

其中 队列topic.a只配置topic.msg一条消息，正确
其中 队列topic.b匹配三条消息，因为三条消息都是topic开头的 正确
其中 队列topic.c匹配一条消息，只有一条消息满足（也就是topic.m.z这条消息）

1.3.3 异步发送邮件

增加发邮件代码，请参考SpringBoot入门之五 整合邮件服务
编写发送消息的controller
MailController.java

@Controller
public class MailController {
    @Autowired
    private MailService mailService;
    @Autowired
    private RabbitSender rabbitSender;

    @GetMapping("/mail/sendMail")
    @ResponseBody
    public String sendBySync(HttpServletRequest request) {

        String msg = null;
        try {
            String[] mailTo = {"407737980@qq.com"};

            // 发送html格式正文的邮件 整合thymeleaf模板
            Map<String, Object> variableMap = new HashMap<String, Object>();

            variableMap.put("subject", "hello ");
            variableMap.put("content", "hello !This is a test! ");

            long begin = System.currentTimeMillis();
            String result = mailService.sendMsgByThymeleafTemplate(
                new MailEntity("hello freemark", "hello !This is a test! ", mailTo, variableMap));
            long end = System.currentTimeMillis();
            long useTime = end - begin;
            msg = "success, uset time " + useTime + " ms";
            if (result.equals("success")) {
                return msg;
            } else {
                return "error";
            }
        } catch (Exception e) {
            msg = e.getMessage();
            return "error";
        }
    }

    @GetMapping("/mail/sendMailByMq")
    @ResponseBody
    public String sendByMq(HttpServletRequest request) {

        String msg = null;
        try {

            // 发送html格式正文的邮件 整合thymeleaf模板
            Map<String, Object> variableMap = new HashMap<String, Object>();

            variableMap.put("subject", "hello ");
            variableMap.put("content", "hello !This is a test! ");
            rabbitSender.send("test", "hello !This is a test! ", variableMap);

            return "success";
        } catch (Exception e) {
            msg = e.getMessage();
            return "error";
        }
    }

    @GetMapping("/mail/sendSimpleMq")
    @ResponseBody
    public String sendSimpleMsg(HttpServletRequest request) {

        Date date = new Date();
        String dateString = new SimpleDateFormat("YYYY-mm-DD hh:MM:ss").format(date);
        System.out.println("[fanout] send msg:" + dateString);
        // 注意 第一个参数是队列名称 第二个是消息内容
        rabbitSender.send("hello", dateString);
        return "success";
    }

    @GetMapping("/mail/sendTopicMq")
    @ResponseBody
    public String sendTopicMsg(HttpServletRequest request) {

        Date date = new Date();
        String dateString = new SimpleDateFormat("YYYY-mm-DD hh:MM:ss").format(date);
        System.out.println("[fanout] send msg:" + dateString);
        // 注意 第一个参数是我们交换机的名称 ，第二个参数是routerKey topic.msg，第三个是你要发送的消息
        // 这条信息将会被 topic.a topic.b接收
        rabbitSender.sendByExchange("topicExchange", "topic.msg", dateString);
        return "success";
    }

    @GetMapping("/mail/index")
    public ModelAndView mail(HttpServletRequest request) {

        ModelAndView mv = new ModelAndView();
        mv.setViewName("/web/email.html");
        return mv;
    }
}

编写发送消息的web页面

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<div>
    <a href="" th:href="@{/mail/sendMail}">点击同步发送邮件</a> <br>
    <a href="" th:href="@{/mail/sendMailByMq}">点击异步发送邮件</a> <br>
    <a href="" th:href="@{/mail/sendSimpleMq}">点击发送消息-普通工作模式</a> <br>
    <a href="" th:href="@{/mail/sendTopicMq}">点击发送消息-普通订阅模式</a> <br>
</div>
</body>
</html>

启动项目

点击异步发送邮件

源码地址

源码地址

2 ActiveMq

ActiveMQ是由Apache出品，ActiveMQ是一个完全支持JMS1.1和J2EE 1.4规范的JMS Provider实现。它非常快速，支持多种语言的客户端和协议，而且可以非常容易的嵌入到企业的应用环境中，并有许多高级功能。

2.1 特点

ActiveMQ是Apache出品，最流行的，能力强劲的开源消息总线，并且它是一个完全支持JMS规范的消息中间件
其丰富的API、多种集群构建模式使得他成为业界老牌消息中间件，在中小型企业中应用广泛!
MQ衡量指标：服务性能、数据存储、集群架构。

ActiveMQ现在用的比较少，因为ActiveMQ相比其他的MQ的性能来说比较一般。现如今高并发、大数据的应用场景随处可见。如果这时候在MQ的选择上，那么ActiveMQ就显得力不从心了。

衡量一个MQ的指标，主要有三个方面：服务性能、数据存储、集群架构
服务性能：ActiveMQ的性能不是特别好，面对超大规模并发时候，总是会出现各种各样的小问题，比如阻塞，消息堆积过多，产生一些延迟等等一些问题。
数据存储：ActiveMQ默认采用KahaDB内存存储方式。也可以采用一些高性能的存储方式，比如：google的LevelDb 基于内c存的。如果是为了保证消息的可靠，也可以采用mysql或者oracle数据库。
集群架构：ActiveMQ流行那么多年，与其他组件集成的Api也是十分完善的。如果不是特别大的并发场景下，ActiveMQ也是一个不错的选择。因为ActiveMQ的集群架构模式也是十分好。

2.2 架构模式

Masrer-Slave模式
主备模式，利用Zookeeper进行两个或多个节点的协调。其中的主节点是对外提供服务的，而另外的从节点启动着，但是不对外提供服务。当主节点挂掉，利用Zookeeper进行一个高可用的切换，将Salve节点切换成主节点，继续对外提供服务。

NetWork模式

本质是两组主备模式的集成，中间用NewWork网关，做一个连接配置，就可以实现分布式集群。

2.3 优缺点

优点：

跨平台(JAVA编写与平台无关，ActiveMQ几乎可以运行在任何的JVM上)
可以用JDBC：可以将数据持久化到数据库。虽然使用JDBC会降低ActiveMQ的性能，但是数据库一直都是开发人员最熟悉的存储介质
支持JMS规范：支持JMS规范提供的统一接口
支持自动重连和错误重试机制
有安全机制：支持基于shiro，jaas等多种安全配置机制，可以对Queue/Topic进行认证和授权
监控完善：拥有完善的监控，包括WebConsole，JMX，Shell命令行，Jolokia的RESTful API
界面友善：提供的WebConsole可以满足大部分情况，还有很多第三方的组件可以使用，比如hawtio

缺点：

社区活跃度不及RabbitMQ高
根据其他用户反馈，会出莫名其妙的问题，会丢失消息
目前重心放到activemq6.0产品Apollo，对5.x的维护较少
不适合用于上千个队列的应用场景

2.4 spingboot整合activeMq

2.4.1配置pom依赖

	<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-activemq</artifactId>
		</dependency>
		<!--消息队列连接池-->
        <dependency>
            <groupId>org.apache.activemq</groupId>
            <artifactId>activemq-pool</artifactId>
        </dependency>

2.4.2 activeMq配置文件

spring:
  activemq:
    broker-url: tcp://192.168.0.1:61616
    user: admin
    password: admin
    close-timeout: 15s   # 在考虑结束之前等待的时间
    in-memory: true      # 默认代理URL是否应该在内存中。如果指定了显式代理，则忽略此值。
    non-blocking-redelivery: false  # 是否在回滚回滚消息之前停止消息传递。这意味着当启用此命令时，消息顺序不会被保留。
    send-timeout: 0     # 等待消息发送响应的时间。设置为0等待永远。
    queue-name: active.queue
    topic-name: active.topic.name.model
    

2.4.3 源码实例

ActiveMqConf

@Configuration
public class ActiveMqConf {
    @Value("${spring.activemq.user}")
    private String username;
    @Value("${spring.activemq.password}")
    private String password;
    @Value("${spring.activemq.broker-url}")
    private String brokerUrl;

    @Bean
    public ConnectionFactory connectionFactory() {
        return new ActiveMQConnectionFactory(username, password, brokerUrl);
    }

    // 在Queue模式中，对消息的监听需要对containerFactory进行配置
    @Bean("queueListener")
    public JmsListenerContainerFactory<?> queueJmsListenerContainerFactory(ConnectionFactory connectionFactory) {
        SimpleJmsListenerContainerFactory factory = new SimpleJmsListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory);
        factory.setPubSubDomain(false);
        return factory;
    }

    // 在Topic模式中，对消息的监听需要对containerFactory进行配置
    @Bean("topicListener")
    public JmsListenerContainerFactory<?> topicJmsListenerContainerFactory(ConnectionFactory connectionFactory) {
        SimpleJmsListenerContainerFactory factory = new SimpleJmsListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory);
        factory.setPubSubDomain(true);
        return factory;
    }
}

发送消息类

@Component
public class ActiveMqSender {
    @Autowired
    private JmsTemplate jmsQueueTemplate;
    @Value("${spring.activemq.queue-name}")
    private String queueName;

    @Value("${spring.activemq.topic-name}")
    private String topicName;

    @Bean(name = "queue")
    public Queue queue() {
        return new ActiveMQQueue(queueName);
    }

    @Bean(name = "topic")
    public Topic topic() {
        return new ActiveMQTopic(topicName);
    }

    /**
     * 发送原始消息 Message
     */
    public void send(String destinationName, final String msg) {
        jmsQueueTemplate.send(destinationName, new MessageCreator() {
            @Override
            public Message createMessage(Session session) throws JMSException {
                return session.createTextMessage(msg);
            }
        });

    }
}

ActiveMqConsumer

@Component
public class ActiveMqConsumer {
    // topic模式的消费者
    @JmsListener(destination = "${spring.activemq.topic-name}", containerFactory = "topicListener")
    public void readActiveTopic(String message) {
        System.out.println("topic接受到：" + message);
    }

    // Queue模式的消费者
    // queue模式的消费者
    @JmsListener(destination = "${spring.activemq.queue-name}", containerFactory = "queueListener")
    public void readActiveQueue(String message) {
        System.out.println("queue接受到：" + message);
    }
}

测试类

    @Autowired
    private ActiveMqSender activeMqSender;


    @Test
    public void activeMqTest() {
        activeMqSender.send("active.queue", "hello");
    }