RabbitMQ

最新推荐文章于 2023-08-11 14:48:43 发布
最新推荐文章于 2023-08-11 14:48:43 发布
阅读量656 收藏
点赞数
文章标签： java-rabbitmq rabbitmq 中间件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42377720/article/details/127065953
版权

基础RabbitMQ消息队列（消息中间件）

MQ基本概念

  1. MQ为消息队列，存储消息的中间件
  2. 分布式系统通信的两种方式：（1）直接远程调用。（2）借助第三方 完成通信
  3. 发送方-----消息中间件---->接收方

MQ的优势

1. 应用解耦

在新增额外系统、删除系统、子系统发生错误，都不会影响订单系统，只需要对MQ发送消息即可实现
在这里插入图片描述

在这里插入图片描述

2. 异步提速

在订单系统和数据库系统之间添加消息MQ，订单系统从MQ中获取数据，子系统将数据可以提前提交至MQ中。
在这里插入图片描述
在这里插入图片描述

3. 削峰填谷

  1. 瞬时消息请求在增多，承受不住请求的压力

  1. 引入消息队列MQ，将请求挂靠在MQ中，让MQ承担请求的压力

在这里插入图片描述
在这里插入图片描述

总结

  • 应用解耦：提高了系统的容错性和可维护性
  • 异步提速：提升了系统的吞吐量和用户体验度
  • 削峰填谷：提升了系统的稳定性

MQ的劣势

1. 系统可用性降低

添加了MQ之后，增加了系统的组件，增加了系统出错的概率：MQ宕机了，系统也会受影响
在这里插入图片描述

2. 系统复杂性提高

MQ 的加入大大增加了系统的复杂度，以前系统间是同步的远程调用，现在是通过 MQ 进行异步调用。如何保证消息没有被重复消费？怎么处理消息丢失情况？那么保证消息传递的顺序性？

3. 一致性问题

A 系统处理完业务，通过 MQ 给B、C、D三个系统发消息数据，如果 B 系统、C 系统处理成功，D 系统处理
失败。如何保证消息数据处理的一致性？

总结

  • 生产者不需要从消费者处获取反馈，则可以用MQ
  • 解耦、提速、削峰的收益，超过维护MQ的成本，可以使用。

常见MQ产品

目前业界有很多的 MQ 产品，例如 RabbitMQ、RocketMQ、ActiveMQ、Kafka、ZeroMQ、MetaMq等，也有直接使用 Redis 充当消息队列的案例，而这些消息队列产品，各有侧重，在实际选型时，需要结合自身需求及 MQ 产品特征，综合考虑。
在这里插入图片描述

RabbitMQ简介

  • RabbitMQ是基于AMQP协议使用的Erlang语言开发的消息队列产品。
  • AMQP（高级消息队列协议）类比HTTP。
连接
连接
生产者
中介
消费者

Connection：生产者/消费者与broker之间的TCP连接;
broker：接收和分发消息的中介，就是消息服务器;
Virtual host：每一个用户有一个host，类似私人账户一样;
channel：每个channel之间相互隔离，可以减少TCP connection的开销;
exchange：根据分发规则，将message分发到不同的queue中；
Queue：装在message，被消费者取走；
Binding：exchange和queue之间的虚拟连接。
在这里插入图片描述

RabbitMQ六种工作模式

1. 简单模式 “Hello World”

RabbitMQ 是一个消息代理: 它接受和转发消息。你可以把它想象成一个邮局: 当你把你想要投递的邮件放在一个邮箱里时，你可以确定信件的承运人最终会把邮件投递给你的收件人。在这个类比中，RabbitMQ 是一个邮箱、一个邮局和一个信件载体。
在这里插入图片描述
P是一个生产者，红色部分是一个消息缓存队列，C是消费者

Producer

public class Producer{
  private final static String QUEUE_NAME = "hello";
  public static void main(String[] argv) throws Exception {
  		//1. 创建连接工厂
  		ConnectionFactory factory = new ConnectionFactory();
  		//2. 设置参数
		factory.setHost("localhost"); 	//设置主机ip

		//3. 创建连接
		Connection connection = factory.newConnection();
		//4. 创建Channel
		Channel channel = connection.createChannel()；
    	//5. 创建消息队列
    	/*
     		参数1： 队列名
     		参数2：durable，是否持久化
     		参数3：exclusive，是否独占，只能有一个消费者监听队列，一般为false
     		参数4：autodelete，是否自动删除队列，没有消费者时自动删除
     		参数5：参数
    	*/
    	channel.queueDeclare(QUEUE_NAME, false, false, false, null);
    	String message = "Hello World!";
    	//6. 发送消息
     	/*
			参数1： exchange，交换机，默认为“”
			参数2：routingkey，路由名，简单模式下，交换机与路由名相互绑定，为队列名称QUEUE_NAME
			参数3：props，配置信息
			参数4：body，message 消息内容，字节信息
		*/
    	channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
    	System.out.println(" [x] Sent '" + message + "'");
    	
    	//7. 关闭资源，可以选择性关闭
    	channel.close();
    	connection.close();
  }
}

consumer

public class Consumer{

  private final static String QUEUE_NAME = "hello";

 public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

        //接收消息
        /*
        	回调方法	，当收到消息之后，会自动执行
        	参数：
        		参数1：consumerTag，消息标识
        		参数2：envelope，交换机，routingkey名
        		参数3：properties，配置信息
        		参数4：message，消息数据
        */
        Consumer deliverCallbackConsumer = new DefaultConsumer(channel){
          	@override
        	public void handleDelivery(String consumerTag,Envelope envelope,AMQP.BasicProperties properties,byte[] message){
				System.out.println(“consumerTag：”+consumerTag);
				System.out.println(“exchange：”+envelope.getExchange());
				System.out.println(“rountingkey：”+envelope.getrountingkey());
				System.out.println(“properties：”+properties);
				System.out.println(“message：”+new String(message));
			}
        } 
        /*
			参数1： routingkey，路由名，简单模式下，交换机与路由名相互绑定，为队列名称QUEUE_NAME
			参数2：autoAck，自动确认
			参数3：callback，回调对象，deliverCallback
			参数4：body，message 消息内容，字节信息
		*/
        channel.basicConsume(QUEUE_NAME, true, deliverCallbackConsumer);
        
        //消费者不能关闭资源，因为需要不间断的监听消息队列
    }
}

2. work queues模式

工作队列(又名: 任务队列)背后的主要思想是避免立即执行资源密集型任务，并且不得不等待它完成。相反，我们将任务安排在以后完成。我们将任务封装为消息并将其发送到队列。在后台运行的辅助进程将弹出任务并最终执行作业。当您运行许多工作线程时，任务将在它们之间共享。

  • C1、C2是相互竞争资源的关系
  • 应用场景：适用任务过重过多情况，提升任务处理的速度
  • 同时启动多个consumer，然后启动producer，发送message，观察消息消费情况


Producer

public class Producer{
  private final static String QUEUE_NAME = "hello";
  public static void main(String[] argv) throws Exception {
  		//1. 创建连接工厂
  		ConnectionFactory factory = new ConnectionFactory();
  		//2. 设置参数
		factory.setHost("localhost"); 	//设置主机ip

		//3. 创建连接
		Connection connection = factory.newConnection();
		//4. 创建Channel
		Channel channel = connection.createChannel()；
    	//5. 创建消息队列
    	/*
     		参数1： 队列名
     		参数2：durable，是否持久化
     		参数3：exclusive，是否独占，只能有一个消费者监听队列，一般为false
     		参数4：autodelete，是否自动删除队列，没有消费者时自动删除
     		参数5：参数
    	*/
    	channel.queueDeclare(QUEUE_NAME, false, false, false, null);
    	//6. 发送10条消息
    	for( int i= 0 ; i< 10; i++){
    		String message = i + "Hello World!";
     		/*
				参数1： exchange，交换机，默认为“”
				参数2：routingkey，路由名，简单模式下，交换机与路由名相互绑定，为队列名称QUEUE_NAME
				参数3：props，配置信息
				参数4：body，message 消息内容，字节信息
			*/
    		channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
    	}
    	System.out.println(" [x] Sent '" + message + "'");
    	
    	//7. 关闭资源，可以选择性关闭
    	//channel.close();
    	//connection.close();
  }
}

consumer1

public class Consumer1{

  private final static String QUEUE_NAME = "hello";

 public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

        //接收消息
        /*
        	回调方法	，当收到消息之后，会自动执行
        	参数：
        		参数1：consumerTag，消息标识
        		参数2：envelope，交换机，routingkey名
        		参数3：properties，配置信息
        		参数4：message，消息数据
        */
        Consumer deliverCallbackConsumer = new DefaultConsumer(channel){
          	@override
        	public void handleDelivery(String consumerTag,Envelope envelope,AMQP.BasicProperties properties,byte[] message){
				System.out.println(“message：”+new String(message));
			}
        } 
        /*
			参数1： routingkey，路由名，简单模式下，交换机与路由名相互绑定，为队列名称QUEUE_NAME
			参数2：autoAck，自动确认
			参数3：callback，回调对象，deliverCallback
			参数4：body，message 消息内容，字节信息
		*/
        channel.basicConsume(QUEUE_NAME, true, deliverCallbackConsumer);
        
        //消费者不能关闭资源，因为需要不间断的监听消息队列
    }
}

consumer2

public class Consumer2{

  private final static String QUEUE_NAME = "hello";

 public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

        //接收消息
        /*
        	回调方法	，当收到消息之后，会自动执行
        	参数：
        		参数1：consumerTag，消息标识
        		参数2：envelope，交换机，routingkey名
        		参数3：properties，配置信息
        		参数4：message，消息数据
        */
        Consumer deliverCallbackConsumer = new DefaultConsumer(channel){
          	@override
        	public void handleDelivery(String consumerTag,Envelope envelope,AMQP.BasicProperties properties,byte[] message){
				System.out.println(“message：”+new String(message));
			}
        } 
        /*
			参数1： routingkey，路由名，简单模式下，交换机与路由名相互绑定，为队列名称QUEUE_NAME
			参数2：autoAck，自动确认
			参数3：callback，回调对象，deliverCallback
			参数4：body，message 消息内容，字节信息
		*/
        channel.basicConsume(QUEUE_NAME, true, deliverCallbackConsumer);
        
        //消费者不能关闭资源，因为需要不间断的监听消息队列
    }
}

================================================================================================

3. Publish/Subscribe模式

producer发送一条消息，两个消费者都可以收到
在这里插入图片描述

  • producer将消息发送给X(exchange)，不直接发送给队列。
  • X：交换机。转发消息，有三种处理方式：
    • Fanout：广播，将消息交给所有与其绑定的队列
    • Direct：定向，将消息交给指定的routingkey队列
    • Topic：通配符，将消息交给符合的routing pattern的队列
  • X，交换机，只负责消息的转发，不具备存储能力，如果没有队列接收，消息将被丢失。

Producer

public class Producer{
  
  public static void main(String[] argv) throws Exception {
  		//1. 创建连接工厂
  		ConnectionFactory factory = new ConnectionFactory();
  		//2. 设置参数
		factory.setHost("localhost"); 	//设置主机ip

		//3. 创建连接
		Connection connection = factory.newConnection();
		//4. 创建Channel
		Channel channel = connection.createChannel()；
		
    	//5. 创建交换机
    	String exchange_name = "exc_name"; 
    	/*
    		交换机参数列表：
    			参数1：交换机名称
    			参数2：交换机类型，四种
    			参数3：是否持久化
    			参数4：自动删除
    			参数5：内部使用
    			参数6：参数
    		*/
		channel.exchangeDeclare(exchange_name ,'fanout',true,false,false,null);
		
		//6. 创建队列
		private String queue_name1 = "hello1";
		private String queue_name2 = "hello2";
		channel.exchangeQueue(queue_name1 ,true,false,false,null);
		channel.exchangeQueue(queue_name2 ,true,false,false,null);
		
		//7. 绑定交换机与队列
		/*
			绑定参数列表：
				参数1：队列名
				参数2：交换机名
				参数3：routingkey，绑定规则，默认为fonout，“”
		*/
		channel.queueBind(queue_name1 ,exchange_name ,"");
		channel.queueBind(queue_name2 ,exchange_name ,"");

		//8. 发送消息
		String message = "publish/subscribe";
		channel.basicPublish(exchange_name,"",null,message.getBytes() )

		//9. 释放资源
		channel.close();
		channel.connection();
	}
}

consumer1

public class Consumer1{
 public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

        //接收消息
        Consumer deliverCallbackConsumer = new DefaultConsumer(channel){
          	@override
        	public void handleDelivery(String consumerTag,Envelope envelope,AMQP.BasicProperties properties,byte[] message){
				System.out.println(“message：”+new String(message));
			}
        } 
        //两个消费者，监听自己的队列，绑定对应的队列名
        channel.basicConsume(queue_name1, true, deliverCallbackConsumer);
        
        //消费者不能关闭资源，因为需要不间断的监听消息队列
    }
}

==============================================================================

4. Routing模式

  • 队列与路由指定routingkey绑定
  • producer向exchange转发消息的时候，也必须指定routingkey
  • exchange与消息队列不在固定绑定，而是根据消息的routingkey进行判断，队列的routingkey与消息的routingkey一致，才可以接收到消息。

在这里插入图片描述
Producer

public class Producer{
  
  public static void main(String[] argv) throws Exception {
  		//1. 创建连接工厂
  		ConnectionFactory factory = new ConnectionFactory();
  		//2. 设置参数
		factory.setHost("localhost"); 	//设置主机ip

		//3. 创建连接
		Connection connection = factory.newConnection();
		//4. 创建Channel
		Channel channel = connection.createChannel()；
		
    	//5. 创建交换机
    	String exchange_name = "exc_name"; 
		channel.exchangeDeclare(exchange_name ,BuiltinExchangeType.DIRECT,true,false,false,null);
		
		//6. 创建队列
		private String queue_name1 = "hello1";
		private String queue_name2 = "hello2";
		channel.exchangeQueue(queue_name1 ,true,false,false,null);
		channel.exchangeQueue(queue_name2 ,true,false,false,null);
		
		//7. 绑定交换机与队列
			//队列1绑定一个routingkey
		channel.queueBind(queue_name1 ,exchange_name ,"error");
			//队列2绑定三个routingkey
		channel.queueBind(queue_name2 ,exchange_name ,"info");
		channel.queueBind(queue_name2 ,exchange_name ,"error");
		channel.queueBind(queue_name2 ,exchange_name ,"warning");

		//8. 发送消息
		String message = "publish/subscribe";
			//发送一个routingkey=="info"的消息
		channel.basicPublish(exchange_name,"info",null,message.getBytes() )

		//9. 释放资源
		channel.close();
		channel.connection();
	}
}

consumer1
consumer与publish/subscribe一样。。。。。。

============================================================================

5. Topics通配符模式

与routing模式类似，将routingkey改进为通配符模式，通配符之间用“ . ”隔开

  • *，代表一个单词
  • #，代表多个单词

在这里插入图片描述

============================================================================

6. RPC远程调用模式（不介绍）

============================================================================

SpringBoot整合RabbitMQ

生产者

  • 创建生产者SpringBoot工程
  • 引入start，依赖坐标
<dependency> 	
	<groupId>org.springframework.boot</groupId>
   	<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
  • 编写yml配置，基本信息配置
# 配置ip，端口，username ，password
spring：
	rabbitmq：
		host: loscakhost
		port: 5672
		username: ....
		password: ****
		virtual-host: /
  • 定义交换机，队列以及绑定关系的配置类
@Configuration
public class RabbitMQConfig{

	public static final String EXCHANGE_NAME = "EXCHANGE_NAME";
	public static final String QUEUE_NAME = "QUEUE_NAME";
	//1. 创建交换机
	@Bean("createExchage")
	public Exchage createExchage(){
		return ExchageBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
	}

	//2. 创建队列
	@Bean("createQueue")
	public Queue createQueue(){
		return QueueBuilder..durable(QUEUE_NAME).build();
	}
	
	//3. 绑定队列和交换机
	@Bean
	public Binding bindQueueExchange(Queue queue,Exchage exchange){
		return BindingBuilder.bind(queue).to(exchange).with("*.*");
	}
}
  • 注入RabbitTemplate，调用方法，完成消息发送
@SpringBootTest
@RunWith(SpringRunner.class)
public class ProducerTest{

	//1. 注入RabbitTemplate 
	@AutoWired
	private RabbitTemplate rabbitTempate;
	
	@Test
	public void testSend(){
		//参数列表（exchange，routingkey，message）
		rabbitTempate.convertAndSend(RabbitMQConfig.EXCHANGE_NAME, "xxx.xxx", “hello world” );
	}
	
}

消费者

创建消费者SpringBoot工程
引入start，依赖坐标

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

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

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

@Component
public class RabbitMQListener{

	// @RabbitListener完成消息接收
	@RabbitListener(queue = QUEUE_NAME )
	public void listenerQueue(Message message){
		System.out.println(message.getBytes());
	}
}

============================================================================

快乐码代码
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringBoot+RabbitMQ之MQTT协议的生产和消费
Masli的博客
03-30 4388
一、xml文件: <!--mqtt依赖--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-integration</artifact...
rabbitMQ学习（七）反馈模式
weixin_30725315的博客
07-21 211
反馈模式 在消费端接收到消息后，会反馈给服务器信息。 连接代码： import java.io.IOException; import com.rabbitmq.client.Channel; import com.rabbitmq.client.Connection; import com.rabbitmq.client.ConnectionFactory; ...
RabbitMq学习笔记三、确认消费机制
promiseful的博客
05-26 370
一、目的 消息发送成功 ==》 Publisher 的Confirm 机制 消息不丢失 和 被确认消费 ==》 主要是面向消费者的确认消费而言的 1、是否发送成功 交换机、路由和队列绑定构成的模型不存在时 1）设置发送消息成功时反馈回信息 connectionFactory.setPublisherReturns(true)。 2） 设置消息发送确认机制 rabbitTempate.SetConfirmCallback() 2、RabbitMq 服务出现宕机 在创建队列、交换机时设..
jmail反馈是否发送成功_RabbitMQ - 发送方的可靠性
weixin_39972741的博客
11-22 73
在消费端，当确认或者拒绝了消息后，rabbitmq才会把消息从消息里删除掉，在发送端，会有以下问题：发送给不存在的交换器发送给路由不到的队列网络故障导致中途丢失事务确保消息不丢失的唯一方法是使用事务，将每个消息或一组消息发布、提交的信道设置为事务性的。在rabbitmq中，加事务也比较简单，就是调用txSelect()开启事务，调用txCommit()提交事务，调用txRollback()回滚事务...
RabbitMQ 消息确认机制
weixin_42523973的博客
04-13 158
RabbitMQ 消息确认机制 1. 概述 在Rabbitmq中我们可以通过持久化来解决因为服务器异常而导致丢失的问题,除此之外我们还会遇到一个问题:生产者将消息发送出去之后,消息到底有没有正确到达 Rabbit服务器我们是不知道的（即Rabbit服务器不会反馈任何消息给生产者）也就是默认的情况下是不知道消息有没有正确到达; 导致的问题:消息到达服务器之前丢失,那么持久化也不能解决此问题,因为消...
RabbitMQ Server3.13.0
最新发布
04-02
**RabbitMQ Server 3.13.0** RabbitMQ 是一个开源的消息代理和队列服务器，它基于AMQP（Advanced Message Queuing Protocol）协议，用于在分布式系统中高效地路由和传递消息。RabbitMQ 3.13.0 版本是其稳定版本之一...
rabbitmqadmin
07-08
RabbitMQ命令行手动创建队列rabbitmqadmin用法 手动创建队列方法：登录http://ip:15672/cli下载 将下载的rabbitmqadmin放到/usr/sbin目录下，并赋予权限：chmod 755 rabbitmqadmin 查看命令帮助信息： python ...
rabbitmq开发规范
07-04
**RabbitMQ开发规范详解** 在使用RabbitMQ进行分布式消息传输时，遵循一定的开发规范至关重要，这不仅可以提高系统的可维护性，也有助于保证数据的一致性和稳定性。本篇文章将详细阐述RabbitMQ的命名规范、消息传输...
rabbitmq3.10.4
06-07
RabbitMQ是一个开源的消息代理和队列服务器，广泛应用于分布式系统中的消息传递。它基于AMQP（Advanced Message Queuing Protocol）协议，为多种编程语言提供API，使得开发人员能够轻松地实现消息的发送和接收。在...
RabbitMQ学习笔记
Java+GO+JS全栈工程师-鹤冲天的博客：编程辅导~商务合作~技术交流
01-03 6391
消息队列是用来发送消息的消息中间件，本质上是队列，具有服务削峰、程序解耦、异步消息的功能。
详解RocketMQ消息查询机制
白话机器学习
08-11 2719
RocketMQ 在内存中还维护了一个索引文件列表，对于每一个索引文件，前一个文件的最大存储时间是下一个文件的最小存储时间，前一个文件的最大偏移量是下一个文件的最大偏移量。放入 29:取出哈希槽为 29 中的值 2，然后将 “29|2” 存储在第 3 个索引槽中，并更新哈希槽为 29 的值为 3，即哈希槽为 29 的第一个索引块的地址为 3。放入 16:取出哈希槽为 16 中的值 1，然后将 “16|1” 存储在第 5 个索引槽中，并更新哈希槽为 16 的值为 5。构成链表为: “[16]->5->1”
RocketMQ 1：生产者消息发送-单向发送、同步发送、异步发送
Fisher3652的博客
06-27 1064
目录1.创建一个空的maven工程，引入rocket依赖单向发送2.创建单向发送类OneWayProducer3.查看打印同步发送4.创建同步发送类SyncProducer5.查看打印，消息按顺序发送，Queue 是数据分片的产物，默认是4个，可以修改配置参数defaultTopicQueueNums异步发送6.创建异步发送类AsyncProducer，使用countDownLatch保证10条消息同时发送，并打印反馈结果7.查看打印，因为是异步发送，所以顺序每次都会不一样 1.创建一个空的maven工程
【kafka】---kafka的pull模型
寻梦友的博客
09-12 2909
一、pull和push模型 消费系统主要有两种模型推送或消费消息。 push：优势在于消息实时性高，劣势在于没考虑comsumer消费能力和饱和情况，容易导致producer压垮consumer。 消息中转代理将消息推送到消费者后，标记这条消息已经消费，但这种方式无法保证消息被消费处理。如果要保证消息被处理，消息代理发送完消息后标记“已发送”，再消费者确认消费了回复后变成“已消费”。这需要消费中转代理记录所有消息状态，显然很不切合实际。 pull：优势在于可以控制消费速度和消费数量，保证comsumer不会
java mq如何获取结果_深入研究RocketMQ消费者是如何获取消息的
weixin_32280985的博客
02-25 1231
前言小伙伴们，国庆都过的开心吗？国庆后的第一个工作日是不是很多小伙伴还沉浸在假期的心情中，没有工作状态呢？那王子今天和大家聊一聊RocketMQ的消费者是如何获取消息的，通过学习知识来找回状态吧。废话不多说，我们开始吧。消费者组首先我们了解一个概念，什么是消费者组。消费者组你就可以把它理解为，给一组消费者起一个名字。假设我们有一个订单Topic名字是OrderTopic，然后库存系统和积分系统都要...
java实现对activeMQ存取数据
崔崇东的博客
01-26 3276
列队模式的消息演示 完成的代码下载地址 http://download.csdn.net/download/weixin_39549656/10225164 工程目录结构 生产者AppProducer .java import javax.jms.Connection; import javax.jms.ConnectionFactory; import javax.jms.Dest
java mq如何获取结果,JAVA如何获取mq 发送的信息
weixin_31193137的博客
03-19 1708
JAVA如何获取mq 发送的信息获取信息时报错：MQJE001: 完成代码为“2”，原因为“2045”。A WebSphere MQ error occurred : Completion code 2 Reason code 2045下面是我的测试环境队列管理器和队列配置通道配置代码：/*** 从队列中去获取消息，如果队列中没有消息，就会发生异常，不过没有关系，有TRY...CATCH，如果是第...
MQ消息队列
iteye_14356的博客
04-29 732
AMQP协议介绍 AMQP，即Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。 AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全。 AMQP在消息提供者和客户端的行为进行了强制规定，使得不同卖商之间真正实现了互操作能力。 JMS是早期消息中间件进行标准化的一个尝...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值