【RabbitMQ】SpringBoot的RabbitMQTemplate实战

最新推荐文章于 2024-08-01 21:08:43 发布
最新推荐文章于 2024-08-01 21:08:43 发布
阅读量1.9k 收藏 10
点赞数 1
分类专栏： Mq
原文链接：https://www.jianshu.com/p/580c924a15ad
版权

前言

此文面向的是对RabbitMQ有实战需求的Java开发者，希望读者有一定的RabbitMQ基础上进行阅读，本文主要解决的是SpringBoot中如何去使用RabbitMQTemplate

通信模型

在代码中使用MQ发送消息的过程是异步执行的，消息到达RabbitMQ后，会在通信模型中找到适合的队列进行入队。

RabbitMQ通信模型

下面来看看消息到达RabbitMQ会发生什么，Exchange会将消息通过RoutingKey将消息路由到相应的队列，每当有消息进入到队列中时，消费端就会监听到该消息进行消费。

Exchange

SpringBoot中对于Exchange有以下几种类型

交换机类型描述
DefaultSpring默认创建的交换机，它会将消息路由至名称与RoutingKey相同的队列。
Direct通过RoutingKey路由到与binding key相同的队列。(绑定routing key的fanout)
Topic支持通配符级别的binding key，支持一对多的消息发布
Fanout将消息发生到与交换机绑定的队列
Headers与Topic类似，基于消息的头信息进行路由
Dead letter死信交换机，无法投递的消息会到达这个交换机

SpringBoot集成RabbitMQ

  • pom.xml

可能会出现版本兼容的问题，可自行更换

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
    <version>2.3.5.RELEASE</version>
</dependency>
  • yml

SpringBoot的RabbitMQ具有丰富的配置，比如消费失败重试、消息确认模式、超时等,这里不做复杂的配置。用于简单的应用。

spring:
  rabbitmq:
    host: 192.168.14.148
    port: 5672
    username: root
    password: root
  • RabbitMQTemplate
package com.xjm.spring.data.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author jaymin
 * 2020/12/30 17:10
 */
@Configuration
@Slf4j
public class RabbitMQTemplateConfig {

    @Bean
    public RabbitTemplate rabbitTemplate(CachingConnectionFactory connectionFactory) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        rabbitTemplate.setMessageConverter(jackson2JsonMessageConverter());
        return rabbitTemplate;
    }

    @Bean
    public MessageConverter jackson2JsonMessageConverter(){
        Jackson2JsonMessageConverter jackson2JsonMessageConverter = new Jackson2JsonMessageConverter();
        return jackson2JsonMessageConverter;
    }
}

1. 默认交换机-简单的MQ发送与接收

  • config
package com.xjm.spring.data.rabbitmq.config;


import lombok.Getter;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author jaymin<br>
 * 简单的MQ配置类<br>
 * 2020/12/30 17:41
 */
@Configuration
@Getter
public class SimpleMQConfig {
    /**
     * 队列名
     */
    public static final String SIMPLE_QUEUE_NAME = "com.xjm.mq.simple";
    /**
     * 处理对象的MQ队列
     */
    public static final String HANDLER_OBJECT_QUEUE_NAME = "com.xjm.mq.simple.object";

    @Bean
    public Queue simpleQueue() {
        return new Queue(SIMPLE_QUEUE_NAME);
    }

    @Bean
    public Queue handleObjectQueue() {
        return new Queue(HANDLER_OBJECT_QUEUE_NAME);
    }

}
  • 生产者
package com.xjm.spring.data.rabbitmq.producer;

import com.xjm.modules.model.Order;
import com.xjm.spring.data.rabbitmq.config.SimpleMQConfig;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @author jaymin
 * 2020/12/30 17:42
 */
@Component
public class SimpleProducer {

    private RabbitTemplate rabbitTemplate;

    @Autowired
    public SimpleProducer(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
    }

    /**
     * 发生消息到RabbitMQ,使用SpringBoot默认的交换机<br>
     *
     * @param message
     */
    public void sendMessage(String message) {
        rabbitTemplate.convertAndSend(SimpleMQConfig.SIMPLE_QUEUE_NAME, message);
    }

    /**
     * 消息体为对象。配置MessageConverter为Jackson2JsonMessageConverter即可
     * @param order
     */
    public void sendOrderMessage(Order order){
        rabbitTemplate.convertAndSend(SimpleMQConfig.HANDLER_OBJECT_QUEUE_NAME, order);
    }
}
  • 消费者
package com.xjm.spring.data.rabbitmq.consumer;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.xjm.modules.model.Order;
import com.xjm.spring.data.rabbitmq.config.SimpleMQConfig;
import lombok.extern.slf4j.Slf4j;
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;

/**
 * @author jaymin
 * 2020/12/30 17:52
 */
@Component
@Slf4j
public class SimpleConsumer {

    @RabbitListener(queues = {SimpleMQConfig.SIMPLE_QUEUE_NAME})
    @RabbitHandler
    public void receiveMessage(String message) {
        log.info("simple consumer receive the message:{}", message);
    }

    @RabbitListener(queues = {SimpleMQConfig.HANDLER_OBJECT_QUEUE_NAME})
    @RabbitHandler
    public void receiveObject(Order order) throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();
        String message = objectMapper.writeValueAsString(order);
        log.info("simple consumer receive the object:{}", message);
    }
}
  • 单元测试
package com.xjm.rabbit;

import com.xjm.modules.model.Order;
import com.xjm.spring.data.rabbitmq.producer.SimpleProducer;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.time.LocalDateTime;
import java.util.Date;

/**
 * @author jaymin
 * 2020/12/30 17:54
 */
@RunWith(SpringRunner.class)
@SpringBootTest
@Slf4j
public class SimpleMQTest {
    @Autowired
    private SimpleProducer simpleProducer;

    @Test
    public void test() throws InterruptedException {
        simpleProducer.sendMessage("First message in spring boot.");
        Thread.sleep(10000);
    }

    @Test
    public void testOrder() throws Exception {
        simpleProducer.sendOrderMessage(Order.builder()
                .createTime(new Date())
                .name("Phone")
                .price("2000")
                .build());
        Thread.sleep(10000);
    }
}
  • Result

2. Direct型交换机的MQ模型:routingKey与bindingKey一致则投递

  • config
package com.xjm.spring.data.rabbitmq.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author jaymin
 * 2021/1/2 14:26
 */
@Configuration
public class DirectMQConfig {
    /**
     * 消息的routing key与队列的binding key相同的队列
     */
    public static final String DIRECT_QUEUE_NAME = "com.xjm.mq.direct";
    /**
     * direct 交换机
     */
    public static final String DIRECT_EXCHANGE_NAME = "com.xjm.mq.direct.exchange";
    /**
     * routing key
     */
    public static final String DIRECT_ROUTING_KEY_NAME = "com.xjm.mq.direct.routing.key";

    /**
     * 交换机
     * @return
     */
    @Bean
    public DirectExchange directExchange(){
        return new DirectExchange(DIRECT_EXCHANGE_NAME);
    }

    /**
     * 创建一条持久化的、非排他的、非自动删除的队列
     * @return
     */
    @Bean
    public Queue directQueue(){
        return new Queue(DIRECT_QUEUE_NAME);
    }

    /**
     * Binding,将该routing key的消息通过交换机转发到该队列
     * @return
     */
    @Bean
    public Binding directBinding(){
        return BindingBuilder.bind(directQueue()).to(directExchange()).with(DIRECT_ROUTING_KEY_NAME);
    }

}
  • 生产者:这里展示两种发消息的模式，一种是简单的发送消息，一种是往消息的Header中添加参数
package com.xjm.spring.data.rabbitmq.producer;

import com.xjm.spring.data.rabbitmq.config.DirectMQConfig;
import lombok.AllArgsConstructor;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.UUID;

/**
 * @author jaymin
 * 2021/1/2 14:43
 */
@Component
@AllArgsConstructor(onConstructor_ = {@Autowired})
public class DirectProducer {

    private RabbitTemplate rabbitTemplate;

    public void sendMessage(String message) {
        rabbitTemplate.convertAndSend(DirectMQConfig.DIRECT_EXCHANGE_NAME, DirectMQConfig.DIRECT_ROUTING_KEY_NAME, message);
    }

    /**
     * 发送消息时往请求头添加信息
     * @param message
     */
    public void sendMessageWithProperties(String message) {
        rabbitTemplate.convertAndSend(DirectMQConfig.DIRECT_EXCHANGE_NAME,
                DirectMQConfig.DIRECT_ROUTING_KEY_NAME,
                message,
                originalMessage -> {
                    MessageProperties messageProperties = originalMessage.getMessageProperties();
                    messageProperties.setHeader("X-TOKEN", UUID.randomUUID().toString());
                    return originalMessage;
                });
    }
}
  • 消费者
package com.xjm.spring.data.rabbitmq.consumer;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.xjm.spring.data.rabbitmq.config.DirectMQConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * @author jaymin
 * 2021/1/2 14:48
 */
@Component
@Slf4j
public class DirectConsumer {

    @RabbitListener(queues = {DirectMQConfig.DIRECT_QUEUE_NAME})
    @RabbitHandler
    public void receiveMessage(String message, Message originalMessage) throws JsonProcessingException {
        Map<String, Object> headers = originalMessage.getMessageProperties().getHeaders();
        ObjectMapper objectMapper = new ObjectMapper();
        String headersParam = objectMapper.writeValueAsString(headers);
        log.info("direct consumer receive the message:{},original message:{},\n headers param:{}", message, originalMessage.toString(), headersParam);
    }
}
  • 单元测试
package com.xjm.rabbit;

import com.xjm.spring.data.rabbitmq.producer.DirectProducer;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

/**
 * @author jaymin
 * 2021/1/2 14:49
 */
@RunWith(SpringRunner.class)
@SpringBootTest
@Slf4j
public class DirectMQTest {

    @Autowired
    private DirectProducer directProducer;

    @Test
    public void test() throws InterruptedException {
        directProducer.sendMessageWithProperties("Hello,2021");
        Thread.sleep(10000);
    }
}
  • Result

3. Fanout型交换机MQ模型:订阅模式，消息到达交换机会转发到与该交换机绑定的队列

  • config
package com.xjm.spring.data.rabbitmq.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


/**
 * @author jaymin<br>
 * fanout:订阅交换机,可以实现发布订阅模式的消费模型<br>
 * 2021/1/2 14:52
 */
@Configuration
public class FanoutMQConfig {
    /**
     * 与fanout绑定的第一个队列
     */
    public static final String FIRST_FANOUT_QUEUE_NAME = "com.xjm.mq.fanout.first";
    /**
     * 与fanout交换机绑定的第二个队列
     */
    public static final String SECOND_FANOUT_QUEUE_NAME = "com.xjm.mq.fanout.second";
    /**
     * fanout 交换机
     */
    public static final String FANOUT_EXCHANGE_NAME = "com.xjm.mq.fanout.exchange";

    /**
     * FanoutExchange,持久化、非自动删除
     *
     * @return
     */
    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange(FANOUT_EXCHANGE_NAME);
    }

    @Bean
    public Queue firstFanoutQueue() {
        return new Queue(FIRST_FANOUT_QUEUE_NAME);
    }

    @Bean
    public Queue secondFanoutQueue() {
        return new Queue(SECOND_FANOUT_QUEUE_NAME);
    }

    @Bean
    public Binding firstFanoutBinding() {
        return BindingBuilder.bind(firstFanoutQueue()).to(fanoutExchange());
    }

    @Bean
    public Binding secondFanoutBinding() {
        return BindingBuilder.bind(secondFanoutQueue()).to(fanoutExchange());
    }
}
  • 生产者
package com.xjm.spring.data.rabbitmq.producer;

import com.xjm.spring.data.rabbitmq.config.FanoutMQConfig;
import lombok.AllArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @author jaymin
 * 2021/1/2 14:52
 */
@Component
@AllArgsConstructor(onConstructor_ = {@Autowired})
public class FanoutProducer {

    private RabbitTemplate rabbitTemplate;

    /**
     * 发送消息至fanout交换机,由于fanout只关注订阅关系，所以routing key随便指定都可以
     * @param message
     */
    public void sendMessage(String message){
        rabbitTemplate.convertAndSend(FanoutMQConfig.FANOUT_EXCHANGE_NAME, StringUtils.EMPTY, message);
    }
}
  • 消费者
package com.xjm.spring.data.rabbitmq.consumer;

import com.xjm.spring.data.rabbitmq.config.FanoutMQConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * @author jaymin
 * 2021/1/2 14:52
 */
@Component
@Slf4j
public class FanoutConsumer {

    @RabbitListener(queues = {FanoutMQConfig.FIRST_FANOUT_QUEUE_NAME})
    @RabbitHandler
    public void firstReceiveMessage(String message) {
        log.info("first fanout consumer receive the message:{}", message);
    }

    @RabbitListener(queues = {FanoutMQConfig.SECOND_FANOUT_QUEUE_NAME})
    @RabbitHandler
    public void secondReceiveMessage(String message) {
        log.info("second fanout consumer receive the message:{}", message);
    }
}
  • 单元测试
package com.xjm.rabbit;

import com.xjm.spring.data.rabbitmq.producer.FanoutProducer;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

/**
 * @author jaymin
 * 2021/1/2 15:08
 */
@RunWith(SpringRunner.class)
@SpringBootTest
@Slf4j
public class FanoutMQTest {
    @Autowired
    private FanoutProducer fanoutProducer;

    @Test
    public void test() throws InterruptedException {
        fanoutProducer.sendMessage("Produce once,consume many times");
        Thread.sleep(10000);
    }
}
  • Result

4. Topic型交换机模型:将routingKey与binding key做通配符匹配，转发消息到匹配的队列

  • config
package com.xjm.spring.data.rabbitmq.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author jaymin
 * 2021/1/2 15:12
 */
@Configuration
public class TopicMQConfig {
    /**
     * 体育主题的篮球队列
     */
    public static final String BASKETBALL_TOPIC_QUEUE_NAME = "com.xjm.mq.topic.sports.basketball";
    /**
     * 体育主题的足球队列
     */
    public static final String FOOTBALL_TOPIC_QUEUE_NAME = "com.xjm.mq.topic.sports.football";
    /**
     * 读书主题的阅读队列
     */
    public static final String BOOK_TOPIC_QUEUE_NAME = "com.xjm.mq.topic.book";
    /**
     * 主题交换机
     */
    public static final String TOPIC_EXCHANGE_NAME = "com.xjm.mq.topic.exchange";
    /**
     * 体育主题
     */
    public static final String SPORTS_TOPIC = "topic.sports.#";
    /**
     * 读书主题
     */
    public static final String BOOK_TOPIC = "topic.book.#";

    @Bean
    public TopicExchange topicExchange() {
        return new TopicExchange(TOPIC_EXCHANGE_NAME);
    }

    @Bean
    public Queue basketBallQueue() {
        return new Queue(BASKETBALL_TOPIC_QUEUE_NAME);
    }

    @Bean
    public Queue footBallQueue() {
        return new Queue(FOOTBALL_TOPIC_QUEUE_NAME);
    }

    @Bean
    public Queue bookQueue() {
        return new Queue(BOOK_TOPIC_QUEUE_NAME);
    }

    @Bean
    public Binding basketBallBinding() {
        return BindingBuilder.bind(basketBallQueue()).to(topicExchange()).with(SPORTS_TOPIC);
    }

    @Bean
    public Binding footBallBinding() {
        return BindingBuilder.bind(footBallQueue()).to(topicExchange()).with(SPORTS_TOPIC);
    }

    @Bean
    public Binding bookBinding() {
        return BindingBuilder.bind(bookQueue()).to(topicExchange()).with(BOOK_TOPIC);
    }
}
  • 生产者
package com.xjm.spring.data.rabbitmq.producer;

import com.xjm.spring.data.rabbitmq.config.TopicMQConfig;
import lombok.AllArgsConstructor;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @author jaymin
 * 2021/1/2 15:32
 */
@Component
@AllArgsConstructor(onConstructor_ = {@Autowired})
public class TopicProducer {
    private RabbitTemplate rabbitTemplate;

    public void sendMessage(String message, String topic) {
        rabbitTemplate.convertAndSend(TopicMQConfig.TOPIC_EXCHANGE_NAME, topic, message);
    }
}
  • 消费者
package com.xjm.spring.data.rabbitmq.consumer;

import com.xjm.spring.data.rabbitmq.config.FanoutMQConfig;
import com.xjm.spring.data.rabbitmq.config.TopicMQConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * @author jaymin
 * 2021/1/2 15:35
 */
@Component
@Slf4j
public class TopicConsumer {

    @RabbitListener(queues = {TopicMQConfig.BASKETBALL_TOPIC_QUEUE_NAME})
    @RabbitHandler
    public void basketballReceiveMessage(String message) {
        log.info("basketball consumer receive the message:{}", message);
    }

    @RabbitListener(queues = {TopicMQConfig.FOOTBALL_TOPIC_QUEUE_NAME})
    @RabbitHandler
    public void footballReceiveMessage(String message) {
        log.info("football consumer receive the message:{}", message);
    }

    @RabbitListener(queues = {TopicMQConfig.BOOK_TOPIC_QUEUE_NAME})
    @RabbitHandler
    public void bookReceiveMessage(String message) {
        log.info("book consumer receive the message:{}", message);
    }
}
  • 单元测试
package com.xjm.rabbit;

import com.xjm.spring.data.rabbitmq.producer.TopicProducer;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

/**
 * @author jaymin
 * 2021/1/2 15:39
 */
@RunWith(SpringRunner.class)
@SpringBootTest
@Slf4j
public class TopicMQTest {

    @Autowired
    private TopicProducer topicProducer;

    @Test
    public void test() throws InterruptedException {
        topicProducer.sendMessage("start the game!", "topic.sports.news");
        topicProducer.sendMessage("SpringBoot 编程思想", "topic.book.springboot");
        Thread.sleep(10000);
    }
}
  • Result

如何更好地理解RabbitMQ消息队列中间件

首先,我们需要投递的消息可以理解成一封信
交换机充当邮局的作用，负责帮我们转发消息
每个队列充当的是收信箱
此时，发送信息的端为生产者；接收消息的端为消费者。
最后，通过一副图片来进行更具体的描述

https://www.jianshu.com/p/580c924a15ad

SpringBoot整合RabbitMQ之 典型应用场景实战一
青松之竹_Java博客
10-09 9万+
实战前言 RabbitMQ 作为目前应用相当广泛的消息中间件，在企业级应用、微服务应用中充当着重要的角色。特别是在一些典型的应用场景以及业务模块中具有重要的作用，比如业务服务模块解耦、异步通信、高并发限流、超时业务、数据延迟处理等。 其中课程的学习链接地址：https://edu.csdn.net/course/detail/9314 RabbitMQ 官网拜读 首先，让我们先拜读 Ra...
Spring Boot如何集成RabbitMQ？一文教你搞定！
最新发布
**My Coding Family**
04-27 1035
🏆 本文精选收录于《滚雪球学SpringBoot》专栏，专为零基础学习者量身打造。从Spring基础到项目实战，手把手带你掌握核心技术，助力你快速提升，迈向职场巅峰，开启财富自由之路🚀！无论你是刚入门的小白，还是已有基础的开发者，都能在这里找到适合自己的学习路径！    🌟 关注、收藏、订阅，持续更新中！和我们一起高速成长，突破自我！💡
SpringBoot 中使用 RabbitTemplate
qq_46539281的博客
07-26 5133
3.直接使用，导入rabbitTemplate类，使用rabbitTemplate.convertAndSend()方法。写在配置文件中，由RabbitProperties这个类进行读取，封装到ConnectionFactory中。（包括交换机选择与队列的配置，绑定），选择的模式在这里配置。1.写application.properties中的rabbitMq的连接配置等。0.rabbtMq的本地服务，得开启。（跟redis差不多）RabbitConfig（rabbitMq的配置类）......
rabbitmq RabbitTemplate
qq_33002953的博客
05-22 2740
@Bean public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) { RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory); return rabbitTemplate; } @Test public ...
Spring Boot整合RabbitMQ
梦幻通灵
10-31 451
RabbitMQ有6种消息模型
【六袆 - Java】RabbitMQ；RabbitmqTemplate类的作用；在SpringBoot项目使用RabbitMQ；在SpringBoot项目集成RabbitMQ；
六祎的博客
06-29 529
RabbitMQ 是一个消息代理：它接受并转发消息。您可以将它想象成一个邮局：当您将想要投递的邮件放入邮筒时，您可以确信信使最终会将邮件投递给您的收件人。在这个比喻中，RabbitMQ 就是邮筒、邮局和信件承运人。队列只受主机内存和磁盘限制的约束，它本质上是一个大型消息缓冲区。
Java使用RabbitMQ实战，Springboot使用rabbitMQ实战
秃了也弱了
06-27 971
引入依赖： 1、简单实例 2、延迟消息 RabbitMQ实现延迟消息，RabbitMQ使用死信队列实现延迟消息，RabbitMQ延时队列插件 4、消息属性设置 5、消息可靠投递 RabbitMQ保证消息的可靠投递，Java实现RabbitMQ消息的可靠投递，Springboot实现RabbitMQ消息的可靠投递引包： 1、简单实例 （1）引入rabbitMQ.xml （2）生产者 （3）消费者 （4）测试类 三、SpringBoot-API 1、spring-amqp介绍 Spring AMQ
RabbitMQ精讲7：与SpringBoot、Spring Cloud Stream整合实战
琦彦
04-16 2101
目录 与SpringBoot整合实战 1.生产端 2. 消费端 消费端核心配置： @RabbitListener注解使用 3.代码示例 3.1pom文件和消息实体 3.2生产者 3.3消费者 与Spring Cloud Stream整合实战 1. 架构介绍 2. 核心概念： 3.代码示例 3.1pom文件和消息实体 3.2生产者 3.3消费...
Spring Boot集成RabbitMQ的使用
码海浮生，一个乐于分享的全栈工程师！
08-01 1114
Spring Boot集成RabbitMQ的使用
SpringBoot 集成RabbitMQ，简单示例（附源码）
一碗清深的博客
03-19 487
在现代的分布式系统中，消息队列是一种常见的通信机制，用于解耦和异步处理。 RabbitMQ是一个流行的开源消息队列中间件，它提供了可靠的消息传递机制，并支持多种消息模式。 本文将介绍如何在Spring Boot项目中集成RabbitMQ，并提供一个简单的示例。
消息队列专题(实战篇)：SpringBoot 集成 RabbitMQ 入门级实战
盛夏温暖流年
11-26 2313
最近的学习劲头越来越足了，昨晚刚写完了 RabbitMQ 介绍与环境搭建篇，今天就开始更新实战篇了，想起原来同事对我的形容：生产队的驴都没你勤快，哈哈哈哈哈哈，说得可真对！ 言归正传，本篇博客参考了慕课网的 RabbitMQ 课程，在此基础上进行了简化，提供了一个最简单的无存储功能的消息队列实现，课程链接如下，感兴趣的小伙伴可自行进行学习： https://www.imooc.com/video/17845 配置消息队列 打开并登录消息队列的管理界面，首先来配置 exchange： 图中有三个参数，分别
rabbitmq-template:用于存储我的RabbitMQ模板的存储库
03-11
适用于RabbitMQ的Docker 描述 该存储库使使用docker构建RabbitMQ变得简单。 先决条件 快速开始 docker-compose up -d 设置 步骤1：将节点添加到您docker-compose.yml version : ' 3.3 ' services : rabbitmq : image : rabbitmq:3-management container_name : rabbitmq volumes : - rabbitmq-vol:/var/lib/rabbitmq - rabbitmq-log:/var/log/rabbitmq - ./conf/:/etc/rabbitmq/ networks : - rabbitmq-net 步骤2：在端口中添加默认端口
SpringBoot下RabbitMQ的实战应用：动态创建和动态监控队列、死信、备份交换机
土味儿
01-07 4222
每个用户对应一个普通队列；当用户过多时，相应的队列也会很多，并且队列是持久化的，会占用较多的系统资源；交换机收到消息，但无法投递时，转发至备份交换机，再广播至对应队列。缓存操作不是本文的重点，用模型类代替；缓存中未得到确认的消息，由定时器重新发送；用户登录后，动态切换要监控的队列；未发送成功的消息，由缓存保存，定时重发。如果用户退出后，也要更新监控列表；是接收不到的，消息会存储在相应对列中。发消息，消息应该不会被消费，存在。项目要足够稳健，消息不能丢失。交换机、队列、消息持久化。，这时再向上一个登录用户。
RabbitMq整合Springboot超全实战案例+图文演示+源码自取_rabbitmq springboot 实战
2401_84182578的博客
04-12 2586
RabbitMQ是一种开源的消息队列软件，它实现了高级消息队列协议（AMQP），提供了可靠的消息传递机制以及支持分布式应用程序之间的通信。RabbitMQ支持多种编程语言，如Java、Python、Ruby、PHP等等，并且可以在不同的操作系统上运行，如Windows、Linux、Mac OS等。RabbitMQ的核心理念是分离应用程序之间的通信，允许开发人员将其应用程序解耦，从而使它们更加容易理解、扩展和维护。
springboot集成rabbitmq商品秒杀业务实战（流量削峰）
明耀的博客
09-26 3151
转载：springboot集成rabbitmq商品秒杀业务实战（流量削峰） 消息队列如何实现流量削峰？ 要对流量进行削峰，最容易想到的解决方案就是用消息队列来缓冲瞬时流量，把同步的直接调用转换成异步的间接推送，中间通过一个队列在一端承接瞬时的流量洪峰，在另一端平滑地将消息推送出去。
SpringBoot整合RabbitMQ系列--RabbitTemplate的配置
IT利刃出鞘的博客
05-29 3452
本文用实例介绍SpringBoot整合RabbitMQ时RabbitTemplate的配置。
为什么要使用MQ消息中间件
bless295的博客
10-20 571
为什么要使用MQ消息中间件 1.应用场景 1.1 异步处理 场景说明：用户注册后，需要发注册邮件和注册短信,传统的做法有两种1.串行的方式;2.并行的方式 (1)串行方式:将注册信息写入数据库后,发送注册邮件,再发送注册短信,以上三个任务全部完成后才返回给客户端。 这有一个问题是,邮件,短信并不是必须的,它只是一个通知,而这种做法让客户端等待没有必要等待的东西. (2)并行方式:将注册信息写入数据库后,发送邮件的同时,发送短信,以上三个任务完成后,返回给客户端,并行的方式能提高处理的时间。 假设
Spring Boot 中的 RabbitTemplate 是什么，原理，如何使用
it_xushixiong的博客
07-01 3658
本文介绍了 RabbitTemplate 的原理、使用方法和常见应用场景。RabbitTemplate 是 Spring Boot 应用程序中与 RabbitMQ 集成的关键组件，它封装了 AMQP 协议的细节，提供了简单的 API 来进行消息发送和接收。通过本文的介绍，读者可以了解 RabbitTemplate 的基本原理和使用方法，并在实际项目中使用 RabbitTemplate 实现异步任务处理和发布订阅模式等应用场景。
springboot+Rabit实战三：(springboot+rabbit 项目搭建)
u012149894的专栏
12-23 567
一：pom.xml 引入rabbitmqjar 包： org.springframework.boot spring-boot-starter-amqp   二：配置文件中配置rabbit 的连接信息，如下图： #application setting spring.application.name=spring-boot-rabbitmq serve
RabbitMQ springboot
02-27
### 配置与集成 为了在Spring Boot项目中集成RabbitMQ实现消息队列功能，需先添加Maven或Gradle中的RabbitMQ依赖项。对于Maven而言，在`pom.xml`文件内加入如下依赖： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> ``` 随后，在Spring Boot应用的配置文件（如`application.properties`或`application.yml`）里设定RabbitMQ的相关连接参数[^3]。 #### Java代码实例：创建消息生产者 下面展示了一个简单的Java类用于向名为`myQueue`的消息队列发送字符串形式的信息： ```java import org.springframework.amqp.core.Queue; import org.springframework.amqp.rabbit.connection.ConnectionFactory; import org.springframework.amqp.rabbit.core.RabbitTemplate; import org.springframework.context.annotation.Bean; import org.springframework.stereotype.Component; @Component public class MessageProducer { private final RabbitTemplate rabbitTemplate; public MessageProducer(ConnectionFactory connectionFactory){ this.rabbitTemplate = new RabbitTemplate(connectionFactory); } @Bean Queue myQueue(){ return new Queue("myQueue", false); } void sendMessage(String messageContent){ System.out.println("[x] Sent '" + messageContent + "'"); rabbitTemplate.convertAndSend("myQueue",messageContent); } } ``` 此段程序展示了如何利用Spring AMQP库简化了与RabbitMQ交互的过程；通过注入ConnectionFactory对象构建RabbitTemplate实例完成消息发送操作，并定义了一个无持久化的队列供测试之用[^1]。 #### 关于死信队列和延迟队列 当涉及到更复杂的需求比如处理失败重试机制或是定时任务调度时，则可考虑引入死信队列以及基于官方提供的`rabbitmq-delayed-message-exchange`插件来达成延时投递的效果[^5]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值