创建延时队列、springboot配置多个rabbitmq

已于 2023-08-22 21:58:08 修改
阅读量761 收藏
点赞数
分类专栏： MQ 文章标签： java rabbitmq
于 2023-08-21 23:07:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43732943/article/details/132418349
版权

创建延时队列

queue.file_delay_destroy
x-dead-letter-exchange:	exchange.file_delay_destroy
x-message-ttl:	259200000
259200000为3天,1000为1秒

在这里插入图片描述

创建普通队列

queue.file_destroy

创建普通交换机

exchange.file_delay_destroy

type选择fanout
在这里插入图片描述

交换机绑定普通队列

(图中已经绑定，红框为绑定过程)
在这里插入图片描述

普通队列绑定交换机

(图中已经绑定，红框为绑定过程)
在这里插入图片描述

延时队列

springboot配置多个rabbitmq

延时队列时间到之后，将消息发送给queue.file_destroy，执行删除文件操作

import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonInclude;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;

@JsonInclude(JsonInclude.Include.NON_NULL)
@JsonIgnoreProperties(ignoreUnknown = true)
@EqualsAndHashCode
@Data
public class MQMessage implements Serializable {
  private JSONObject msg;
  private String messageId;   //存储消息发送的唯一标识
}

import com.sxqx.entity.MQMessage;

public interface MQMessageSender {
  /**
   *
   * @param queue 消息队列名称
   * @param msg 消息
   */
  void send(String queue, MQMessage msg);
}

RabbitConfig配置类

import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.amqp.SimpleRabbitListenerContainerFactoryConfigurer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

@Configuration
public class RabbitConfig {

  @Primary
  @Bean(name="mq1ConnectionFactory")
  public ConnectionFactory mq1ConnectionFactory(
          @Value("${spring.rabbitmq.mq1.host}") String host,
          @Value("${spring.rabbitmq.mq1.port}") int port,
          @Value("${spring.rabbitmq.mq1.username}") String username,
          @Value("${spring.rabbitmq.mq1.password}") String password,
          @Value("${spring.rabbitmq.mq1.virtual-host}") String virtualHost
  ){
    CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
    connectionFactory.setHost(host);
    connectionFactory.setPort(port);
    connectionFactory.setUsername(username);
    connectionFactory.setPassword(password);
    connectionFactory.setVirtualHost(virtualHost);
    connectionFactory.setPublisherConfirms(true);
    connectionFactory.setPublisherReturns(true);
    return connectionFactory;
  }

  @Bean(name="mq2ConnectionFactory")
  public ConnectionFactory mq2ConnectionFactory(
          @Value("${spring.rabbitmq.mq2.host}") String host,
          @Value("${spring.rabbitmq.mq2.port}") int port,
          @Value("${spring.rabbitmq.mq2.username}") String username,
          @Value("${spring.rabbitmq.mq2.password}") String password,
          @Value("${spring.rabbitmq.mq2.virtual-host}") String virtualHost
  ){
    CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
    connectionFactory.setHost(host);
    connectionFactory.setPort(port);
    connectionFactory.setUsername(username);
    connectionFactory.setPassword(password);
    connectionFactory.setVirtualHost(virtualHost);
    connectionFactory.setPublisherConfirms(true);
    connectionFactory.setPublisherReturns(true);
    return connectionFactory;
  }

  @Primary
  @Bean(name="mq1RabbitTemplate")
  public RabbitTemplate mq1RabbitTemplate(
          @Qualifier("mq1ConnectionFactory") ConnectionFactory connectionFactory
  ){
    RabbitTemplate mq1RabbitTemplate = new RabbitTemplate(connectionFactory);
    mq1RabbitTemplate.setMessageConverter(jsonMessageConverter());
    return mq1RabbitTemplate;
  }

  @Bean(name="mq2RabbitTemplate")
  public RabbitTemplate mq2RabbitTemplate(
          @Qualifier("mq2ConnectionFactory") ConnectionFactory connectionFactory
  ){
    RabbitTemplate mq2RabbitTemplate = new RabbitTemplate(connectionFactory);
    mq2RabbitTemplate.setMessageConverter(jsonMessageConverter());
    return mq2RabbitTemplate;
  }

  @Bean
  public Jackson2JsonMessageConverter jsonMessageConverter() {
    return new Jackson2JsonMessageConverter();
  }


  @Bean(name = "mq1Factory")
  @Primary
  public SimpleRabbitListenerContainerFactory mq1Factory(
          SimpleRabbitListenerContainerFactoryConfigurer configurer,
          @Qualifier("mq1ConnectionFactory") ConnectionFactory connectionFactory
  ) {
    SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
    configurer.configure(factory, connectionFactory);
    return factory;
  }

  @Bean(name = "mq2Factory")
  public SimpleRabbitListenerContainerFactory mq2Factory(
          SimpleRabbitListenerContainerFactoryConfigurer configurer,
          @Qualifier("mq2ConnectionFactory") ConnectionFactory connectionFactory
  ) {
    SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
    configurer.configure(factory, connectionFactory);
    return factory;
  }
}

mq1

@Component
public class RabbitMQ1MessageSender  implements MQMessageSender, RabbitTemplate.ConfirmCallback{
  @Resource(name = "mq1RabbitTemplate")
  private RabbitTemplate mq1RabbitTemplate;
  Log log = LogFactory.getLog(RabbitMQ1MessageSender.class);
  @Autowired
  public RabbitMQ1MessageSender() {
  }

  @PostConstruct
  public void init(){
    mq1RabbitTemplate.setConfirmCallback(this);
  }

  @Override
  public void confirm(CorrelationData correlationData, boolean ack, String cause) {
    if(!ack){
      log.error("消息接收失败" + cause);
      // 我们这里要做一些消息补发的措施
      System.out.println("id="+correlationData.getId());
    }
  }

  @Override
  public void send(String routingKey, MQMessage msg) {
    String jsonString = JsonConverter.bean2Json(msg);
    if (jsonString != null) {
      mq1RabbitTemplate.convertAndSend(routingKey, jsonString);
    }
  }
}

mq2

import com.sxqx.entity.MQMessage;
import com.sxqx.utils.dataConverter.JsonConverter;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;

@Component
public class RabbitMQ2MessageSender implements MQMessageSender, RabbitTemplate.ConfirmCallback{
  @Resource(name = "mq2RabbitTemplate")
  private RabbitTemplate mq2RabbitTemplate;
  Log log = LogFactory.getLog(RabbitMQ2MessageSender.class);
  @Autowired
  public RabbitMQ2MessageSender() {
  }
  
  @PostConstruct
  public void init(){
    mq2RabbitTemplate.setConfirmCallback(this);
  }

  @Override
  public void confirm(CorrelationData correlationData, boolean ack, String cause) {
    if(!ack){
      log.error("消息接收失败" + cause);
      // 我们这里要做一些消息补发的措施
      System.out.println("id="+correlationData.getId());
    }
  }

  @Override
  public void send(String routingKey, MQMessage msg) {
    String jsonString = JsonConverter.bean2Json(msg);
    if (jsonString != null) {
      mq2RabbitTemplate.convertAndSend(routingKey, jsonString);
    }
  }
}

application-prod.yaml

spring:
  rabbitmq:
    mq1:
      username: guest
      password: guest
      host: mq1_ip
      port: 5672
      virtual-host: /
      publisher-returns: true
      publisher-confirm-type: simple
      listener:
        simple:
          acknowledge-mode: auto # 手动应答
          prefetch: 10 #每次从队列中取一个,轮询分发，默认是公平分发
          retry:
            max-attempts: 5 # 重试次数
            enabled: true # 开启重试
          concurrency: 5
          max-concurrency: 10
    mq2:
      username: guest
      password: guest
      host: mq2_ip
      port: 5672
      virtual-host: /
      publisher-returns: true
      publisher-confirm-type: simple
      listener:
        simple:
          acknowledge-mode: auto # 手动应答
          prefetch: 10 #每次从队列中取一个,轮询分发，默认是公平分发
          retry:
            max-attempts: 5 # 重试次数
            enabled: true # 开启重试
          concurrency: 5
          max-concurrency: 10

mq1消费端，发消息给mq2

@Component
public class SyncWeatherLivePicMessageReceiver  implements IMessageReceiver {
    private final IWeatherLivePicMapper weatherLivePicMapper;
    private final RabbitMQ2MessageSender rabbitMQ2MessageSender;

    @Autowired
    public SyncWeatherLivePicMessageReceiver(IWeatherLivePicMapper weatherLivePicMapper,
                                             RabbitMQ2MessageSender rabbitMQ2MessageSender) {
        this.weatherLivePicMapper = weatherLivePicMapper;
        this.rabbitMQ2MessageSender = rabbitMQ2MessageSender;
    }

    Log log = LogFactory.getLog(SyncWeatherLivePicMessageReceiver.class);
    private FtpHelper ftpHelperIns1;
    private FtpHelper ftpHelperIns2;
    private FTPFileFilter ftpFileFilter;
    @RabbitListener(queuesToDeclare = {
            @Queue(name = "sxqxgzbgxw_weather_live_pic")
    })
    @RabbitHandler
    @Override
    public void onMessageReceived(String mqMessageString) {
        JsonNode jsonNode = JsonConverter.jsonString2JsonNode(mqMessageString);
        JsonNode msg = jsonNode.findValue("msg");
        JsonNode JsonNodeParams = msg.findValue("params");
        Map<String, Object> params = JsonConverter.jsonNode2HashMap(JsonNodeParams);
        if (params.size() > 0) {
            String times = params.get("times").toString();
            String serverFrom = params.get("serverFrom").toString();
			......
            
			// 清除数据
			MQMessage mqMessage = new MQMessage();
			JSONObject jsonObject = new JSONObject();
			jsonObject.put("filePath", "/data/static/dataSharingStatic/weatherlive/colorFigure/png/610000/610000/"+ times);
			mqMessage.setMsg(jsonObject);
			rabbitMQ2MessageSender.send("queue.file_delay_destroy", mqMessage);

			// 清除DB记录
			MQMessage mqMessage2 = new MQMessage();
			JSONObject jsonObject2 = new JSONObject();
			jsonObject2.put("tableName", "WEATHER_LIVE_PIC");
			jsonObject2.put("picUrl", "http://外网ip/dataSharingStatic/weatherlive/colorFigure/png/610000/610000/"+ times +"/"+ type + "/" + "gjzjqyz/"+ fileNameFrom);
			mqMessage2.setMsg(jsonObject);
			rabbitMQ2MessageSender.send("queue.db_delay_destroy", mqMessage2);                
        }
    }
}

mq2消费端用于递归删除文件

import com.fasterxml.jackson.databind.JsonNode;
import com.sxqx.listener.IMessageReceiver;
import com.sxqx.utils.dataConverter.JsonConverter;
import com.sxqx.utils.file.FileHelper;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.io.File;

@Component
public class FileDestroyMessageReceiver implements IMessageReceiver {
  Log log = LogFactory.getLog(FileDestroyMessageReceiver.class);
  @RabbitListener(queuesToDeclare = {
      @Queue(name = "queue.file_destroy")
  })
  @RabbitHandler
  @Override
  public void onMessageReceived(String mqMessageString) {
    JsonNode jsonNode = JsonConverter.jsonString2JsonNode(mqMessageString);
    JsonNode msg = jsonNode.findValue("msg");
    String filePath = msg.findValue("filePath").asText();

    if (filePath.contains("/data/static/dataSharingStatic/weatherlive/colorFigure/png/610000/610000")) {
      File file = new File(filePath);
      if (file.exists()) {
        FileHelper.deleteFile(file);
      }
    } else {
      log.info("有人想删除设定之外的文件");
      log.info(filePath);
    }
  }
}

FileHelper工具类递归删除文件或文件夹

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;

public class FileHelper {
    /**
     * 递归删除文件或文件夹
     * @param directory
     */
    public static void deleteFile(File directory) {
        if (!directory.exists()) {
            return;
        }

        File[] files = directory.listFiles();
        if (files!=null) {//如果包含文件进行删除操作
            for (File value : files) {
                if (value.isFile()) {
                    //删除子文件
                    value.delete();
                } else if (value.isDirectory()) {
                    //通过递归的方法找到子目录的文件
                    deleteFile(value);
                }
                value.delete();//删除子目录
            }
        }
        directory.delete();
    }
}

mq2消费端用于删除数据库数据

import com.fasterxml.jackson.databind.JsonNode;
import com.sxqx.listener.IMessageReceiver;
import com.sxqx.mapper.remote.xugugzb.weatherlivepic.IWeatherLivePicMapper;
import com.sxqx.utils.dataConverter.JsonConverter;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Objects;

@Component
public class DBDestroyMessageReceiver implements IMessageReceiver {
  private final IWeatherLivePicMapper weatherLivePicMapper;
  @Autowired
  public DBDestroyMessageReceiver(IWeatherLivePicMapper weatherLivePicMapper){
    this.weatherLivePicMapper = weatherLivePicMapper;
  }
  Log log = LogFactory.getLog(DBDestroyMessageReceiver.class);
  @RabbitListener(queuesToDeclare = {
      @Queue(name = "queue.db_destroy")
  })
  @RabbitHandler
  @Override
  public void onMessageReceived(String mqMessageString) {
    JsonNode jsonNode = JsonConverter.jsonString2JsonNode(mqMessageString);
    JsonNode msg = jsonNode.findValue("msg");
    String tableName = msg.findValue("tableName").asText();
    String picUrl = msg.findValue("picUrl").asText();

    if (picUrl.contains("/dataSharingStatic/weatherlive/colorFigure/png/610000/610000/")) {
      if (Objects.equals("WEATHER_LIVE_PIC",tableName)) {
        weatherLivePicMapper.deleteWeatherLivePic(picUrl);
      }
    } else {
      log.info("有人想删除设定之外的数据");
      log.info(picUrl);
    }
  }
}

nginx.conf

上传静态资源至linux path，配置nginx.conf，使浏览器可以直接访问静态资源

server {
	listen       80;
	server_name  60.204.202.112;
	add_header   Cache-Control no-store;
	charset	     utf-8;

	location / {
		root   /mnt/sxqxgxw-gzb-front/dist/;
	try_files $uri $uri/ /index.html;
		index  index.html index.htm;
	}
	#访问/dataSharingStatic时,相当于访问/data/static/dataSharingStatic路径下资源
	location /dataSharingStatic {
		root   /data/static;
		autoindex   on;
		add_header  Access-Control-Allow-Origin *;
		add_header  Access-Control-Allow-Headers X-Requestd-With;
		add_header  Access-Control-Allow-Methods GET,POST,OPTIONS;
	}
	
	error_page   500 502 503 504  /50x.html;
	location = /50x.html {
		root   html;
	}
	
	location /api/ {
		proxy_pass    http://60.204.202.112:8896;
		rewrite	  ^/api/(.*)$ /$1 break;
		add_header    Access-Control-Allow-Origin *;
		add_header    Access-Control-Allow-Headers X-Requestd-With;
		add_header	  Access-Control-Allow-Methods GET,POST,OPTIONS;
	}
   
}
Benjamin Cheung
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot RabbitMQ 实现消息队列功能
禅与计算机程序设计艺术
07-29 1658
在企业级应用中，为了提升系统性能、降低响应延迟、改善用户体验、增加系统的稳定性、提高资源利用率等方面所需的功能之一就是使用消息队列。RabbitMQ是一个开源的AMQP(Advanced Message Queuing Protocol)的实现消息队列，它是用Erlang语言开发的。Spring AMQP为我们提供了基于RabbitMQ的消息发送、接收和管理的功能支持。在本教程中，我们将学习如何使用RabbitMQ以及Spring AMQP框架，通过构建一个简单的消息队列服务。
springboot与rabbitmq消息队列的整合
08-05
SpringBoot+RabbitMQ，springboot与rabbitmq消息队列的整合。
springboot中使用RabbitMq根据配置文件中定义队列名,实现动态创建多个队列并绑定到fanout交换机上
weixin_45799178的博客
11-27 2938
需求: 接收第三方回调消息, 两个独立的服务上分别消费这条消息 yml配置: rabbitmq: fanout: exchangeName: test # 解除绑定队列名称(解除后,会在增加和绑定 queueName中的队列) # 防止queueName中减少队列时,仍然存在绑定的关系 unbindQueueName: test1,test2 # 增加队列 & 绑定队列名称 queueName: test1,test2 配置类: @Config
SpringBoot+Rabbitmq多连接多队列
最新发布
qq_37822565的博客
05-24 170
【代码】SpringBoot+Rabbitmq多连接多队列。
07_Springboot 整合 RabbitMQ【5个消息队列模式】
书启鸿蒙知秋枫
07-12 645
3. 基础配置 3.1 application.properties 3.2 启动类 Application 3.3 RabbitConfig 配置类​​​​​​​ 3.4 生产者类 Product 4.​​​​​​​ 一对一发送（简单队列） 4.1 生产者 4.2 消费者 5. 一对多发送（工作队列） 5.1 生产者 5.2 消费者1 5.3 消费者2 6. ​​​​​​Fanout Exchange（发布/订阅） 6.1
SpringBoot配置多个RabbitMq
热门推荐
Good Luck
04-26 9万+
YML rabbitmq: first: username: ${app.appkey} password: ${app.appkey} virtual-host: ${app.appid} addresses: x.x.x.x:5672,x.x.x.x:5672 second: username: guest password: guest virtual-host: / host: 12
SpringBoot + RabbitMQ 做延时队列
qq_44680160的博客
12-19 1015
SpringBoot + RabbitMQ 做延时队列
springboot+rabbitmq实现延时队列
08-29
本教程将详细介绍如何使用SpringBoot集成RabbitMQ来实现一个延时队列，并探讨消息发送与消费确认机制以及消费者端的策略模式应用。 首先，SpringBoot是Java开发者广泛使用的快速开发框架，它简化了Spring的配置和...
SpringBoot整合Rabbitmq之死信队列
桐花思雨
09-25 2964
目录死信队列死信从何而来 死信队列 死信：无法被消费方消费掉的消息，称为死信。如果死信一直留在队列中，会导致一直被消费，却从不消费成功。所以 rabbitmq 专门开辟了一个来存放死信的队列，叫死信队列（DLX，dead-letter-exchange） 死信从何而来 消息被拒绝（调用 basicNack() 或 basicReject()，并且参数 requeue = false） 消息过期，过了 TTL 存活时间 队列设置了 x-max-length 最大消息数量且当前队列中的消息已经达到了这个数量，
SpringBoot整合Rabbitmq之延时队列
桐花思雨
09-27 1277
目录延时队列概念使用场景延时队列实现 延时队列 概念 延时队列是存储延时消息的队列，延时消息就是生产者发送了一条消息，但是不希望该消息不要被立即消费，而是设置一个延时时间，等过了这个时间再消费消息 使用场景 订单在十分钟之内未支付则自动取消 新创建的店铺，如果在十天内都没有上传过商品，则自动发送消息提醒 账单在一周内未支付，则自动结算 用户注册成功后，如果三天内没有登陆则进行短信提醒 用户发起退款，如果三天内没有得到处理则通知相关运营人员 这时候，延时队列就可以闪亮登场了，以上场景，正是延时队列的用武之
2024/5/13 SpringBoot配置多个RabbitMQ
Abcdzzr的博客
05-13 2158
配置单个RabbitMQ时不需要关心底层的连接工厂是如何配置的，当把yaml内容填好它会自动配置连接工厂，只需要把交换机、队列、配置绑定起来即可。当需要配置多个mq时才需要自己手动配置连接工厂，并不是只能配置两个RabbitMQ，可以按这个格式配置更多个。唯一注意的是不要把这些队列和交换机搞混了即可。
Spring Boot 配置多个RabbitMQ,多个消息源发送不同服务器IP
LMC技术人生专栏
07-26 1万+
项目代码构造  这里写图片描述  关注点在红框的代码。。。  代码  下面就把项目的代码展示下来  application.properties  配置文件  spring.application.name=rabbitmq-hello  # RabbitMQ  spring.rabbitmq.first.host=node9  spring.rabbitmq.first.port=5670  s...
SpringBoot整合RabbitMQ实战(多交换器多队列、手动ACK确认、死信队列)
qq_41539088的博客
03-17 3691
SpringBoot整合RabbitMQ，多交换器多队列配置、手动ACK确认、死信队列
rabbitmq 消息队列 多重绑定
web15536243458的博客
08-23 1188
想要解决其实很容易，只需要没两个实例所绑定的队列不同即可，最简单的就是以不同的名字申明所绑定的队列。两个不同的实例接收消息，相同的队列、相同的交换机、相同的routingkey，但是数据是交替接收的，不能两个实例同时接收同一条消息。今天遇到了个多重绑定的问题。
SpringBoot整合RabbitMQ消息队列
2302_76812487的博客
03-04 1663
/** * 将队列和交换机绑定, 并设置匹配路由键：directRouting * * @return */ @Bean public Binding bindingDirectExchange_A() { return BindingBuilder.bind(directQueue_A()).to(directExchange()).with("directRouting1");
Spring项目集成RabbitMQ及自动创建队列
邢慧鹏的博客
02-21 7640
简单记录项目集成RabbitMQ的过程，及项目启动自动创建队列
springBoot对接多个mq并且实现延迟队列---未完待续
weixin_43317111的博客
09-19 301
/设置延迟队列的 TTL 消息存活时间。//设置延迟队列的 TTL 消息存活时间。//设置延迟队列的 TTL 消息存活时间。//设置延迟队列绑定的死信交换机。//设置延迟队列绑定的死信路由键。//设置延迟队列绑定的死信交换机。//设置延迟队列绑定的死信路由键。//设置延迟队列绑定的死信交换机。//设置延迟队列绑定的死信路由键。// 设置消息转换器。// 设置消息转换器。
SpringBoot 整合 ActiveMQ，多个queue和多个topic实现，及前端VUE使用Stompjs接收
erf_1012的专栏
06-05 4590
参考自：https://www.cnblogs.com/yufeng218/p/11509486.html 一、ActiveMQ简介 1). ActiveMQ ActiveMQ是Apache所提供的一个开源的消息系统，完全采用Java来实现，因此，它能很好地支持J2EE提出的JMS（Java Message Service,即Java消息服务）规范。JMS是一组Java应用程序接口，它提供消息的创建、发送、读取等一系列服务。JMS提供了一组公共应用程序接口和响应的语法，类似于Java数据库的统一访问.
SpringBoot整合RabbitMQ以及Rabbit队列学习
天乔巴夏丶
06-25 738
文章目录RabbitMQ的相关概念RabbitMQ的几种模式Exchange的四种类型Linux系统上Rabbitmq的安装RabbitMQ的Web界面操作快速体验参考链接 RabbitMQ的相关概念 AMPQ：Advanced Message Queue Protocol，RabbitMQ是erlang开发的AMPQ的实现。 Message：消息，不具名，由消息头（由路由键routing-key，优先权priority，持久性存储delivery-mode等可选属性构成）和消息体（不透明）组成。 Pu
springboot配置多个rabbitmq
06-28
### 回答1： Spring Boot可以很容易地配置多个RabbitMQ实例。以下是配置多个RabbitMQ实例的步骤： 1. 在application.properties文件中添加多个RabbitMQ实例的配置信息。例如： spring.rabbitmq.host=host1 spring.rabbitmq.port=5672 spring.rabbitmq.username=user1 spring.rabbitmq.password=password1 spring.rabbitmq.second.host=host2 spring.rabbitmq.second.port=5672 spring.rabbitmq.second.username=user2 spring.rabbitmq.second.password=password2 2. 创建多个RabbitTemplate和ConnectionFactory bean。例如： @Configuration public class RabbitMQConfig { @Bean public ConnectionFactory connectionFactory() { CachingConnectionFactory connectionFactory = new CachingConnectionFactory(); connectionFactory.setHost(env.getProperty("spring.rabbitmq.host")); connectionFactory.setPort(env.getProperty("spring.rabbitmq.port", Integer.class)); connectionFactory.setUsername(env.getProperty("spring.rabbitmq.username")); connectionFactory.setPassword(env.getProperty("spring.rabbitmq.password")); return connectionFactory; } @Bean public RabbitTemplate rabbitTemplate() { RabbitTemplate template = new RabbitTemplate(connectionFactory()); return template; } @Bean(name = "secondConnectionFactory") public ConnectionFactory secondConnectionFactory() { CachingConnectionFactory connectionFactory = new CachingConnectionFactory(); connectionFactory.setHost(env.getProperty("spring.rabbitmq.second.host")); connectionFactory.setPort(env.getProperty("spring.rabbitmq.second.port", Integer.class)); connectionFactory.setUsername(env.getProperty("spring.rabbitmq.second.username")); connectionFactory.setPassword(env.getProperty("spring.rabbitmq.second.password")); return connectionFactory; } @Bean(name = "secondRabbitTemplate") public RabbitTemplate secondRabbitTemplate() { RabbitTemplate template = new RabbitTemplate(secondConnectionFactory()); return template; } } 3. 在需要使用RabbitMQ的地方，注入对应的RabbitTemplate或ConnectionFactory bean即可。例如： @Autowired private RabbitTemplate rabbitTemplate; @Autowired @Qualifier("secondRabbitTemplate") private RabbitTemplate secondRabbitTemplate; 使用以上步骤，就可以在Spring Boot应用中配置多个RabbitMQ实例了。 ### 回答2： 在Spring Boot中配置多个RabbitMQ会让应用程序变得更加灵活，这意味着应用可以与多个RabbitMQ实例连接，并能够发送和接收消息。 Spring Boot通过在配置文件(application.properties或application.yml)中定义多个RabbitMQ实例来实现多个RabbitMQ的配置。下面是在同一应用程序中配置两个RabbitMQ实例的示例： 在application.yml文件中添加以下内容： ``` spring.rabbitmq.host=server1 spring.rabbitmq.port=5672 spring.rabbitmq.username=user1 spring.rabbitmq.password=password1 spring.rabbitmq.virtual-host=/vhost1 spring.rabbitmq.second.host=server2 spring.rabbitmq.second.port=5672 spring.rabbitmq.second.username=user2 spring.rabbitmq.second.password=password2 spring.rabbitmq.second.virtual-host=/vhost2 ``` 在上面的示例中，我们定义了两个RabbitMQ实例，一个用于服务器1，另一个用于服务器2。对于每个实例，我们指定了名称，主机名，端口，用户名，密码和虚拟主机。 为了使用以上配置，我们需要通过@Resource注解或@Autowired注解在Java类中定义一个RabbitTemplate bean。同时在需要连接第二个RabbitMQ实例的地方指定使用哪个RabbitMQ实例即可。例如： ``` @SpringBootApplication public class DemoApplication implements CommandLineRunner { @Autowired private RabbitTemplate rabbitTemplate; @Autowired @Qualifier("secondRabbitTemplate") private RabbitTemplate secondRabbitTemplate; public static void main(String[] args) { SpringApplication.run(DemoApplication.class, args); } @Override public void run(String... args) throws Exception { rabbitTemplate.convertAndSend("queue1", "message1"); secondRabbitTemplate.convertAndSend("queue2", "message2"); } } ``` 在上面的代码中，我们注入了两个不同的RabbitTemplate实例，分别用于发送到不同的RabbitMQ实例。我们可以使用这两个实例来发送消息到不同的队列。在这个例子中，我们把“message1”发送到“queue1”，把“message2” 发送到“queue2”。 总之，配置多个RabbitMQ实例可以让Spring Boot应用程序与多个RabbitMQ连接，并实现更复杂的异构应用程序。我们只需要简单地在配置文件中添加多个实例，并通过Java类中的@Resource或@Autowired注解即可使用。 ### 回答3： Spring Boot 是一种流行的 Java 框架，用于快速构建基于 Spring 框架的应用程序。RabbitMQ 是一个流行的开源消息队列，常用于构建分布式系统。Spring Boot 提供了对 RabbitMQ 的支持，并允许用户配置多个 RabbitMQ。 配置多个 RabbitMQ，可以通过在 application.properties 或 application.yml 文件中添加多个 RabbitMQ 的配置来实现。如下所示： application.yml： ``` spring: rabbitmq: 1: host: localhost port: 5672 username: guest password: guest virtual-host: / 2: host: localhost port: 5673 username: guest password: guest virtual-host: / ... ``` application.properties： ``` spring.rabbitmq.1.host=localhost spring.rabbitmq.1.port=5672 spring.rabbitmq.1.username=guest spring.rabbitmq.1.password=guest spring.rabbitmq.1.virtual-host=/ spring.rabbitmq.2.host=localhost spring.rabbitmq.2.port=5673 spring.rabbitmq.2.username=guest spring.rabbitmq.2.password=guest spring.rabbitmq.2.virtual-host=/ ... ``` 其中，`1` 和 `2` 表示 RabbitMQ 的标识符。我们可以根据需要添加更多的标识符。在我们的应用程序中，我们可以使用以下方式注入多个RabbitMQ： ``` @Bean @Primary public ConnectionFactory connectionFactory1() { CachingConnectionFactory connectionFactory = new CachingConnectionFactory("localhost", 5672); connectionFactory.setUsername("guest"); connectionFactory.setPassword("guest"); return connectionFactory; } @Bean public RabbitTemplate rabbitTemplate1(ConnectionFactory connectionFactory1) { return new RabbitTemplate(connectionFactory1); } @Bean public SimpleMessageListenerContainer messageListenerContainer1( ConnectionFactory connectionFactory1) { SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory1); container.setQueueNames("queue1"); container.setDefaultRequeueRejected(false); container.setMessageListener(messageListenerAdapter1()); return container; } @Bean public MessageListenerAdapter messageListenerAdapter1() { return new MessageListenerAdapter(new MyMessageListener()); } @Bean public ConnectionFactory connectionFactory2() { CachingConnectionFactory connectionFactory = new CachingConnectionFactory("localhost", 5673); connectionFactory.setUsername("guest"); connectionFactory.setPassword("guest"); return connectionFactory; } @Bean public RabbitTemplate rabbitTemplate2(ConnectionFactory connectionFactory2) { return new RabbitTemplate(connectionFactory2); } @Bean public SimpleMessageListenerContainer messageListenerContainer2( ConnectionFactory connectionFactory2) { SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory2); container.setQueueNames("queue2"); container.setDefaultRequeueRejected(false); container.setMessageListener(messageListenerAdapter2()); return container; } @Bean public MessageListenerAdapter messageListenerAdapter2() { return new MessageListenerAdapter(new MyMessageListener()); } ``` 这样，在我们的应用程序中就可以使用`rabbitTemplate1`和`rabbitTemplate2`来发送消息，使用 `messageListenerContainer1`和`messageListenerContainer2`监听队列消息。 总结： 在 Spring Boot 配置多个 RabbitMQ 的过程中，我们需要在 application.properties 或 application.yml 中添加多个配置，注入多个 ConnectionFactory，RabbitTemplate 和 SimpleMessageListenerContainer 来进行发送和监听消息。同时，我们还需要根据实际情况调整配置，确保消息传递的正确性和可靠性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值