Springboot使用JmsTemplate实现单双向消息队列

1.安装activemq

下载地址：http://activemq.apache.org/download.html

windows安装：

下载完成之后解压

以此进入 bin->win64，双击 activemq.bat 启动

启动完成界面。输入地址：http://localhost:8161/admin界面，用户密码都是admin。

linux安装：

下载 linux的tar包，解压缩，

tar xvf apache-activemq-5.15.8-bin.tar.gz

进入bin启动

同样输入地址查看是否启动，

 

2.Springboot整合ActiveMq

项目结构

需要的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>

application.properties配置

server.port=8083


###ActiveMQ的配置
spring.activemq.broker-url=tcp://114.116.24.32:61616
# 在考虑结束之前等待的时间
#spring.activemq.close-timeout=15s
# 默认代理URL是否应该在内存中。如果指定了显式代理，则忽略此值。
spring.activemq.in-memory=true
# 是否在回滚回滚消息之前停止消息传递。这意味着当启用此命令时，消息顺序不会被保留。
spring.activemq.non-blocking-redelivery=false
# 等待消息发送响应的时间。设置为0等待永远。
spring.activemq.send-timeout=0
#默认情况下activemq提供的是queue模式，若要使用topic模式需要配置下面配置
#spring.jms.pub-sub-domain=true
#账号
spring.activemq.user=admin
# 密码
spring.activemq.password=admin
# 是否信任所有包
#spring.activemq.packages.trust-all=
# 要信任的特定包的逗号分隔列表（当不信任所有包时）
#spring.activemq.packages.trusted=
# 当连接请求和池满时是否阻塞。设置false会抛“JMSException异常”。
#spring.activemq.pool.block-if-full=true
# 如果池仍然满，则在抛出异常前阻塞时间。
#spring.activemq.pool.block-if-full-timeout=-1ms
# 是否在启动时创建连接。可以在启动时用于加热池。
#spring.activemq.pool.create-connection-on-startup=true
# 是否用Pooledconnectionfactory代替普通的ConnectionFactory。
#spring.activemq.pool.enabled=false
# 连接过期超时。
#spring.activemq.pool.expiry-timeout=0ms
# 连接空闲超时
#spring.activemq.pool.idle-timeout=30s
# 连接池最大连接数
#spring.activemq.pool.max-connections=1
# 每个连接的有效会话的最大数目。
#spring.activemq.pool.maximum-active-session-per-connection=500
# 当有"JMSException"时尝试重新连接
#spring.activemq.pool.reconnect-on-exception=true
# 在空闲连接清除线程之间运行的时间。当为负数时，没有空闲连接驱逐线程运行。
#spring.activemq.pool.time-between-expiration-check=-1ms
# 是否只使用一个MessageProducer
#spring.activemq.pool.use-anonymous-producers=true

 

消息发送方：MessageProduce.java

package com.wjx.mq.config.produce;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.stereotype.Component;

import javax.jms.Destination;


/**
 * @Description: 消息发送方
 * @Auther: wjx
 * @Date: 2019/1/24 14:22
 */
@Component
public class MessageProduce {

    private Logger logger = LoggerFactory.getLogger(MessageProduce.class);

    /**
     * 获取jms的模板
     */
    @Autowired
    private JmsTemplate jmsTemplate;


    /**
     * 发送消息
     *
     * @param destination
     * @param message
     */
    public void convertAndSend(Destination destination, String message) {
        jmsTemplate.convertAndSend(destination, message);
        logger.info("消息发送成功！");
    }
}

消息消费方（单方向）MessageConsumeOne.java

package com.wjx.mq.config.consume;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Component;

/**
 * @Description: 单项消息队列接收方
 * @Auther: wjx
 * @Date: 2019/1/24 14:30
 */
@Component
public class MessageConsumeOne {

    private Logger logger = LoggerFactory.getLogger(MessageConsumeOne.class);


    /**
     * 使用 JmsListener 配置监听模板监听队列
     *
     * @param txt
     */
    @JmsListener(destination = "wjx_queue")
    public void receiveQueue(String txt) {
        logger.info("MessageConsumeOne 接收到的的报文是：" + txt);
    }
}

消息消费方（双向）MessageConsumeDouble.java

package com.wjx.mq.config.consume;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jms.annotation.JmsListener;
import org.springframework.messaging.handler.annotation.SendTo;
import org.springframework.stereotype.Component;

/**
 * @Description: 双向消息队列消息接收方
 * @Auther: wjx
 * @Date: 2019/1/24 14:33
 */
@Component
public class MessageConsumeDouble {

    private Logger logger = LoggerFactory.getLogger(MessageConsumeDouble.class);


    /**
     * @param txt 报文
     * @return
     * @SendTo 消息接收完成之后，向 out.queue 发送消息，实现双向队列
     */
    @JmsListener(destination = "wjx_queue")
    @SendTo("out.queue")
    public String receiveQueue(String txt) {
        logger.info("MessageConsumeTwo 接收到的报文是:" + txt);
        logger.info("MessageConsumeTwo 发送出去的报文地址是: out.queue ");
        return txt;
    }
}

消息消费方发送的  out.queue 接收方

package com.wjx.mq.config.produce;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Component;

/**
 * @Description: 双向队列，消费者发送的消息监听并接收
 * @Auther: wjx
 * @Date: 2019/1/24 14:37
 */
@Component
public class MessageConsumeReceive {

    private Logger logger = LoggerFactory.getLogger(MessageConsumeReceive.class);

    @JmsListener(destination = "out.queue")
    public void consumerQueue(String txt) {
        logger.info("从消费者接收到的消息 out.queue 报文是：" + txt);
    }
}

Controller层

package com.wjx.mq.web;

import com.wjx.mq.config.produce.MessageProduce;
import org.apache.activemq.command.ActiveMQQueue;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.jms.Destination;

/**
 * @Description:
 * @Auther: wjx
 * @Date: 2019/1/24 14:40
 */
@RestController
public class JmsController {

    @Autowired
    private MessageProduce messageProduce;

    @GetMapping("sendMessage")
    public String activeMqSendMessage() {
        int num = 10;

        try {
            //ActiveMQQueue 队列模式
            //ActiveMQTopic 订阅模式

            Destination destination = new ActiveMQQueue("wjx_queue");
            for (int i = 0; i < num; i++) {
                messageProduce.convertAndSend(destination, "这是第 " + i + " 次发送的消息");
            }
            return "发送消息成功";
        } catch (Exception e) {
            return "发送消息失败";
        }
    }
}

配置完成。

 

测试

一开始没有数据

发送一条消息

 

查看结果