RabbitMQ 結合SpringBoot使用

已于 2022-01-26 12:04:48 修改
阅读量262 收藏
点赞数 1
分类专栏： # RabbitMQ 文章标签： rabbitmq spring boot java
于 2022-01-26 11:15:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45395031/article/details/108997841
版权

目录

1、 引入pom文件，加入依赖：

pom.xml

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

<dependency>
    <groupId>org.springframework.amqp</groupId>
    <artifactId>spring-rabbit-test</artifactId>
    <scope>test</scope>
</dependency>

2、yml 配置RabbitMQ信息

application.yml

spring:
  rabbitmq:
    host: localhost
    username: guest
    password: guest

一、简单模式

主程序

使用Spring自带的Queue类（队列的封装对象，封装了队列的基本信息。）。

RabbitMQ 的自动配置类，会发现这些Queue实例。然后放入RabbitMQ服务器中定义这些队列。

package com.example.rabbitmq;

import org.springframework.amqp.core.Queue;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class RabbitmqDemoApplication {

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

    @Bean
    public Queue task_queue() {
        /*
         * 可用以下形式:
         * new Queue("helloworld") - 持久,非排他,非自动删除
         * new Queue("helloworld",false,false,false,null)
         */
        return new Queue("helloworld",false);
    }

}

这个案例分别有生产者（sender）和消费者（receiver）

生产者

AmqpTemplate是RabbitMQ客户端API的一个封装工具,提供了简便的方法来执行消息操作.

AmqpTemplate由自动配置类自动创建，所以可以直接引用。

package com.example.rabbitmq.m1;

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class SimpleSender {

    @Autowired
    AmqpTemplate t;

    public void send() {
        // 这里向 helloworld 队列发送消息
        t.convertAndSend("helloworld", "Hello world!! "+System.currentTimeMillis());
        System.out.println("消息已发送");
    }
}

消费者

@RabbitListener从指定队列获取信息

package com.example.rabbitmq.m1;

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;

@Component
public class SimpleReceiver {

	// @RabbitListener 注解中也可以直接定义队列:
    @RabbitListener(queuesToDeclare = @Queue(name = "helloworld",durable = "false"))
    public void receive(String msg) {
        System.out.println("收到: "+msg);
    }
}

还可以使用这种方法
@RebbitHandler注解的方法来处理消息
@RabbitListener从指定队列获取信息

@Component 
@RabbitListener(queues = "helloworld") 
public class SimpleReceiver { 	
  
     @RabbitHandler 	
     public void receive(String msg) {
		    System.out.println("收到: "+msg);
     }
 }

编写测试类

在存放测试代码目录中，创建测试类

package com.example.rabbitmq;

import com.example.rabbitmq.m1.SimpleSender;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Scanner;

@SpringBootTest
public class SimpleTests {

    @Autowired
    SimpleSender simpleSender;

    @Test
    void test1() throws Exception {
        simpleSender.send();
        System.out.println("[按回车结束]");
        new Scanner(System.in).nextLine();
    }

}

二、工作模式

主程序

在主程序中创建名为task_queue的持久队列

package com.example.rabbitmq;

import org.springframework.amqp.core.Queue;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class RabbitmqDemoApplication {

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

    @Bean
    public Queue task_queue() {
        /*
         * 可用以下形式:
         * new Queue("helloworld") - 持久,非排他,非自动删除
         * new Queue("helloworld",false,false,false,null)
         */
        return new Queue("task_queue");
    }

}

生产者

package com.example.rabbitmq.m2;

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Scanner;

@Component
public class WorkSender {

    @Autowired
    AmqpTemplate t;

    public void send() {
        while (true) {
            System.out.print("输入:");
            String s = new Scanner(System.in).nextLine();

            //spring 默认将消息的 DeliveryMode 设置为 PERSISTENT 持久化,
            t.convertAndSend("task_queue", s);
        }
    }

}

spring boot封装的 rabbitmq api 中, 发送的消息默认是持久化消息. 如果希望发送非持久化消息,
需要在发送消息时做以下设置:

  • 使用 MessagePostProcessor 前置处理器参数
  • 从消息中获取消息的属性对象
  • 在属性中把 DeliveryMode 设置为非持久化
	t.convertAndSend("task_queue", (Object) s, message -> {
          	 MessageProperties props = message.getMessageProperties();
			 props.setDeliveryMode(MessageDeliveryMode.NON_PERSISTENT);
			 return message; 		
         } 	
    });

消费者

package com.example.rabbitmq.m2;

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class WorkReceiver1 {

    @RabbitListener(queues="task_queue")
    public void receive1(String s) throws Exception {
        System.out.println("receiver1 - 收到: "+s);
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '.') {
                Thread.sleep(1000);
            }
        }
    }

    @RabbitListener(queues="task_queue")
    public void receive2(String s) throws Exception {
        System.out.println("receiver2 - 收到: "+s);
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '.') {
                Thread.sleep(1000);
            }
        }
    }

}

测试类

package com.example.rabbitmq;

import com.example.rabbitmq.m2.WorkSender;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class WorkTests {
    @Autowired
    WorkSender workSender;

    @Test
    void test1() throws Exception {
        workSender.send();
    }
}

消息确认机制 - ack模式（默认auto模式）

在 spring boot 中提供了三种确认模式:

  • NONE - 使用rabbitmq的自动确认
  • AUTO - 使用rabbitmq的手动确认, springboot会自动发送确认回执 (默认)
  • MANUAL - 使用rabbitmq的手动确认, 且必须手动执行确认操作

默认的 AUTO 模式中, 处理消息的方法抛出异常, 则表示消息没有被正确处理, 该消息会被重新发送.

设置 ack 模式
spring:
  rabbitmq:
    host: 127.0.0.1
    username: guest
    password: guest
    listener: # rabbitmq的确认方式 
      simple:
        # acknowledgeMode: NONE # rabbitmq的自动确认
        acknowledgeMode: AUTO # rabbitmq的手动确认, springboot会自动发送确认回执 (默认)
        # acknowledgeMode: MANUAL # rabbitmq的手动确认, springboot不发送回执, 必须自己编码发送回执
手动执行确认操作

如果设置为 MANUAL 模式,必须手动执行确认操作

@RabbitListener(queues="task_queue")
public void receive1(String s, Channel c, @Header(name= AmqpHeaders.DELIVERY_TAG) long tag) throws Exception {
   System.out.println("receiver1 - 收到: "+s);
   for (int i = 0; i < s.length(); i++) {
       if (s.charAt(i) == '.') {
          Thread.sleep(1000);
        }
    }
    // 手动发送确认回执
    c.basicAck(tag, false);
}

抓取数量（默认值 250）

工作模式中, 为了合理地分发数据, 需要将 qos 设置成 1, 每次只接收一条消息, 处理完成后才接收下一条消息.

spring boot 中是通过 prefetch 属性进行设置, 改属性的默认值是 250.

发布和订阅模式

主程序

创建 FanoutExcnahge 实例, 封装 fanout 类型交换机定义信息.

spring boot 的自动配置类会自动发现交换机实例, 并在 RabbitMQ 服务器中定义该交换机.

package com.example.m3;

import org.springframework.amqp.core.FanoutExchange;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class Main {

	public static void main(String[] args) {
		SpringApplication.run(Main.class, args);
	}
	@Bean
	public FanoutExchange fanoutExchange() {
		return new FanoutExchange("logs");
	}
}

生产者

生产者向指定的交换机 logs 发送数据.

不需要指定队列名或路由键, 即使指定也无效, 因为 fanout 交换机会向所有绑定的队列发送数据, 而不是有选择的发送.

package com.example.m3;

import java.util.Scanner;

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class Publisher {
	@Autowired
	AmqpTemplate t;
	
	public void send() {
		while (true) {
			System.out.print("输入:");
			String s = new Scanner(System.in).nextLine();
			// 指定向 logs 交换机发送, 不指定队列名或路由键
			t.convertAndSend("logs","",s);
		}
	}
}

消费者

消费者需要执行以下操作:

  1. 定义随机队列(随机命名,非持久,排他,自动删除)
  2. 定义交换机(可以省略, 已在主程序中定义)
  3. 将队列绑定到交换机

spring boot 通过注解完成以上操作:

@RabbitListener(bindings = @QueueBinding( //这里进行绑定设置
	value = @Queue, //这里定义随机队列,默认属性: 随机命名,非持久,排他,自动删除
	exchange = @Exchange(name = "logs", declare = "false") //指定 logs 交换机,因为主程序中已经定义,这里不进行定义
))

package com.example.m3;

import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class Subscriber {
	@RabbitListener(bindings = @QueueBinding(value = @Queue, exchange = @Exchange(name = "logs", declare = "false")))
	public void receive1(String s) throws Exception {
		System.out.println("receiver1 - 收到: "+s);
	}
	@RabbitListener(bindings = @QueueBinding(value = @Queue, exchange = @Exchange(name = "logs", declare = "false")))
	public void receive2(String s) throws Exception {
		System.out.println("receiver2 - 收到: "+s);
	}
}

测试类

package cn.tedu.m3;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class PublishSubscribeTests {
	@Autowired
	Publisher publisher;

	@Test
	void test1() throws Exception {
		publisher.send();
	}
}

路由模式

与发布和订阅模式代码类似, 只是做以下三点调整:

使用 direct 交换机

队列和交换机绑定时, 设置绑定键
发送消息时, 指定路由键

主程序

主程序中使用 DirectExcnahge 对象封装交换机信息, spring boot 自动配置类会自动发现这个对象, 并在 RabbitMQ 服务器上定义这个交换机.

package cn.tedu.m4;

import org.springframework.amqp.core.DirectExchange;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class Main {

	public static void main(String[] args) {
		SpringApplication.run(Main.class, args);
	}
	@Bean
	public DirectExchange fanoutExchange() {
		return new DirectExchange("direct_logs");
	}
}

生产者

生产者向指定的交换机发送消息, 并指定路由键.

package cn.tedu.m4;

import java.util.Scanner;

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class RouteSender {
	@Autowired
	AmqpTemplate t;
	
	public void send() {
		while (true) {
			System.out.print("输入消息:");
			String s = new Scanner(System.in).nextLine();
			System.out.print("输入路由键:");
			String key = new Scanner(System.in).nextLine();
			// 第二个参数指定路由键
			t.convertAndSend("direct_logs",key,s);
		}
	}
}

消费者

消费者通过注解来定义随机队列, 绑定到交换机, 并指定绑定键:

@RabbitListener(bindings = @QueueBinding( // 这里做绑定设置
	value = @Queue, // 定义队列, 随机命名,非持久,排他,自动删除
	exchange = @Exchange(name = "direct_logs", declare = "false"), // 指定绑定的交换机,主程序中已经定义过队列,这里不进行定义
	key = {"error","info","warning"} // 设置绑定键
))

package cn.tedu.m4;

import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class RouteReceiver {
	@RabbitListener(bindings = @QueueBinding(value = @Queue,exchange = @Exchange(name = "direct_logs", declare = "false"),key = {"error"}))
	public void receive1(String s) throws Exception {
		System.out.println("receiver1 - 收到: "+s);
	}
	@RabbitListener(bindings = @QueueBinding(value = @Queue, exchange = @Exchange(name = "direct_logs", declare = "false"),key = {"error","info","warning"}))
	public void receive2(String s) throws Exception {
		System.out.println("receiver2 - 收到: "+s);
	}
}

测试类

package cn.tedu.m4;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class RouteTests {
	@Autowired
	RouteSender sender;

	@Test
	void test1() throws Exception {
		sender.send();
	}
}

主题模式

主题模式不过是具有特殊规则的路由模式, 代码与路由模式基本相同, 只做如下调整:

使用 topic 交换机
使用特殊的绑定键和路由键规则

主程序

package cn.tedu.m5;

import org.springframework.amqp.core.TopicExchange;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class Main {

	public static void main(String[] args) {
		SpringApplication.run(Main.class, args);
	}
	@Bean
	public TopicExchange fanoutExchange() {
		return new TopicExchange("topic_logs");
	}
}

生产者

package cn.tedu.m5;

import java.util.Scanner;

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class TopicSender {
	@Autowired
	AmqpTemplate t;
	
	public void send() {
		while (true) {
			System.out.print("输入消息:");
			String s = new Scanner(System.in).nextLine();
			System.out.print("输入路由键:");
			String key = new Scanner(System.in).nextLine();
			
			t.convertAndSend("topic_logs",key,s);
		}
	}
}

消费者

package cn.tedu.m5;

import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class TopicReceiver {
	@RabbitListener(bindings = @QueueBinding(value = @Queue,exchange = @Exchange(name = "topic_logs", declare = "false"),key = {"*.orange.*"}))
	public void receive1(String s) throws Exception {
		System.out.println("receiver1 - 收到: "+s);
	}
	@RabbitListener(bindings = @QueueBinding(value = @Queue, exchange = @Exchange(name = "topic_logs", declare = "false"),key = {"*.*.rabbit","lazy.#"}))
	public void receive2(String s) throws Exception {
		System.out.println("receiver2 - 收到: "+s);
	}
}

测试类

package cn.tedu.m5;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class TopicTests {
	@Autowired
	TopicSender sender;

	@Test
	void test1() throws Exception {
		sender.send();
	}

}

RPC异步调用

主程序

主程序中定义两个队列

发送调用信息的队列: rpc_queue
返回结果的队列: 随机命名

package cn.tedu.m6;

import java.util.UUID;

import org.springframework.amqp.core.Queue;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class Main {

	public static void main(String[] args) {
		SpringApplication.run(Main.class, args);
	}
	@Bean
	public Queue sendQueue() {
		return new Queue("rpc_queue",false);
	}
	@Bean
	public Queue rndQueue() {
		return new Queue(UUID.randomUUID().toString(), false);
	}
}

服务端

从rpc_queue接收调用数据, 执行运算求斐波那契数,并返回计算结果.
@Rabbitlistener注解对于具有返回值的方法:

会自动获取 replyTo 属性
自动获取 correlationId 属性
向 replyTo 属性指定的队列发送计算结果, 并携带 correlationId 属性

package cn.tedu.m6;

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class RpcServer {
	@RabbitListener(queues = "rpc_queue")
	public long getFbnq(int n) {
		return f(n);
	}

	private long f(int n) {
		if (n==1 || n==2) {
			return 1;
		}
		return f(n-1) + f(n-2);
	}
}

客户端

使用 SPEL 表达式获取随机队列名: “#{rndQueue.name}”

发送调用数据时, 携带随机队列名和correlationId

从随机队列接收调用结果, 并获取correlationId

package cn.tedu.m6;

import java.util.UUID;

import org.springframework.amqp.AmqpException;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessagePostProcessor;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;

@Component
public class RpcClient {
	@Autowired
	AmqpTemplate t;
	
	@Value("#{rndQueue.name}")
	String rndQueue;
	
	public void send(int n) {
		// 发送调用信息时, 通过前置消息处理器, 对消息属性进行设置, 添加返回队列名和关联id
		t.convertAndSend("rpc_queue", (Object)n, new MessagePostProcessor() {
			@Override
			public Message postProcessMessage(Message message) throws AmqpException {
				MessageProperties p = message.getMessageProperties();
				p.setReplyTo(rndQueue);
				p.setCorrelationId(UUID.randomUUID().toString());
				return message;
			}
		});
	}
	
	//从随机队列接收计算结果
	@RabbitListener(queues = "#{rndQueue.name}")
	public void receive(long r, @Header(name=AmqpHeaders.CORRELATION_ID) String correlationId) {
		System.out.println("\n\n"+correlationId+" - 收到: "+r);
	}
	
}

测试类

package cn.tedu.m6;

import java.util.Scanner;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class TopicTests {
	@Autowired
	RpcClient client;

	@Test
	void test1() throws Exception {
		while (true) {
			System.out.print("求第几个斐波那契数: ");
			int n = new Scanner(System.in).nextInt();
			client.send(n);
		}
	}

}

希望大家可以关注下我的公众号，嘻嘻！可以加入 java闲聊群，一起唠唠嗑！
在这里插入图片描述

小心仔
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
RabbitMQ - Spring boot 整合
wanght笔记
03-12 2万+
文章目录新建项目pom.xmlapplication.yml主程序简单模式创建主类生产者消费者测试类工作模式主类生产者生产者消费者ack模式设置 ack 模式手动执行确认操作抓取数量 新建项目 pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4...
elk+rabbitmq+springboot快速搭建日志系统
Honson的博客
12-31 897
elk+rabbitmq+springboot日志系统搭建说明 一、环境部署 1、使用工具（xshell等）远程连接到110服务器，首先部署好 elk (ElasticSearch，logstash，kibana) 和 rabbitmq elk和rabbitmq我先前已经在110服务器用docker部署好了，具体部署步骤自行查阅资料。（110服务器只是我当时使用的服务器地址，不用在意。） 2、进入logstash进行配置 如果创建logstash容器时使用 -v 绑定了某个卷，则不需要进入logsta
spring boot 配置文件application.yml中可以配置哪些配置项
李思苇
09-01 823
spring boot 配置文件application.yml中的可配置项。可以打开spring boot 的spring-boot-autoconfiguration工程的源码，在spring-boot-autoconfigure\src\main\java\org\springframework\boot\autoconfigure包中，找到以集成的框架的名字为名称的文件夹，然后找以*properties.java结尾的类，这个类中的大部分属性都是可以在application.yml中配置的配置项。..
SpringBoot日常：封装rabbitmq starter组件
最新发布
qq_32590535的博客
07-08 1039
本章内容主要介绍编写一个rabbitmq starter，能够通过配置文件进行配置交换机、队列以及绑定关系等等。项目引用该组件后能够自动初始化交换机和队列，并进行简单通信。 如若有其他需求，可自行扩展，例如消息消费的确认等
【详细步骤】Springboot整合RabiitMQ
咖啡程序员
12-10 2203
文章目录前言一、首先我们需要引入RabiitMQ的依赖二、然后进行配置1.在application.yml配置文件中进行RabbitMQ的配置2.创建配置类3.封装发送消息和接收消息的类三、测试1.随便在一个Contoller类中写一个测试方法2.启动项目 进行测试 前言 提示：Springboot整合RabiitMQ： 前面我们安装好了RabiitMQ并成功启动后，接下来我们就来学习如何将RabiitMQ整合到Springboot上，并且进行实战使用。springboot的项目创建这里就不进行说明了。
RabbitMQ的5种模式+使用SpringBoot实现
此为咸鱼的博客
06-17 2815
RabbitMQ的5种模式1、点对点，简单的生产者消费者2、工作模式（work）3、发布/订阅模式Publish/Subscribe4、routing路由模式5、topic主题模式 新建一个springboot的项目，引入RabbitMQ的pom.xml依赖 <dependency> <groupId>org.springframework.bo...
rabbitmq | rabbitTemplate的convertAndSend部分源码解析
weixin_43268715的博客
12-01 2505
在RabbitMQ中，事务是一种确保消息发送的可靠性的机制。Spring AMQP提供了对RabbitMQ事务的抽象，而作为Spring AMQP的核心组件，提供了许多简化消息发送的方法。在这篇博客中，我们将深入探讨RabbitMQ事务机制的源码实现，以及Spring封装的的使用。
rabbitmq结合springboot使用
07-15
使用 Spring Boot 集成 RabbitMQ 可以很方便地在应用程序中使用消息队列。首先需要在项目中引入相关的依赖，然后配置 RabbitMQ 的连接信息，最后在代码中使用 RabbitTemplate 和 AmqpAdmin 进行消息的发送和接收。
RabbitMQ整合SpringBoot综合应用
06-19
SpringBoot结合RabbitMQ，可以通过`TxManager`和`TransactionSynchronizationAdapter`实现消息发送与业务操作的事务一致性。 8. **错误处理和确认机制**：为了保证消息的可靠传输，可以启用消费者确认模式，当消费...
简单的RabbitMQ集成Springboot实现订单异步发送功能示例以及RabbitMQ的相关问题
captian_900331的博客
06-02 1547
【代码】简单的RabbitMQ集成Springboot实现订单异步发送功能示例。
Zipkin+Rabbitmq结合springboot2.0版本详细搭建流程
盛难晨
01-23 3888
下载Zipkin的jar包 zipkin下载链接 启动Zipkin java -jar zipkin-server-2.10.4-exec.jar --zipkin.collector.rabbitmq.addresses=192.168.23.134 --zipkin.collector.rabbitmq.username=账号 --zipkin.collector.rabbitmq.pass...
springboot使用rabbitmq工具类
03-29
springboot使用rabbitmq工具类,里面包含比较原生的方法,还有一套是我结合springboot框架写的一套方法,里面有两个方法,看情况使用,一般使用框架的方法比较好,因为框架方法时前辈们封装好经过检验的没有问题的方法,自己写的方法比较简陋,参考下原理即可.
RabbitMQ高级特性
qq_40432598的博客
03-11 623
RabbitMQ高级特性
《Spring Boot 实战派》--12.集成RabbitMQ,实现系统间的 数据交换
tumu6889的博客
05-28 3258
第12章集成RabbitMQ,实现系统间的数据交换 RabbitMQ是近年来使用非常广泛的消息中间件。 本章首先介绍它的原理、概念、6种工作模式、常用的注解； 然后用实例讲解在Spring Boot 中如何使用AmqpTemplate接口实现消息的发送和监听。 12.1认识RabbitMQ 12.1.1介绍RabbitMQ RabbitMQ 是开源的高级消息队列协议(Advanced Message Queueing Protocol, AMQP) 的实现，用Erlang语言编写，...
RabbitMQ消息持久化总结
weixiaohuai的博客
07-06 8898
一、简介 在RabbitMQ中，如果遇到RabbitMQ服务停止或者挂掉，那么我们的消息将会出现丢失的情况，为了在RabbitMQ服务重启的情况下，不丢失消息，我们可以将Exchange（交换机）、Queue（队列）与Message（消息）都设置为可持久化的（durable）。这样的话，能够保证绝大部分的消息不会被丢失，但是还有有一些小概率会发生消息丢失的情况。下面通过一个简单的示例总结在Rab...
RabbitMQ发送方确认机制
菜鸟逆袭之路
05-25 1978
RabbitMQ发送方确认机制
RabbitMQ-SpringBoot-direct模式
qq_42438218的博客
11-05 503
图解目标：1. 生产者发送消息到RabbitMQ2. 消费者从RabbitMQ获取消息3. 消息过期时间TTL4. 死信队列5. 消息确认机制代码结构。
Spring Cloud Stream整合Rabbit之重复投递
这个时代，作为程序员可能要学习小程序
08-23 639
点击上方关注 “终端研发部”设为“星标”，和你一起掌握更多数据库知识SpringCloudStream整合Rabbit时，消费端在处理失败时，如果需要进行重试，可以有如下几种重试机制：方法1（默认）：当消费端在处理消息时抛出异常，那么默认会在当前线程的3次的Retry。该方法是默认的，可以通过修改配置文件，指定channel下的参数，例如：1 2 3 4 5 6 7 8 9 10spring:...
消息机制-rabbitmq
明耀的博客
04-29 160
pom.xml <!-- rabbitmq--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId&gt...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小心仔

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值