RabbitMQ自学笔记（高级理论暂未学习，以后补全）

最新推荐文章于 2024-07-25 20:57:40 发布
最新推荐文章于 2024-07-25 20:57:40 发布
阅读量82 收藏
点赞数 1
分类专栏： 笔记 文章标签： rabbitmq 学习 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59563359/article/details/128982630
版权

RabbitMQ

MQ基本概念

概念

  • MQ全称Message Queue（消息队列），是在消息的传输过程中保存消息的容器。多用于分布式系统之间进行通信

  • 分布式系统通信方法两种：直接远程调用和借助第三方完成间接调用

  • 由A系统传输消息到B系统通信，A系统为生产者，B系统为消费者，作为经过的第三方MQ则为中间件

优势与劣势

  • 优势：

    • 应用解耦：提升容错性和可维护性

    • 异步提速：提升用户体验和系统吞吐量（单位时间内处理请求的数目）

    • 削峰填谷：提高系统稳定性

  • 劣势：

    • 系统可用性降低：系统引入的外部依赖越多，系统稳定性越差

    • 系统复杂度提高：暂时无法保证消息是否被重复消费，如何处理消息丢失情况，是否保证消息传递的顺序性

    • 一致性问题：由MQ发消息数据给其他系统，如果其中存在一个系统处理失败，则暂时无法保证消息数据处理的一致性

常见的MQ产品

  • RabbitMQ

  • RocketMQ

  • ActiveMQ

  • Kafka

  • ZeroMQ

  • MetaMq

  • Redis充当消息队列

RabbitMQ简介

  • AMQP，全称Advanced Message Queuing Protocol（高级消息队列协议），是一个网络协议，是应用层协议的一个开发标准，为面向消息的中间件设计，类比HTTP

  • RabbitMQ是基于AMQP协议使用Erlang语言开发的一款消息队列产品

RabbitMQ基础架构

  • Broker：接收和分发消息的应用，RabbitMQ server就是message Broker

  • Virtual Host：出于多租户和安全因素设计的，把AMQP的基本组件划分到一个虚拟的分组中，类似于网络中的namespace概念，当多个不同的用户使用同一个RabbitMQ server提供的服务时，可以划分出多个vhost，每个用户在自己的vhost创建exchange/queue等

  • Connection：生产者/消费者和broker之间的TCP连接

  • Channel：如果每一次访问RabbitMQ都建立一个connection，在消息量大时开销大，效率低，channel是在connection内部建立的逻辑连接，如果应用程序支持多线程，通常每个thread创建单独的channel进行通讯，AMQP method包含了channel id帮助客户端和message broker识别channel，所以channel之间是完全隔离的，Channel作为轻量级的Connection极大减少了系统建立TCP connection的开销

  • Exchange：message到达broker的第一站，根据分发规则，匹配查询表中的routing key，分发消息到queue中去，常用的类型有：direct（point-to-point），topic（publish-subscribe），fanout（multicast）

  • Queue：消息最终被送到这里等待消费者取走

  • Binding：exchange和queue之间的虚拟连接，binding中可以包含routing key，Binding信息被保存到exchange中的查询表中，用于message的分发依据

RabbitMQ的六种工作模式

  • 简单模式

  • work queues

  • Publish/Subscribe发布与订阅模式

  • Routing路由模式

  • Topics主题模式

  • RPC远程调用模式（远程调用，不太算MQ）

JMS

  • JMS即Java消息服务（JavaMessage Service）应用程序接口，是一个Java平台中关于面向消息中间件的API

  • JMS是JavaEE规范中的一种，类比JDBC

  • RabbitMQ没有实现JMS规范，开源社区提供，ActiveMQ实现了JMS规范

RabbitMQ快速入门

简单模式完成消息队列

  • 创建工程（生产者，消费者）

    • Producer

    • Consumer

  • 添加依赖

    • <dependencies>
<dependency>
   <!--RabbitMQ java客户端-->
<groupId>com.rabbitmq</groupId>
   <artifactId>amqp-client</artifactId>
   <version>5.6.0</version>
 </dependency>
</dependencies>
<!--编译插件1.8版本-->
<build>
<plugins>
<plugin>
   <groupId>org.apache.maven.plugins</groupId>
     <artifactId>maven-compiler-plugin</artifactId>
     <version>3.8.0</version>
     <configuration>
     <source>1.8</source>
       <target>1.8</target>
     </configuration>
   </plugin>
 </plugins>
</build>

  • 编写生产者发送消息

    • // 1.创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
// 2.设置参数
factory.setHost("IP地址");//IP 默认值为 localhost
factory.setPort(5672);//端口 默认值为 5672
factory.setVirtualHost("/xiangxi");//虚拟机 默认值为 /
factory.setUsername("xiangxi");//用户名 默认值为 guest
factory.setPassword("123456");//密码 默认值为 guest
// 3.创建连接Connection
Connection connection = factory.newConnection();
// 4.创建Channel
Channel channel = connection.createChannel();
// 5.创建队列Queue(简单模式不需要交换机Exchange)
/*
queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
参数：
1. queue:队列名称
2. durable:是否持久化，当mq重启之后，还在
3. exclusive:
(1)是否独占，只能有一个消费者监听这队列
(2)当Connection关闭时，是否删除队列
4. autoDelete:是否自动删除，当没有消费者时，自动删除掉
5. arguments:参数信息
*/
//如果不存在名字叫做hello_world的队列，则会创建该队列
channel.queueDeclare("hello_world",true,false,false,null);
// 6.发送消息
/*
basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
参数：
1. exchange:交换机名称(简单模式下交换机会使用默认的""空字符串)
2. routingKey:路由名称
3. props:配置信息
4. body:发送消息数据
*/
String body = "hello rabbitmq";
channel.basicPublish("","hello_world",null,body.getBytes());
// 7.释放资源
channel.close();
connection.close();

  • 编写消费者接收消息

    • // 1.创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
// 2.设置参数
factory.setHost("IP地址");//IP 默认值为 localhost
factory.setPort(5672);//端口 默认值为 5672
factory.setVirtualHost("/xiangxi");//虚拟机 默认值为 /
factory.setUsername("xiangxi");//用户名 默认值为 guest
factory.setPassword("123456");//密码 默认值为 guest
// 3.创建连接Connection
Connection connection = factory.newConnection();
// 4.创建Channel
Channel channel = connection.createChannel();
// 5.创建队列Queue(简单模式不需要交换机Exchange)
/*
queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
参数：
1. queue:队列名称
2. durable:是否持久化，当mq重启之后，还在
3. exclusive:
(1)是否独占，只能有一个消费者监听这队列
(2)当Connection关闭时，是否删除队列
4. autoDelete:是否自动删除，当没有消费者时，自动删除掉
5. arguments:参数信息
*/
//如果不存在名字叫做hello_world的队列，则会创建该队列
channel.queueDeclare("hello_world",true,false,false,null);
// 6.接收消息
/*
basicConsume(String queue, boolean autoAck, Consumer callback)
参数：
1. queue,:队列名称
2. autoAck:是否自动确认(接收到消息自动给mq确认消息)
3. callback:回调对象
*/
Consumer consumer = new DefaultConsumer(channel){
 /*
回调方法，当收到消息后，会自动执行该方法
参数：
1. consumerTag:标识
2. envelope:获取一些信息(交换机，路由key...)
3. properties:配置信息
4. body:数据
 */
 @Override
 public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException{
   System.out.println("consumerTag:" + consumerTag);
   System.out.println("Exchange:" + envelope.getExchange());
   System.out.println("RoutingKey:" + envelope.getRoutingKey());
   System.out.println("properties" + properties);
   System.out.println("body" + new String(body));
}
}
channel.basicConsume("hello_world",true,consumer);

RabbitMQ工作模式

简单模式/经典模式

  • 一个生产者对应一个消费者

Work Queues 工作队列模式

  • 一个生产者对应多个消费者，消费者之间对于同一个消息的关系是竞争关系

  • Work Queues对于任务过重或任务较多情况使用工作队列可以提高任务处理速度，例如：短信服务部署多个，只需要有一个节点成功发送即可

Pub/Sub 订阅模式

  • Exchange：交换机（X），一方面，接收生产者发送的消息，另一方面，知道如何处理消息，交换机只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与交换机绑定，或者没有符合路由规则的队列，消息则会丢失

  • Exchange常见三种类型：

    • Fanout：广播，将消息交给所有绑定到交换机的队列

    • Direct：定向，将消息交给符合制定routing key的队列

    • Topic：通配符，将消息交给符合routing pattern（路由模式）的队列

订阅模式生产者代码

// 1.创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
// 2.设置参数
factory.setHost("IP地址");//IP 默认值为 localhost
factory.setPort(5672);//端口 默认值为 5672
factory.setVirtualHost("/xiangxi");//虚拟机 默认值为 /
factory.setUsername("xiangxi");//用户名 默认值为 guest
factory.setPassword("123456");//密码 默认值为 guest
// 3.创建连接Connection
Connection connection = factory.newConnection();
// 4.创建Channel
Channel channel = connection.createChannel();
// 5.创建交换机Exchange
/*
exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, boolean internal, Map<String, Object> arguments)
参数：
1. exchange:交换机名称
2. type:交换机类型(枚举)
DIRECT("direct"):定向
FANOUT("fanout"):扇形(广播)
TOPIC("topic"):通配符
HEADERS("headers"):参数匹配
   3. durable:是否持久化
   4. autoDelete:是否自动删除
   5. internal:内部使用
   6. arguments:参数信息
*/
channel.exchangeDeclare("test_fanout",BuiltinExchangeType.FANOUT,true,false,false,null);
// 6.创建队列Queue
/*
queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
参数：
1. queue:队列名称
2. durable:是否持久化，当mq重启之后，还在
3. exclusive:
(1)是否独占，只能有一个消费者监听这队列
(2)当Connection关闭时，是否删除队列
4. autoDelete:是否自动删除，当没有消费者时，自动删除掉
5. arguments:参数信息
*/
channel.queueDeclare("test_fanout_queue1",true,false,false,null);
channel.queueDeclare("test_fanout_queue2",true,false,false,null);
// 7.绑定交换机和队列
/*
queueBind(String queue, String exchange, String routingKey)
参数：
1. queue:队列名称
2. exchange:交换机名称
3. routingKey:路由key，绑定规则(使用fanout类型默认路由key为""空字符串)
*/
channel.queueBind("test_fanout_queue1","test_fanout","");
channel.queueBind("test_fanout_queue2","test_fanout","");
// 8.发送消息
/*
basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
参数：
1. exchange:交换机名称
2. routingKey:路由名称
3. props:配置信息
4. body:发送消息数据
*/
String body = "hello rabbitmq";
channel.basicPublish("test_fanout","",null,body.getBytes());
// 9.释放资源
channel.close();
connection.close();

订阅模式消费者代码

test_fanout_queue1消费者

// 1.创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
// 2.设置参数
factory.setHost("IP地址");//IP 默认值为 localhost
factory.setPort(5672);//端口 默认值为 5672
factory.setVirtualHost("/xiangxi");//虚拟机 默认值为 /
factory.setUsername("xiangxi");//用户名 默认值为 guest
factory.setPassword("123456");//密码 默认值为 guest
// 3.创建连接Connection
Connection connection = factory.newConnection();
// 4.创建Channel
Channel channel = connection.createChannel();
// 5.接收消息
/*
basicConsume(String queue, boolean autoAck, Consumer callback)
参数：
1. queue,:队列名称
2. autoAck:是否自动确认(接收到消息自动给mq确认消息)
3. callback:回调对象
*/
Consumer consumer = new DefaultConsumer(channel){
 /*
回调方法，当收到消息后，会自动执行该方法
参数：
1. consumerTag:标识
2. envelope:获取一些信息(交换机，路由key...)
3. properties:配置信息
4. body:数据
 */
 @Override
 public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException{
   System.out.println("consumerTag:" + consumerTag);
   System.out.println("Exchange:" + envelope.getExchange());
   System.out.println("RoutingKey:" + envelope.getRoutingKey());
   System.out.println("properties" + properties);
   System.out.println("body" + new String(body));
}
}
channel.basicConsume("test_fanout_queue1",true,consumer);

test_fanout_queue2消费者

// 1.创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
// 2.设置参数
factory.setHost("IP地址");//IP 默认值为 localhost
factory.setPort(5672);//端口 默认值为 5672
factory.setVirtualHost("/xiangxi");//虚拟机 默认值为 /
factory.setUsername("xiangxi");//用户名 默认值为 guest
factory.setPassword("123456");//密码 默认值为 guest
// 3.创建连接Connection
Connection connection = factory.newConnection();
// 4.创建Channel
Channel channel = connection.createChannel();
// 5.接收消息
/*
basicConsume(String queue, boolean autoAck, Consumer callback)
参数：
1. queue,:队列名称
2. autoAck:是否自动确认(接收到消息自动给mq确认消息)
3. callback:回调对象
*/
Consumer consumer = new DefaultConsumer(channel){
 /*
回调方法，当收到消息后，会自动执行该方法
参数：
1. consumerTag:标识
2. envelope:获取一些信息(交换机，路由key...)
3. properties:配置信息
4. body:数据
 */
 @Override
 public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException{
   System.out.println("consumerTag:" + consumerTag);
   System.out.println("Exchange:" + envelope.getExchange());
   System.out.println("RoutingKey:" + envelope.getRoutingKey());
   System.out.println("properties" + properties);
   System.out.println("body" + new String(body));
}
}
channel.basicConsume("test_fanout_queue2",true,consumer);

Routing 路由模式

  • 队列与交换机的绑定要制定一个RoutingKey（路由Key）

  • 消息的发送方在向交换机发送消息时，也必须指定消息的RoutingKey

  • 交换机不再把消息交给每一个绑定的队列，而是根据消息的RoutingKey进行判断，只有队列的RoutingKey与消息的RoutingKey完全一致，才会接收到消息

路由模式生产者代码

// 1.创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
// 2.设置参数
factory.setHost("IP地址");//IP 默认值为 localhost
factory.setPort(5672);//端口 默认值为 5672
factory.setVirtualHost("/xiangxi");//虚拟机 默认值为 /
factory.setUsername("xiangxi");//用户名 默认值为 guest
factory.setPassword("123456");//密码 默认值为 guest
// 3.创建连接Connection
Connection connection = factory.newConnection();
// 4.创建Channel
Channel channel = connection.createChannel();
// 5.创建交换机Exchange
/*
exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, boolean internal, Map<String, Object> arguments)
参数：
1. exchange:交换机名称
2. type:交换机类型(枚举)
DIRECT("direct"):定向
FANOUT("fanout"):扇形(广播)
TOPIC("topic"):通配符
HEADERS("headers"):参数匹配
   3. durable:是否持久化
   4. autoDelete:是否自动删除
   5. internal:内部使用
   6. arguments:参数信息
*/
channel.exchangeDeclare("test_direct",BuiltinExchangeType.DIRECT,true,false,false,null);
// 6.创建队列Queue
/*
queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
参数：
1. queue:队列名称
2. durable:是否持久化，当mq重启之后，还在
3. exclusive:
(1)是否独占，只能有一个消费者监听这队列
(2)当Connection关闭时，是否删除队列
4. autoDelete:是否自动删除，当没有消费者时，自动删除掉
5. arguments:参数信息
*/
channel.queueDeclare("test_direct_queue1",true,false,false,null);
channel.queueDeclare("test_direct_queue2",true,false,false,null);
// 7.绑定交换机和队列
/*
queueBind(String queue, String exchange, String routingKey)
参数：
1. queue:队列名称
2. exchange:交换机名称
3. routingKey:路由key，绑定规则(使用fanout类型默认路由key为""空字符串)
*/
//test_direct_queue1的绑定 error
channel.queueBind("test_direct_queue1","test_direct","error");
//test_direct_queue2的绑定 error info warning
channel.queueBind("test_direct_queue2","test_direct","info");
channel.queueBind("test_direct_queue2","test_direct","error");
channel.queueBind("test_direct_queue2","test_direct","warning");
// 8.发送消息
/*
basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
参数：
1. exchange:交换机名称
2. routingKey:路由名称
3. props:配置信息
4. body:发送消息数据
*/
String body = "hello rabbitmq";
channel.basicPublish("test_direct","",null,body.getBytes());
// 9.释放资源
channel.close();
connection.close();

路由模式消费者代码

test_direct_queue1消费者

// 1.创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
// 2.设置参数
factory.setHost("IP地址");//IP 默认值为 localhost
factory.setPort(5672);//端口 默认值为 5672
factory.setVirtualHost("/xiangxi");//虚拟机 默认值为 /
factory.setUsername("xiangxi");//用户名 默认值为 guest
factory.setPassword("123456");//密码 默认值为 guest
// 3.创建连接Connection
Connection connection = factory.newConnection();
// 4.创建Channel
Channel channel = connection.createChannel();
// 5.接收消息
/*
basicConsume(String queue, boolean autoAck, Consumer callback)
参数：
1. queue,:队列名称
2. autoAck:是否自动确认(接收到消息自动给mq确认消息)
3. callback:回调对象
*/
Consumer consumer = new DefaultConsumer(channel){
 /*
回调方法，当收到消息后，会自动执行该方法
参数：
1. consumerTag:标识
2. envelope:获取一些信息(交换机，路由key...)
3. properties:配置信息
4. body:数据
 */
 @Override
 public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException{
   System.out.println("consumerTag:" + consumerTag);
   System.out.println("Exchange:" + envelope.getExchange());
   System.out.println("RoutingKey:" + envelope.getRoutingKey());
   System.out.println("properties" + properties);
   System.out.println("body" + new String(body));
}
}
channel.basicConsume("test_fanout_queue1",true,consumer);

test_direct_queue2消费者

// 1.创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
// 2.设置参数
factory.setHost("IP地址");		//IP 默认值为 localhost
factory.setPort(5672);			//端口 默认值为 5672
factory.setVirtualHost("/xiangxi");			//虚拟机 默认值为 /
factory.setUsername("xiangxi");			//用户名 默认值为 guest
factory.setPassword("123456");			//密码 默认值为 guest
// 3.创建连接Connection
Connection connection = factory.newConnection();
// 4.创建Channel
Channel channel = connection.createChannel();
// 5.接收消息
/*
	basicConsume(String queue, boolean autoAck, Consumer callback)
	参数：
		1. queue,:队列名称
		2. autoAck:是否自动确认(接收到消息自动给mq确认消息)
		3. callback:回调对象
*/
Consumer consumer = new DefaultConsumer(channel){
  /*
  	回调方法，当收到消息后，会自动执行该方法
  	参数：
  		1. consumerTag:标识
  		2. envelope:获取一些信息(交换机，路由key...)
  		3. properties:配置信息
  		4. body:数据
  */
  @Override
  public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException{
    System.out.println("consumerTag:" + consumerTag);
    System.out.println("Exchange:" + envelope.getExchange());
    System.out.println("RoutingKey:" + envelope.getRoutingKey());
    System.out.println("properties" + properties);
    System.out.println("body" + new String(body));
  }
}
channel.basicConsume("test_direct_queue2",true,consumer);

Topics 通配符模式

通配符模式生产者代码

// 1.创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
// 2.设置参数
factory.setHost("IP地址");		//IP 默认值为 localhost
factory.setPort(5672);			//端口 默认值为 5672
factory.setVirtualHost("/xiangxi");			//虚拟机 默认值为 /
factory.setUsername("xiangxi");			//用户名 默认值为 guest
factory.setPassword("123456");			//密码 默认值为 guest
// 3.创建连接Connection
Connection connection = factory.newConnection();
// 4.创建Channel
Channel channel = connection.createChannel();
// 5.创建交换机Exchange
/*
	exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, boolean internal, Map<String, Object> arguments)
	参数：
		1. exchange:交换机名称
		2. type:交换机类型(枚举)
				DIRECT("direct"):定向
				FANOUT("fanout"):扇形(广播)
				TOPIC("topic"):通配符
				HEADERS("headers"):参数匹配
    3. durable:是否持久化
    4. autoDelete:是否自动删除
    5. internal:内部使用
    6. arguments:参数信息
*/
channel.exchangeDeclare("test_topic",BuiltinExchangeType.TOPIC,true,false,false,null);
// 6.创建队列Queue
/*
	queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
	参数：
		1. queue:队列名称
		2. durable:是否持久化，当mq重启之后，还在
		3. exclusive:
			(1)是否独占，只能有一个消费者监听这队列
			(2)当Connection关闭时，是否删除队列
		4. autoDelete:是否自动删除，当没有消费者时，自动删除掉
		5. arguments:参数信息
*/
channel.queueDeclare("test_topic_queue1",true,false,false,null);
channel.queueDeclare("test_topic_queue2",true,false,false,null);
// 7.绑定交换机和队列
/*
	queueBind(String queue, String exchange, String routingKey)
	参数：
		1. queue:队列名称
		2. exchange:交换机名称
		3. routingKey:路由key，绑定规则
				routingKey 系统名称.日志级别
					* 对应一个单词 # 对应零-多个单词
*/
//test_topic_queue1的绑定 #.error 任何一个的error级别信息
channel.queueBind("test_topic_queue1","test_topic","#.error");
//test_topic_queue1的绑定 order.* order下的所有级别信息
channel.queueBind("test_topic_queue1","test_topic","order.*");
//test_topic_queue2的绑定 *.* 所有级别的信息
channel.queueBind("test_topic_queue2","test_topic","*.*");
// 8.发送消息
/*
	basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
	参数：
		1. exchange:交换机名称
		2. routingKey:路由名称
		3. props:配置信息
		4. body:发送消息数据
*/
String body = "hello rabbitmq";
channel.basicPublish("test_topic","order.info",null,body.getBytes());
// 9.释放资源
channel.close();
connection.close();

通配符模式消费者代码

test_topic_queue1消费者

// 1.创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
// 2.设置参数
factory.setHost("IP地址");		//IP 默认值为 localhost
factory.setPort(5672);			//端口 默认值为 5672
factory.setVirtualHost("/xiangxi");			//虚拟机 默认值为 /
factory.setUsername("xiangxi");			//用户名 默认值为 guest
factory.setPassword("123456");			//密码 默认值为 guest
// 3.创建连接Connection
Connection connection = factory.newConnection();
// 4.创建Channel
Channel channel = connection.createChannel();
// 5.接收消息
/*
	basicConsume(String queue, boolean autoAck, Consumer callback)
	参数：
		1. queue,:队列名称
		2. autoAck:是否自动确认(接收到消息自动给mq确认消息)
		3. callback:回调对象
*/
Consumer consumer = new DefaultConsumer(channel){
  /*
  	回调方法，当收到消息后，会自动执行该方法
  	参数：
  		1. consumerTag:标识
  		2. envelope:获取一些信息(交换机，路由key...)
  		3. properties:配置信息
  		4. body:数据
  */
  @Override
  public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException{
    System.out.println("consumerTag:" + consumerTag);
    System.out.println("Exchange:" + envelope.getExchange());
    System.out.println("RoutingKey:" + envelope.getRoutingKey());
    System.out.println("properties" + properties);
    System.out.println("body" + new String(body));
  }
}
channel.basicConsume("test_topic_queue1",true,consumer);

test_topic_queue2消费者

// 1.创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
// 2.设置参数
factory.setHost("IP地址");		//IP 默认值为 localhost
factory.setPort(5672);			//端口 默认值为 5672
factory.setVirtualHost("/xiangxi");			//虚拟机 默认值为 /
factory.setUsername("xiangxi");			//用户名 默认值为 guest
factory.setPassword("123456");			//密码 默认值为 guest
// 3.创建连接Connection
Connection connection = factory.newConnection();
// 4.创建Channel
Channel channel = connection.createChannel();
// 5.接收消息
/*
	basicConsume(String queue, boolean autoAck, Consumer callback)
	参数：
		1. queue,:队列名称
		2. autoAck:是否自动确认(接收到消息自动给mq确认消息)
		3. callback:回调对象
*/
Consumer consumer = new DefaultConsumer(channel){
  /*
  	回调方法，当收到消息后，会自动执行该方法
  	参数：
  		1. consumerTag:标识
  		2. envelope:获取一些信息(交换机，路由key...)
  		3. properties:配置信息
  		4. body:数据
  */
  @Override
  public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException{
    System.out.println("consumerTag:" + consumerTag);
    System.out.println("Exchange:" + envelope.getExchange());
    System.out.println("RoutingKey:" + envelope.getRoutingKey());
    System.out.println("properties" + properties);
    System.out.println("body" + new String(body));
  }
}
channel.basicConsume("test_topic_queue2",true,consumer);

SpringBoot整合RabbitMQ

生产者

  • 创建生产者SpringBoot工程

  • 引入依赖坐标

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

  • 编写yml配置，基本信息配置

    # 配置RabbitMQ的基本信息
spring:
  rabbitmq:
    host: 172.16.98.133 #ip
    port: 5672  #端口
    username: guest	
    password: guest
    virtual-host: /

  • 定义交换机，队列以及绑定关系的配置类

    @Configuration
public class RabbitMQConfig {

  public static final String EXCHANGE_NAME = "boot_topic_exchange";
  public static final String QUEUE_NAME = "boot_queue";

  // 1.Exchange 交换机
  @Bean("getExchange")
  public Exchange getExchange() {
    return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
  }

  // 2.Queue 队列
  @Bean("getQueue")
  public Queue getQueue() {
    return QueueBuilder.durable(QUEUE_NAME).build();
  }

  // 3.Binding 交换机和队列的绑定关系
  @Bean
  public Binding bindQueueExchange(@Qualifier("getQueue") Queue queue, @Qualifier("getExchange") Exchange exchange) {
    return BindingBuilder.bind(queue).to(exchange).with("boot.#").noargs();
  }
}

  • 注入RabbitTemplate，调用方法，完成消息发送

//ProducerTest生产者测试类
//@RunWith是一个运行器，指定测试环境来运行
@SpringBootTest
@RunWith(SpringRunner.class)
public class ProducerTest {
    // 1.注入RabbitTemplate
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSend(){
        rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGE_NAME,"boot.heihei","hello springboot");
    }
}

消费者

  • 创建消费者SpringBoot工程

  • 引入依赖坐标

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

  • 编写yml配置，基本信息配置

    # 配置RabbitMQ的基本信息
spring:
  rabbitmq:
    host: 172.16.98.133 #ip
    port: 5672  #端口
    username: guest	
    password: guest
    virtual-host: /

  • 定义监听类，使用@RabbitListener注解完成队列监听

    @Component
public class RabbitMQListener {

  @RabbitListener(queues = "boot_queue")
  public void ListenerQueue(Message message) {
    //System.out.println(message);
    System.out.println(message.getBody());
  }
}

XiangXi响希
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
经验分享 | 我的八股文学习路线及攻略
a6636656的博客
05-09 4445
前几天拿到字节offer了，很开心，也有很多小伙伴私信我问了很多问题，所以在这里简单分享一下我是如何学习八股文的，文章篇幅略长，希望能帮助到有需要的同学或者也是双非大三正在迷茫的你。 【知识库分享】 很多小伙伴看了文章找我要知识库，我的建议是应该参考我的方法而不是内容。我的知识库整理好了，想看整理好的可以私信我“资料”获取 这是我的面经，整理的很详细字节后端暑期实习 一二三面（已OC｜新鲜面经） 学习要点 1. 要明白的一些事情 什么是八股文？八股文不是死东西，八股文本应该指计算机基础知识，考
IDEA学习篇——IntelliJ Idea 常用快捷键总结，rabbitmq与kafka面试
2401_83973995的博客
03-30 816
JVM，JAVA集合，JAVA多线程并发，JAVA基础，Spring原理，微服务，Netty与RPC，网络，日志，Zookeeper，Kafka，RabbitMQ，Hbase，MongoDB，Cassandra，设计模式，负载均衡，数据库，一致性哈希，JAVA算法，数据结构，加密算法，分布式缓存，Hadoop，Spark，Storm，YARN，机器学习，云计算…JVM，JAVA集合，JAVA多线程并发，JAVA基础，Spring原理，微服务，Netty与RPC。
SpringCloud学习笔记
hanpiyo的博客
03-15 630
SpringCloud Ribbon 底层采用了一个拦截器，拦截了 RestTemplate 发出的请求，对地址做了修改。拦截我们的请求 http://userservice/user/1会从请求url中获取服务名称，也就是 user-service根据 user-service 到 eureka 拉取服务列表eureka 返回列表，localhost:8081、localhost:8082IRule利用内置负载均衡规则，从列表中选择一个，例如 localhost:8081。
8. SpringBoot基础学习笔记
有多勉为其难的博客
06-14 2011
SpringBoot技术由Pivotal团队研发制作，功能的话简单概括就是加速Spring程序的开发，这个加速要从如下两个方面来说:1.Spring程序初始搭建过程2.Spring程序的开发过程
机器学习基础环境安装与使用
2401_84048895的博客
04-22 354
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
2024年阿里+腾讯+快手offer都已拿到，Java虚拟机学习集锦是我攒来的
2401_84408291的博客
04-20 914
在开头跟大家分享的时候我就说，面试我是没有做好准备的，全靠平时的积累，确实有点临时抱佛脚了，以至于我自己还是挺懊恼的。（准备好了或许可以拿个40k，没做准备只有30k+，你们懂那种感觉吗）如何准备面试？1、前期铺垫（技术沉积）程序员面试其实是对于技术的一次摸底考试，你的技术牛逼，那你就是大爷。大厂对于技术的要求主要体现在：基础，原理，深入研究源码，广度，实战五个方面，也只有将原理理论结合实战才能把技术点吃透。
服务器后端开发技术完整学习路线，23张思维导图，自学也能进大厂！
程序员柠檬
11-27 9284
大家好，我是柠檬。 柠檬哥作为一个普通大学、非计算机专业，自学后端技术进入腾讯做后端开发工作，我自己也是非科班自学计算机成功转行软件开发（有想听柠檬哥转行之路经历的吗，可以留言告诉我，人多就写写），体会过当初想学又不知从何学起的迷茫，还好最后摸索出了一条正确学习的路线。 思来想去，学习方向和路线很重要。比起具体的技术细节，可复制的经验、清晰的学习路线，是大部分人更加需要的东西。 朝着正确的方向努力否则只会离目标越来越远，不是吗？ 只顾着写各种技术，不告诉大家这个知识点在后端技术图谱的什么位置，有点盲人摸象不
黑马2021最新版 SpringCloud基础篇全技术栈导学（RabbitMQ+Docker+Redis+搜索+分布式）
m0_67402026的博客
07-30 1511
也是使用的Ribbon，下面一个例子将Nacos配置成同集群优先的负载均衡策略默认的并不能实现根据同集群优先来实现负载均衡。Nacos中提供了一个NacosRule的实现，可以优先从同集群中挑选实例。1）给order-service配置集群信息springcloudnacoslocalhost8848discoveryHZ#集群名称2）修改负载均衡规则ribboncom.alibaba.cloud.nacos.ribbon.NacosRule#负载均衡规则。...
java学习路线
w18377940962的博客
02-08 6355
Java 学习路线 Java 学习路线一条龙版 by 程序员鱼皮 ???? + ???? = ???????? 建议先观看视频导读：https://www.bilibili.com/video/BV1Qf4y1K7ff/ 大纲 路线特点 最新，完整一条龙的大厂 Java 学习路线，从入门到入土 同时适用于想全面学习 / 快速求职的同学，可以根据符号来定制自己的专属学习路线 给出目标、学习建议、关键知识点、最优资源以及各类资源推荐（视频、书籍、文档、项目、工具等） 鱼皮自己是 Java 开发者，融入个
rabbitmq学习笔记和软件和插件
05-05
**RabbitMQ学习笔记与软件插件详解** RabbitMQ是一种广泛应用的消息中间件，它基于AMQP（Advanced Message Queuing Protocol）协议，提供可靠的消息传递服务。在分布式系统中，RabbitMQ扮演着数据交换中心的角色，...
rabbitMQ学习笔记
11-06
rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ学习笔记rabbitMQ...
rabbitmq学习笔记.zip
10-16
RabbitMQ是一个开源的消息...总的来说，这个“rabbitmq学习笔记.zip”文件应该为初学者提供了一个全面了解和掌握RabbitMQ的资源，从基础概念到实践操作，再到高级特性和最佳实践，帮助读者建立起对RabbitMQ的深入理解。
RabbitMQ学习笔记
06-22
**RabbitMQ学习笔记** RabbitMQ是一款广泛应用的消息中间件，它基于AMQP（Advanced Message Queuing Protocol）协议，能够实现在分布式系统中可靠的消息传递。RabbitMQ的核心功能是作为一个消息代理，允许应用程序...
RabbitMQ自学笔记
07-23
### RabbitMQ自学笔记知识点梳理 #### 一、RabbitMQ简介与安装 ##### 1.1 RabbitMQ概述 - **定义**: RabbitMQ是一款开源的消息中间件软件，基于AMQP（Advanced Message Queuing Protocol）协议实现。 - **特点**: ...
【高级应用篇】深入Spring Boot与RabbitMQ：构建可靠的微服务通信
weixin_68020300的博客
07-24 2041
在微服务架构中，消息队列作为异步通信与服务解耦的关键组件，发挥着不可替代的作用。本文详尽探索RabbitMQ的高级特性，包括消息确认、持久化、优先级、死信队列、TTL以及发布确认机制，展示如何利用这些特性增强Spring Boot应用与RabbitMQ的集成，实现更高效、更稳健的微服务通信。通过讲解高级消息模式如发布/订阅、路由与主题，以及性能调优、安全性和常见问题的解决方案，本文旨在为开发者提供全面的指南，帮助他们掌握RabbitMQ在实际项目中的高级应用技巧。
Python每日学习
q2903160397的博客
07-21 2253
我是从c++转来学习Python的，总感觉和c++相比Python的实操简单，但是由于写c++的代码多了，感觉Python的语法好奇怪。由于今天是我正式学Python的第一天，干货不多，以后让我们一步一步来见证Python这个优雅的代码的学习之路吧！），这种格式对于我来说已成习惯了，而这一切Python这个优雅的语言通通没有，学习Python这将是道阻且长。今天就简单了解了一下Python的起源和成长并学习了打印 halloworld，算是开始学习了吧。）而且它每一项的代码结束之后要有一个表示结束的封号（
爬虫学习4：爬取王者荣耀技能信息
mohanyelong的博客
07-22 2544
爬取王者荣耀技能信息（代码和代码流程）。
Django学习（二）
最新发布
weixin_67852201的博客
07-25 759
当我门直接访问时会出触发django的csrf检测。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

XiangXi响希

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

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

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

打赏作者

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

抵扣说明：

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

余额充值