Rabbitmq+Spring boot

最新推荐文章于 2024-09-26 13:26:44 发布
最新推荐文章于 2024-09-26 13:26:44 发布
阅读量141 收藏
点赞数
文章标签： rabbitmq java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53088095/article/details/120421140
版权

Rabbitmq加Spring boot

依赖：

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

配置，写的是jvm中rabbit的地址和自己设置rabbit账户

spring:
  rabbitmq:
    host: 192.168.120.150
    username: admin
    password: admin
    # virtual-host: 自己的空间

Spring提供的Queue类,是队列的封装对象,它封装了队列的参数信息.

RabbitMQ的自动配置类,会发现这些Queue实例,并在RabbitMQ服务器中定义这些队列.

创建一个容器管理的队列，斜面都系要，只是名字不同

	/*创建 spring 的 Queue 对象，用来封装队列的参数，
	RabbitAutoConfiguration 自动配置类，会自动发现 Queue 实例，
	使用这里的参数，连接服务器在服务器上创建队列
	 */
	@Bean
	public Queue task_queue() {
		/*
		 * 可用以下形式: （默认）
		 * new Queue("helloworld") - 持久,非排他,非自动删除
		 * new Queue("helloworld",ture,false,false,null)
		 */
		return new Queue("helloworld");
	}

第一、简单模式

qizgogn AmqpTemplate是rabbitmq客户端API的一个封装工具,由自动配置类自动创建

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

@Component
public class Product {
	// spring提供的用来发送消息的工具对象
	//在 RabbitAutoConfiguration中创建

	@Autowired
	AmqpTemplate t;
	
	public void send() {
		// 这里向 helloworld 队列发送消息
		//如果说是对象的话，需要将对象序列化（byte[]）
		t.convertAndSend("helloworld", "Hello world!! "+System.currentTimeMillis());
		System.out.println("消息已发送");
	}
}

2.通过@RabbitListener从指定的队列接收消息,使用@RebbitHandler处理消息

方式一

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

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

方式二、同时也可以只使用@RebbitHandler直接接收和处理消息

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

@RabbitListener也能直接定义队列

	@RabbitListener(queuesToDeclare = @Queue(name = "helloworld",durable = "false"))

测试，工作模式和ASK可用
试一试代码效果

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 ProductTests {
	@Autowired
	Product p ;

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

或者在启动类测试哦

 // 添加测试代码，调用生产者发送消息
    @Autowired
    private Producer p;
    /*
      spring 的执行流程：
      包扫描创建所有实例 --> 完成所有的依赖注入 --> @PostConstruct --> 后续流程自动配置类，消费者.....
     */
    @PostConstruct
    public void test() {
        // new Thread(new Runnable() {
        //     @Override
        //     public void run() {
        //         p.send();
        //     }
        // }).start();

        // lambda表达式，是匿名内部类的简化语法
        new Thread(() -> p.send()).start();
    }

第二、工作模式

现在需要创建持久队列
因为上面使用过名为helloworld的队列，如果还需要使用该队列名，只能把注册的队列删除之后再创建
springboot中queue默认是，持久，非独占，非自动删除

@Component
public class Product {
	@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);
			// t.convertAndSend( "task_queue",s，消息预处理器,可以重新设置消息的属性);
		}
	}
}

如果需要将发送非持久化消息,
则使用 MessagePostProcessor 前置处理器参数，在属性中把 DeliveryMode 设置为非持久化

	//如果需要设置消息为非持久化,可以取得消息的属性对象,修改它的deliveryMode属性
	t.convertAndSend("task_queue", (Object) s, new MessagePostProcessor() {
		@Override
		public Message postProcessMessage(Message message) throws AmqpException {
			MessageProperties props = message.getMessageProperties();
			props.setDeliveryMode(MessageDeliveryMode.NON_PERSISTENT);
			return message;
		}
	});

设置两个消费者接受消息

@Component
public class Consumer {
	@RabbitListener(queues="task_queue")
	public void receive1(String s) throws Exception {
		System.out.println("receiver1 - 收到: "+s);
		
	}
	
	@RabbitListener(queues="task_queue")
	public void receive2(String s) throws Exception {
		System.out.println("receiver2 - 收到: "+s);
		
		
	}

第三、合理分发ack模式,懂？哈哈，另外一篇简单测试有介绍

ACK\QOS

ack-- spring封装的rabbitmq，已经是手动ack模式，
spring会自动发送回执
qos=1 – spring默认设置的qos是250，
yml中可以改变

配置一下

spring:
  rabbitmq:
    listener:
      simple:
        # acknowledgeMode: NONE # rabbitmq的自动确认
        acknowledgeMode: AUTO # rabbitmq的手动确认, springboot会自动发送确认回执 (默认)
        # acknowledgeMode: MANUAL # rabbitmq的手动确认, springboot不发送回执, 必须自己编码发送回执

抓取数量的话，还要配置
qos 设置成 1, 每次只接收一条消息, 处理完成后才接收下一条消息

spring:
  rabbitmq:
    listener:
      simple:
        prefetch: 1 # qos=1, 默认250

手动执行确认操作
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);
		// 手动发送确认回执
		c.basicAck(tag, false);
	}

第四、发布和订阅模式(广播模式)

创建的是Fanout交换机

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


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

发送消息

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 交换机发送, 不指定队列名或路由键
			//对于fanout交换机来说，""时无效的
			t.convertAndSend("logs","",s);
		}
	}
}

接收的消费者

package cn.tedu.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") //指定 logs 交换机,因为主程序中已经定义,这里不进行定义
))
	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);
	}
}

测试吗

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

路由模式

使用 direct 交换机

@Bean
	public DirectExchange fanoutExchange() {
		return new DirectExchange("direct_logs");
	}

@Component
public class RouteProduct {
	@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);
		}
	}
}


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

	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);
	}
}

主题模式

使用 topic 交换机

@Bean
	public TopicExchange fanoutExchange() {
		return new TopicExchange("topic_logs");
	}

@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);
		}
	}
}

@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);
	}
}

最麻烦最难的 RPC异步调用

需要定义两个队列
生产者发送到调用队列，在发送到消息上需要携带两个数据（1.返回的队列名2关联id标识）
关联i的话，是一个生产者发出多条消息时，后端负载均衡处理，返回时没有标识将不知道是第几次发出的响应消息。也可以设置每条消息发出将有一个新的返回队列，但这样太消耗内存
在这里插入图片描述
可以负载均衡方式接受处理队列消息
在这里插入图片描述
创建两个队列


@Bean
	public Queue sendQueue() {
		return new Queue("rpc_queue",false);
	}
	@Bean
	public Queue rndQueue() {
		return new Queue(UUID.randomUUID().toString(), false);
	}

处理：
@Rabbitlistener注解对于具有返回值的方法:
会自动获取 replyTo 属性
自动获取 correlationId 属性
向 replyTo 属性指定的队列发送计算结果, 并携带 correlationId 属性

@Component
public class Server {
    /*
    如果处理消息的方法不是 void，有返回值，
    那么 spring 会把返回值，通过返回队列发回到客户端，并携带关联id
     */
    @RabbitListener(queues = "rpc-queue")
    public long receive(int n) {
        long r = f(n);
        return r;
    }

    private long f(int n) {
        long a = 1;
        long b = 1;
        for (int i = 3; i <= n; i++) {
            b = a+b;
            a = b-a;
        }
        return b;
    }
}

 /* 
    SPEL --- Spring Expression Language
    直接访问 spring 容器中的对象
    #{rndQueue.name}

    OGNL --- Object Graph Navigation Language
    Struts2 中的一种标记
    ${}
     */
@Component
public class Client {
    @Autowired
    private AmqpTemplate t;

    @Value("#{rndQueue.name}")
    private String replyTo;

    public void send(int n) {
        t.convertAndSend("rpc-queue", n, (message) -> {
            MessageProperties p = message.getMessageProperties();
            p.setReplyTo(replyTo);
            p.setCorrelationId(UUID.randomUUID().toString());
            return message;
        });
    }

    @RabbitListener(queues = "#{rndQueue.name}")
    public void receive(long r, @Header(name = AmqpHeaders.CORRELATION_ID) String cid) {
        System.out.println(cid + "--- 结果："+r);
    }
}

更精确的RPC模式

josion.
关注
RabbitMq+springboot
04-20
demo中介绍了rabbitmq的三种模式，分别为Direct，topic，Fanout并且集成了消息确认机制，消息重发机制集以及集群， 需要用到的同学可以下载看看，少走弯路。
RabbitMQ+SpringBoot
justisme的博客
03-22 234
RabbitMQ+SpringBoot 引入依赖pom.xml 配置密码:application.properties 配置模式(简单队列、Work模式、Topic Exchange（主题模式）、Fanout Exchange（订阅模式）)，以下为简单队列。 配置生产者(sender)和消费者(recevier)
【RabbitMQ——SpringBoot整合】
qq_45467608的博客
09-26 775
Fanout 交换器（Exchange）是 RabbitMQ 中的一种消息路由模式。它是一种广播式的交换器，会将接收到的消息发送给所有绑定到该交换器的队列，而不考虑路由键（routing key）。这意味着无论消息发布时指定了什么路由键，Fanout 交换器都会忽略这些信息，并简单地将消息复制并分发给所有的绑定队列。
rabbitmq+springboot
qq_45562888的博客
03-30 269
https://www.cnblogs.com/liconglong/p/15150370.html
RabbitMQ——SpringBoot集成RabbitMQ
贝尔摩德苦艾酒
06-30 8724
RabbitMQ——SpringBoot集成RabbitMQ
RabbitMQ（三）：RabbitMQ与Spring Boot简单整合
07-27 314
RabbitMQ是目前非常热门的一款消息中间件，不管是互联网大厂还是中小企业都在大量使用。Spring Boot的兴起，极大地简化了Spring的开发，本文将使用Spring Boot与RabbitMQ进行简单整合，实现生产和消费消息。 配置 Spring Boot使用了这么久，套路差不多摸清楚了。Spring Boot与其他组件进行整合，无非就是加入pom依赖，接着配置一些基本信息，然...
rabbitmq + spring boot demo 消息确认、持久化、备用交换机、死信交换机等代码
03-07
RabbitMQ作为一款流行的开源消息中间件，广泛应用于Spring Boot项目中。本教程将详细介绍如何在Spring Boot应用中结合RabbitMQ实现消息确认、消息持久化、备用交换机以及死信交换机等功能。 首先，让我们理解这些...
基于React+Spring Boot+RabbitMQ+AIGC的智能BI数据分析平台设计源码
最新发布
10-24
该项目为基于React、Spring Boot、RabbitMQ和AIGC技术的智能BI数据分析平台设计源码。该平台支持用户快速导入数据表格，并输入分析目标，系统将借助AI自动生成定制化的可视化图表，同时提供分析结论和问题解答。用户...
springbootj集成canal+mysql+rabbitmq
10-11
mysql需开启binlog 查看是否开启binlog ...3.3 rabbitmq配置 在virtualHost：/ 下新增Exchanges： canal.exchange 新增队列：test.queue, 绑定canal.queue， RoutingKey：canal.routing.key canal下载及配置 ...
springboot+rabbitMQ+websocket
07-28
接下来，我们将深入探讨如何利用Spring Boot、RabbitMQ和WebSocket来实现一个简单的消息推送聊天应用。 首先，让我们了解Spring Boot如何集成RabbitMQ。在Spring Boot项目中引入`spring-boot-starter-amqp`依赖，它...
详解Spring Boot 配置多个RabbitMQ
08-30
Spring Boot 配置多个 RabbitMQ Spring Boot 是一个流行的 Java 框架，用于快速构建生产级别的应用程序。RabbitMQ 是一个消息队列中间件，用于实现异步消息处理和队列管理。配置多个 RabbitMQ 实例是为了提高系统的...
rabbitmq+springboot实现的rabbitmq
12-06
一个实现rabbitmq的案例，非常适合初学者学习，springboot+rabbitmq实现
RabbitMQ连接池+SpringBoot实现
02-11
RabbitMQ连接池+SpringBoot实现。通过连接池实现将高效的管理RabbitMQ的Connection，并与springboot进行整合，实现消息发送，获取队列列表等功能。基于此可以进行更多功能的扩充。
RabbitMQ整合Springboot
weixin_72388638的博客
06-22 1753
消息队列
RabbitMQ整合SpringBoot
qq_48403611的博客
07-14 415
RabbitMQ整合SpringBoot实现延时队列
【RabbitMQ】之 RabbitMQ 与 SpringBoot 整合
王廷云的博客
04-07 2167
一、SpringBoot 整合 RabbitMQ 1）、引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> 2）、添加配置 # 配置 RabbitMQ 服务器 IP 和端口 spring.rabbitmq.host=19
RabbitMQ入门及--Spring Boot整合
灵越启航
09-17 328
RabbitMQ消息中间件 一、RabbitMQ介绍 RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件）。RabbitMQ服务器是用Erlang语言编写的，而集群和故障转移是构建在开放电信平台框架上的。所有主要的编程语言均有与代理接口通讯的客户端库。 1、主要特性编辑 可伸缩性：集群服务 消息持久化：从内存持久化消息到硬盘，再从硬盘加载到内存 2、R...
rabbitmq集成spring boot
09-20
rabbitmq与Spring Boot的集成可以通过添加相应的依赖来实现。你需要在项目的pom.xml文件中添加以下依赖： ```xml <!-- rabbitmq --> <groupId>org.springframework.boot <artifactId>spring-boot-starter-amqp ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值