springboot整合RabbitMQ

最新推荐文章于 2024-09-24 19:50:59 发布
最新推荐文章于 2024-09-24 19:50:59 发布
阅读量167 收藏
点赞数
分类专栏： SpringBoot RabbitMQ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22165667/article/details/84964969
版权

 

一、加入依赖

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

二、在application.properties文件配置RabbitMQ

#IP地址
spring.rabbitmq.host=localhost
#rabbitmq默认端口号
spring.rabbitmq.port=5672
#账户名和密码
spring.rabbitmq.username=admin
spring.rabbitmq.password=admin
spring.rabbitmq.virtual-host=/
spring.rabbitmq.publisher-confirms=true

三、Topic 示例

1、单生产者-单消费者

加入queue

@Configuration
public class RabbitConfig {
    public static final String TOPIC_QUEUE1 = "topic.queue1";

    @Bean
    public Queue topicQueue1() {
        return new Queue(TOPIC_QUEUE1);
    }
}

编写生产者与消费者 

@Component
public class Topic1 {
    @Autowired
    private AmqpTemplate rabbitTemplate;

    public void send() {
        String sendMsg = "helloWorld1 " + new Date();
        System.out.println("Sender1 : " + sendMsg);
        this.rabbitTemplate.convertAndSend(RabbitConfig.TOPIC_QUEUE1, sendMsg);
    }

    @RabbitListener(queues = RabbitConfig.TOPIC_QUEUE1)
    public void process(String hello) {
        System.out.println("Receiver1  : " + hello);
    }

}

测试

@Component
@EnableScheduling
public class RabbitmqTest {
    @Autowired
    private Topic1 topic1;
     /**
     * 一秒钟
     */
    @Scheduled(cron = "00/1 * * * * ?")
    public void send(){
       //单生产者-单消费者
       topic1.send();
    }
}

启动springboot项目

@SpringBootApplication
public class RabbitApp {
    public static void main(String[] args) {
        SpringApplication.run(RabbitApp.class, args);
    }
}

2、单生产者-多消费者

加入queue

@Configuration
public class RabbitConfig {
    public static final String TOPIC_QUEUE2 = "topic.queue2";
    
    @Bean
    public Queue topicQueue2() {
        return new Queue(TOPIC_QUEUE2);
    }
}

编写生产者与消费者 

@Component
public class Topic2 {
    @Autowired
    private AmqpTemplate rabbitTemplate;

    public void send(String msg) {
        String sendMsg = msg + new Date();
        System.out.println("Sender1 : " + sendMsg);
        this.rabbitTemplate.convertAndSend(RabbitConfig.TOPIC_QUEUE2, sendMsg);
    }

    @RabbitListener(queues = RabbitConfig.TOPIC_QUEUE2)
    public void process1(String hello) {
        System.out.println("消费者1 Receiver1  : " + hello);
    }

    @RabbitListener(queues = RabbitConfig.TOPIC_QUEUE2)
    public void process2(String hello) {
        System.out.println("消费者2 Receiver2  : " + hello);
    }

}

测试

@Component
@EnableScheduling
public class RabbitmqTest {
    @Autowired
    private Topic2 topic2;
    
     /**
     * 一秒钟
     */
    @Scheduled(cron = "00/1 * * * * ?")
    public void send(){
        //单生产者-多消费者
        topic2.send("hello");
    }
}

启动springboot项目

@SpringBootApplication
public class RabbitApp {
    public static void main(String[] args) {
        SpringApplication.run(RabbitApp.class, args);
    }
}

3、多生产者-多消费者

加入queue

@Configuration
public class RabbitConfig {
    public static final String TOPIC_QUEUE3 = "topic.queue3";
    
    @Bean
    public Queue topicQueue3() {
        return new Queue(TOPIC_QUEUE3);
    }
}

编写生产者与消费者  

@Component
public class Topic3 {

    @Autowired
    private AmqpTemplate rabbitTemplate;

    public void send1(String msg) {
        String sendMsg = msg + new Date();
        System.out.println("生产者-Sender1 : " + sendMsg);
        this.rabbitTemplate.convertAndSend(RabbitConfig.TOPIC_QUEUE3, sendMsg);
    }

    public void send2(String msg) {
        String sendMsg = msg + new Date();
        System.out.println("生产者-Sender2 : " + sendMsg);
        this.rabbitTemplate.convertAndSend(RabbitConfig.TOPIC_QUEUE3, sendMsg);
    }

    @RabbitListener(queues = RabbitConfig.TOPIC_QUEUE3)
    public void process1(String hello) {
        System.out.println("消费者-Receiver1  : " + hello);
    }

    @RabbitListener(queues = RabbitConfig.TOPIC_QUEUE3)
    public void process2(String hello) {
        System.out.println("消费者-Receiver2  : " + hello);
    }
}

 测试

@Component
@EnableScheduling
public class RabbitmqTest {
    @Autowired
    private Topic3 topic3;
    
     /**
     * 一秒钟
     */
    @Scheduled(cron = "00/1 * * * * ?")
    public void send(){
       //多生产者-多消费者
       topic3.send1("hello1");
       topic3.send2("hello2");
    }
}

启动springboot项目 

@SpringBootApplication
public class RabbitApp {
    public static void main(String[] args) {
        SpringApplication.run(RabbitApp.class, args);
    }
}

4、实体类传输

加入queue

@Configuration
public class RabbitConfig {
    public static final String TOPIC_QUEUE4 = "topic.queue4";
    
    @Bean
    public Queue topicQueue4() {
        return new Queue(TOPIC_QUEUE4);
    }
}

实体类（必须实现序列化接口）

public class User implements Serializable {
    private String id;
    private String name;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                '}';
    }
}

 编写生产者与消费者  

@Component
public class UserSender {
    @Autowired
    private AmqpTemplate rabbitTemplate;

    public void send() {
        User user=new User();
        user.setId("1");
        user.setName("fullmark");
        System.out.println("user send : " + user.getName()+"---"+user.getId());
        this.rabbitTemplate.convertAndSend(RabbitConfig.TOPIC_QUEUE4, user);
    }

    @RabbitListener(queues = RabbitConfig.TOPIC_QUEUE4)
    public void process(User user) {
        System.out.println("user receive  : " + user.getName()+"---"+user.getId());
    }

}

测试

@Component
@EnableScheduling
public class RabbitmqTest {
    @Autowired
    private UserSender userSender;
    
     /**
     * 一秒钟
     */
    @Scheduled(cron = "00/1 * * * * ?")
    public void send(){
       //实体类传输
       userSender.send();
    }
}

启动springboot项目  

@SpringBootApplication
public class RabbitApp {
    public static void main(String[] args) {
        SpringApplication.run(RabbitApp.class, args);
    }
}

四、topic ExChange示例

 加入queue

@Configuration
public class RabbitConfig {
    //topic
    public static final String TOPIC_QUEUE1 = "topic.queue1";
    public static final String TOPIC_QUEUE2 = "topic.queue2";
    //exchange
    public static final String TOPIC_EXCHANGE = "topic.exchange";
    
    @Bean
    public Queue topicQueue1() {
        return new Queue(TOPIC_QUEUE1);
    }

    @Bean
    public Queue topicQueue2() {
        return new Queue(TOPIC_QUEUE2);
    }    

    @Bean
    public TopicExchange topicExchange() {
        return new TopicExchange(TOPIC_EXCHANGE);
    }
    
    @Bean
    public Binding topicBinding1() {
        return         BindingBuilder.bind(topicQueue1()).to(topicExchange()).with("topic.queue1");
    }

    @Bean
    public Binding topicBinding2() {
        return BindingBuilder.bind(topicQueue2()).to(topicExchange()).with("topic.#");
    }
}

 编写生产者与消费者  

@Component
public class ExChange1 {
    @Autowired
    private AmqpTemplate rabbitTemplate;

    public void send() {
        String msg1 = "I am topic.mesaage msg1======";
        System.out.println("生产者-sender1 : " + msg1);
        this.rabbitTemplate.convertAndSend(RabbitConfig.TOPIC_EXCHANGE, RabbitConfig.TOPIC_QUEUE1, msg1);

        String msg2 = "I am topic.mesaages msg2########";
        System.out.println("生产者-sender2 : " + msg2);
        this.rabbitTemplate.convertAndSend(RabbitConfig.TOPIC_EXCHANGE, RabbitConfig.TOPIC_QUEUE2, msg2);
    }

    @RabbitListener(queues = RabbitConfig.TOPIC_QUEUE1)
    public void process1(String msg) {
        System.out.println("消费者-topicMessageReceiver1  : " +msg);
    }

    @RabbitListener(queues = RabbitConfig.TOPIC_QUEUE2)
    public void process2(String msg) {
        System.out.println("消费者-topicMessagesReceiver2  : " +msg);
    }
}

测试

@Component
@EnableScheduling
public class RabbitmqTest {
    @Autowired
    private ExChange1 exChange1;
    
     /**
     * 一秒钟
     */
    @Scheduled(cron = "00/1 * * * * ?")
    public void send(){
       //exChange
       exChange1.send();
    }
}

启动springboot项目  

@SpringBootApplication
public class RabbitApp {
    public static void main(String[] args) {
        SpringApplication.run(RabbitApp.class, args);
    }
}

五、fanout示例

Fanout 就是我们熟悉的广播模式或者订阅模式，给Fanout交换机发送消息，绑定了这个交换机的所有队列都收到这个消息

 加入queue

@Configuration
public class RabbitConfig {
    //fanout
    public static final String FANOUT_QUEUE1 = "fanout.queue1";
    public static final String FANOUT_QUEUE2 = "fanout.queue2";
    public static final String FANOUT_EXCHANGE = "fanout.exchange";
    
    @Bean
    public Queue fanoutQueue1() {
        return new Queue(FANOUT_QUEUE1);
    }

    @Bean
    public Queue fanoutQueue2() {
        return new Queue(FANOUT_QUEUE2);
    }

    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange(FANOUT_EXCHANGE);
    }

    @Bean
    public Binding fanoutBinding1() {
        return BindingBuilder.bind(fanoutQueue1()).to(fanoutExchange());
    }

    @Bean
    public Binding fanoutBinding2() {
        return BindingBuilder.bind(fanoutQueue2()).to(fanoutExchange());
    }
}

编写生产者与消费者

@Component
public class Fanout1 {
    @Autowired
    private AmqpTemplate rabbitTemplate;

    public void send() {
        String msgString="fanoutSender :hello i am fanout";
        System.out.println(msgString);
        this.rabbitTemplate.convertAndSend(RabbitConfig.FANOUT_EXCHANGE,"abcd.ee", msgString);
    }

    @RabbitListener(queues = RabbitConfig.FANOUT_QUEUE1)
    public void process(String msg) {
        System.out.println("FANOUT_QUEUE1-Receiver  : " + msg);
    }

    @RabbitListener(queues = RabbitConfig.FANOUT_QUEUE2)
    public void process2(String msg) {
        System.out.println("FANOUT_QUEUE2-Receiver : " + msg);
    }

}

测试

@Component
@EnableScheduling
public class RabbitmqTest {
    @Autowired
    private Fanout1 fanout1;
    
     /**
     * 一秒钟
     */
    @Scheduled(cron = "00/1 * * * * ?")
    public void send(){
       //fanout
       fanout1.send();
    }
}

启动springboot项目  

@SpringBootApplication
public class RabbitApp {
    public static void main(String[] args) {
        SpringApplication.run(RabbitApp.class, args);
    }
}

六、direct示例

消息中的路由键（routing key）如果和 Binding 中的 binding key 一致， 交换器就将消息发到对应的队列中。路由键与队列名完全匹配

加入queue

@Configuration
public class RabbitConfig {
    //redirect模式
    public static final String DIRECT_QUEUE1 = "direct.queue1";
    public static final String DIRECT_EXCHANGE = "direct.exchange";
    
    @Bean
    public Queue directQueue1() {
        return new Queue(DIRECT_QUEUE1);
    }

    @Bean
    public DirectExchange directExchange() {
        return new DirectExchange(DIRECT_EXCHANGE);
    }

    @Bean
    public Binding directBinding1() {
        return BindingBuilder.bind(directQueue1()).to(directExchange()).with("direct.admin");
    }
}

 编写生产者与消费者

@Component
public class Direct1 {

    @Autowired
    private AmqpTemplate rabbitTemplate;
    public void send() {
        String context = "hello " + new Date();
        System.out.println("Sender : " + context);
        rabbitTemplate.convertAndSend(RabbitConfig.DIRECT_EXCHANGE, "direct.admin", context);
    }

    @RabbitListener(queues = RabbitConfig.DIRECT_QUEUE1)
    public void process(String msg) {
        System.out.println("DIRECT_QUEUE1-Receiver  : " + msg);
    }

}

测试

@Component
@EnableScheduling
public class RabbitmqTest {

    @Autowired
    private Direct1 direct1;
    
    /**
     * 一秒钟
     */
    @Scheduled(cron = "00/1 * * * * ?")
    public void send(){
        direct1.send();
    }
}

启动springboot项目 

@SpringBootApplication
public class RabbitApp {
    public static void main(String[] args) {
        SpringApplication.run(RabbitApp.class, args);
    }
}

 

七、回调示例

 加入queue

@Configuration
public class RabbitConfig {
    //topic
    public static final String TOPIC_QUEUE1 = "topic.queue1";
    public static final String TOPIC_QUEUE2 = "topic.queue2";
    //exchange
    public static final String TOPIC_EXCHANGE = "topic.exchange";
    
    @Bean
    public Queue topicQueue1() {
        return new Queue(TOPIC_QUEUE1);
    }

    @Bean
    public Queue topicQueue2() {
        return new Queue(TOPIC_QUEUE2);
    }    

    @Bean
    public TopicExchange topicExchange() {
        return new TopicExchange(TOPIC_EXCHANGE);
    }
    
    @Bean
    public Binding topicBinding1() {
        return         BindingBuilder.bind(topicQueue1()).to(topicExchange()).with("topic.queue1");
    }

    @Bean
    public Binding topicBinding2() {
        return BindingBuilder.bind(topicQueue2()).to(topicExchange()).with("topic.#");
    }
}

设置回调配置

/**
 * @author fanghuanbiao
 */
public class RabbitCallbackConfig {
    @Value("${spring.rabbitmq.host}")
    private String addresses;

    @Value("${spring.rabbitmq.port}")
    private String port;

    @Value("${spring.rabbitmq.username}")
    private String username;

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

    @Value("${spring.rabbitmq.virtual-host}")
    private String virtualHost;

    @Value("${spring.rabbitmq.publisher-confirms}")
    private boolean publisherConfirms;

    @Bean
    public ConnectionFactory connectionFactory() {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setAddresses(addresses+":"+port);
        connectionFactory.setUsername(username);
        connectionFactory.setPassword(password);
        connectionFactory.setVirtualHost(virtualHost);
        /** 如果要进行消息回调，则这里必须要设置为true */
        connectionFactory.setPublisherConfirms(publisherConfirms);
        return connectionFactory;
    }

    @Bean
    /** 因为要设置回调类，所以应是prototype类型，如果是singleton类型，则回调类为最后一次设置 */
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    public RabbitTemplate rabbitTemplatenew() {
        RabbitTemplate template = new RabbitTemplate(connectionFactory());
        return template;
    }
}

编写生产与消费者

@Component
public class CallBackSender implements RabbitTemplate.ConfirmCallback {

    @Autowired
    private RabbitTemplate rabbitTemplatenew;

    public void send() {
        rabbitTemplatenew.setConfirmCallback(this);
        String msg="callbackSender : i am callback sender";
        System.out.println(msg );
        CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
        System.out.println("callbackSender UUID: " + correlationData.getId());
        this.rabbitTemplatenew.convertAndSend(RabbitConfig.TOPIC_EXCHANGE,  RabbitConfig.TOPIC_QUEUE2, msg, correlationData);
    }

    @Override
    public void confirm(CorrelationData correlationData, boolean b, String s) {
        System.out.println("callbakck confirm: " + correlationData.getId());
    }
    
    @RabbitListener(queues = RabbitConfig.TOPIC_QUEUE2)
    public void process(String hello) {
        System.out.println("消费者 Receiver1  : " + hello);
    }
}

测试

@Component
@EnableScheduling
public class RabbitmqTest {
    @Autowired
    private CallBackSender callBackSender;
    
     /**
     * 一秒钟
     */
    @Scheduled(cron = "00/1 * * * * ?")
    public void send(){
       callBackSender.send();
    }
}

启动springboot项目  

@SpringBootApplication
public class RabbitApp {
    public static void main(String[] args) {
        SpringApplication.run(RabbitApp.class, args);
    }
}
罗雀儿
关注
专栏目录
spring boot整合RabbitMq
weixin_44105305的博客
03-29 261
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。（但是关于rabbitMq的安装，就不介绍了）在安装完rabbitMq后，输入http://ip:15672/ ，是可以看到一个简单后台管理界面的。可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。
[SpringBoot系列004] SpringBoot整合RabbitMQ
檀越的博客
06-10 601
RabbitMQ是以AMQP协议实现的一种消息中间件产品， AMQP是Advanced Message Queuing Protocol的简称，它是一个面向消息中间件的开放式标准应用层协议。AMQP中定义了以下标准特性： 消息方向 消息队列 消息路由（包括：点到点模式和发布-订阅模式） 可靠性 安全性 安装RabbitMQ[windows] Erlang/OTP 20.3下载地址： http...
03_Springboot整合RabbitMQ
dys000000的博客
09-23 836
x-single-active-consumer：表示队列是否是单一活动消费者，true时，注册的消费组内只有一个消费者消费消息，其他被忽略，false时消息循环分发给所有消费者(默认false)System.out.println("DirectReceiver消费者收到消息 : " + testMessage.toString());x-dead-letter-routing-key：死信消息路由键，在消息发送到死信交换器时会使用该路由键，如果不设置，则使用消息的原来的路由键值。
SpringBoot 集成 RabbitMQ
qq_35091185的博客
07-30 1235
生产环境中，可以增加消费者并发数，提升消息处理能力。2、创建 Spring Boot 项目并添加依赖。SpringBoot 集成 RabbitMQ。4、生产者、消费者、队列、交换机和路由键。配置合理的消息 TTL，避免消息积压。1、安装并运行RabbitMQ服务器。Docker 安装 RabbitMQ。Spring Boot 项目添加依赖。可以将消息进行压缩，减少网络开销。3、配置 RabbitMQ。运行RabbitMQ容器。配置队列、交换机和路由键。配置 RabbitMQ。
Springboot之集成RabbitMQ
小小码农
11-06 360
在集成RabbitMQ之前，首先需要安装RabbitMQ，我选择的是在centos上安装，具体的安装步骤请移步在Centos7上安装RabbitMQ 首先开始安装的第一步： 1、修改pom.xml文件 springboot对rabbitmq有很好的支持，提供了starter，支持自动配置<!-- RabbitMQ --> <dependency> <groupId>org.spring
SpringBoot整合RabbitMQ.zip
06-29
SpringBoot整合RabbitMQ的详细过程 **1.该篇博文首先讲述了交换机和队列之间的绑定关系** ①direct、②fanout、③topic **2.然后讲消息的回调** 四种情况下，确认触发哪个回调函数： ①消息推送到server，但是在...
springBoot整合RabbitMQ案例
04-07
SpringBoot整合RabbitMQ是一个常见的后端开发任务，它涉及到分布式消息传递和Java应用程序的集成。RabbitMQ是一个开源的消息代理和队列服务器，而SpringBoot是基于Spring框架的简化版，提供了快速构建应用程序的方式...
springboot整合rabbitmq，开启手工确认。保证消息100%投递
09-16
在Spring Boot应用中整合RabbitMQ，以确保消息100%投递，是一个关键的实践，特别是对于那些需要高可靠性和数据一致性的系统。RabbitMQ是一个流行的开源消息代理，它遵循Advanced Message Queuing Protocol (AMQP)...
Springboot整合RabbitMQ最简单demo
07-11
Springboot整合RabbitMQ最简单demo,适用于springcloud项目,作为消息总线适用,需要安装RabbitMQ,Mac linux可以使用命令行一键安装,在项目配置文件配置好端口即可(已默认配置),启动项目访问8080端口,参数见controller.
springBoot整合rabbitMQ,包括erlang20.3,rabbitmq-server-3.7.14安装包
07-02
springBoot整合rabbitMQ,包括erlang20.3,rabbitmq-server-3.7.14安装包 整合4种常用模式+高级特性死信队列 暂未整合TTL队列 博客地址:...
spring boot整合rabbitmq
最新发布
m0_73968016的博客
09-24 816
通过以上步骤，你可以在Spring Boot应用中整合RabbitMQ，实现消息的发送和接收。这只是一个基础的示例，实际应用中可能需要更复杂的配置和错误处理机制。
spring boot 整合rabbitmq
weixin_39878226的博客
07-09 193
spring boot的环境怎么搭建这边就不提了， 这里引入spring boot -AMQP的依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> 配置连接,创建交换机，队列 首先 我和上面一样 先要配置连接信息这...
Spring Boot 集成 RabbitMQ
空明的博客
07-15 1617
Spring Boot 集成 RabbitMQ ,记录一些交换器类型、消息投递及消息确认方式的使用。
【springboot】整合rabbitmq
王佑辉的博客
02-19 180
springboot整合rabbitmq
springboot整合 rabbitmq
程序人生|
06-29 216
1 添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> 2 添加配置文件 rabbitmq: passw...
springboot 整合 rabbitmq
fjaljda的博客
11-10 958
springboot 整合 rabbitmq
springboot集成RabbitMQ
zhuchunyan_aijia的博客
05-08 689
springboot集成RabbitMQ非常简单，如果只是简单的使用配置非常少，springboot提供了spring-boot-starter-amqp项目对消息各种支持1、配置pom包，主要是添加spring-boot-starter-amqp的支持&lt;dependency&gt;        &lt;groupId&gt;org.springframework.boot&lt;/gro...
SpringBoot整合RabbitMQ
K_kzj_K的博客
06-09 4773
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上..
springboot 整合rabbitmq
09-07
Spring Boot框架可以很容易地与RabbitMQ进行集成。为了实现这个目标，你需要在项目的依赖项中添加两个关键的依赖项。首先，你需要添加spring-boot-starter-amqp依赖项，它提供了与RabbitMQ进行通信的必要类和方法。其次，你还需要添加spring-boot-starter-web依赖项，以便在项目中使用Web功能。 在你的项目中创建两个Spring Boot应用程序，一个是RabbitMQ的生产者，另一个是消费者。通过这两个应用程序，你可以实现消息的发送和接收。生产者应用程序负责将消息发送到RabbitMQ的消息队列，而消费者应用程序则负责从队列中接收并处理消息。这样，你就可以实现基于RabbitMQ的消息传递系统。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [SpringBoot整合RabbitMQ](https://blog.csdn.net/K_kzj_K/article/details/106642250)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"] - *2* [Springboot 整合RabbitMq ，用心看完这一篇就够了](https://blog.csdn.net/qq_35387940/article/details/100514134)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"] - *3* [undefined](undefined)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值