springboot集成activemq之队列名设置为变量

 

发送消息


import com.example.entity.RntityPo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsMessagingTemplate;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageHeaders;
import org.springframework.messaging.support.GenericMessage;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.jms.Destination;
import javax.jms.Queue;
import javax.jms.Topic;

/**
 * @PackageName com.example.bootmq
 * @ClassName ProducerController
 * @Description #默认情况下activemq提供的是queue模式，若要使用topic模式需要在配置文件中，添加 spring.jms.pub-sub-domain=true
 * @date 2019/9/12 13:49
 */

/*
 * 队列消息控制器
 */
@RestController
public class ProducerController {
    @Autowired
    private JmsMessagingTemplate jmsMessagingTemplate;


    @RequestMapping("/send")
    public void send(String msg) {
        // 指定消息发送的目的地及内容
        System.out.println("发送的内容：" + msg);
//        this.jmsMessagingTemplate.convertAndSend(this.topic, msg);
        this.jmsMessagingTemplate.convertAndSend("send.10", msg);
    }
}

package com.example.jmsmq;

import com.example.bootmq2.MqMessageListener;
import com.example.bootmq2.MqMessageListener2;
import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.command.ActiveMQQueue;
import org.apache.activemq.command.ActiveMQTopic;
import org.apache.activemq.pool.PooledConnectionFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jms.annotation.EnableJms;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.listener.DefaultMessageListenerContainer;

import javax.annotation.Resource;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;

/**
 * @PackageName com.example.bootmq2
 * @ClassName MqConfig3
 * @Description
 * @date 2019/9/12 16:17
 */
@Configuration
@EnableJms //启动消息队列
public class MqConfig3 {
  @Value("${spring.activemq.broker-url}")
  private String jmsBrokerUrl;

  @Value("${spring.activemq.user}")
  private String jmsUser;

  @Value("${spring.activemq.password}")
  private String jmsPassword;

  @Value("${spring.activemq.pool.max-connections}")
  private Integer jmsPoolMaxConnections;

  @Value("${spring.activemq.pool.expire-timeout}")
  private Integer jmsPoolExpireTimeout;

  @Value("${queue.receiveprefix}")
  private String queueReceivePrefix;

  @Value("${queue.sendprefix}")
  private String queueSendPrefix;


  @Resource
  private MqMessageListener mqMessageListener;

  /**
   * jms连接工厂
   * @return
   */
  @Bean
  public PooledConnectionFactory pooledConnectionFactory(){
    ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory();
    connectionFactory.setBrokerURL(jmsBrokerUrl);
    connectionFactory.setUserName(jmsUser);
    connectionFactory.setPassword(jmsPassword);
    PooledConnectionFactory pooledConnectionFactory = new PooledConnectionFactory(connectionFactory);
    pooledConnectionFactory.setMaxConnections(jmsPoolMaxConnections);
    pooledConnectionFactory.setExpiryTimeout(jmsPoolExpireTimeout);
    return pooledConnectionFactory;
  }

  /**
   * jms异步消息监听管理类
   * @return
   */
  @Bean
  public DefaultMessageListenerContainer listenerContainer(){
    String destinationName = new StringBuilder(queueReceivePrefix).append("*").toString();
    DefaultMessageListenerContainer defaultMessageListenerContainer = getListenerContainer(destinationName);
    return defaultMessageListenerContainer;
  }

  /**
   * 根据队列名创建异步消息监听管理类
   * @param destinationName
   * @return
   */
  private DefaultMessageListenerContainer getListenerContainer(String destinationName){
    DefaultMessageListenerContainer messageListenerContainer = new DefaultMessageListenerContainer();
    messageListenerContainer.setConnectionFactory(pooledConnectionFactory());
    Destination sendDestination = new ActiveMQQueue(destinationName);
    messageListenerContainer.setDestination(sendDestination);
    messageListenerContainer.setMessageListener(mqMessageListener);
    return messageListenerContainer;
  }
  /**
   * jms模板
   * @return
   */
  @Bean
  public JmsTemplate jmsTemplate(){
    JmsTemplate jmsTemplate =  new JmsTemplate(pooledConnectionFactory());
    return jmsTemplate;
  }




}

spring.activemq.broker-url=tcp://127.0.0.1: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=1000ms
spring.activemq.pool.expire-timeout=1000
# 连接空闲超时
#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


queue.receiveprefix=send.
queue.sendprefix=receive.

import org.springframework.stereotype.Component;

import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

/**
 * @PackageName com.example.bootmq2
 * @ClassName MqMessageListener
 * @Description activemq队列监听
 * @date 2019/9/12 15:41
 */
@Component
public class MqMessageListener  implements MessageListener{

    @Override
    public void onMessage(Message message) {
        try {

            TextMessage textMsg=(TextMessage)message;
            System.out.println("接收到一个纯文本消息。");
            System.out.println("消息内容是："+textMsg.getText());
            System.out.println("listener         "+message.toString());
        }catch (Exception e){

        }
    }
}

通过访问接口发送消息，使用变量名作为队列名称，然后监听队列名称接收消息。