4.RabbitMQ使用规范&整合spring

最新推荐文章于 2025-06-19 22:14:44 发布
最新推荐文章于 2025-06-19 22:14:44 发布
阅读量5.7k 收藏 4
点赞数 2
CC 4.0 BY-SA版权
分类专栏： RabbitMQ 文章标签： rabbit rabbitmq mq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/CS568591377/article/details/54945186
本文介绍了RabbitMQ的使用规范，包括特性规范如连接重连、队列持久化等，命名规范如队列和路由的命名方式，以及如何整合Spring进行消息队列操作。同时，提供了整合Spring的步骤，包括项目结构、配置文件和示例代码。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

特性规范 

  1. spring（建议4.2以上，mq支持注解）+RabbitMQ1.6.6
  2. 默认配置的连接是5个，当rabbit服务器重启后，会自动重连
  3. 所有队列、路由默认是持久化的，当rabbit服务器重启后，会自动恢复创建
  4. 优先级队列级别设置建议为10（权重越大表示优先执行）
  5. 延迟队列延迟时间最大建议设置为？？？
  6. 所有接收器设置其ack为手动响应，且在listener使用后必须回写，防止队列阻塞
  7. 所有数据发送采用字符串，且存储数据信息尽量小于10K（已配置使用默认的json转换器）
  8. 队列、路由在创建后，属性不可更改，如有需要，需申请运维协助（建议使用新的队列，旧的队列数据处理完后可以删除）

 

命名规范

#命名规范：容器名称.[队列特点or路由特点].使用的平台名称.作用
#@容器名称：queue、exchange
#@队列特点：非持久化标记(undurable)、延时队列(delay)、优先级队列(priority)
#@路由特点：direct、topic、fanout、headers
#@使用的平台名称：xiangshang、xiangqian……
#@作用：干什么的
#eg：消息队列（queue.xiangshang.message）、延时消息队列（queue.delay.xiangshang.message）、普通路由（exchange.direct.xiangshang.common）、通用路由（exchange.direct.xiangshang.common）

 

整合Spring

  1. 大纲
    只需以下几步，即可实现测试，测试环境xshell账号（服务器：10.200.0.150       用户名：root           密码：xs360..COM）
    rabbitMQ管理平台（http://10.200.0.150:15672/         用户名：guest  密码：guest  连接端口：5672）
     
  2. 项目结构

      

  3. 依赖的jar

    < properties >
         < spring.amqp.version >1.6.6.RELEASE</ spring.amqp.version >
    </ properties >
    < dependencies >
         < dependency >
             < groupId >org.springframework.amqp</ groupId >
             < artifactId >spring-amqp</ artifactId >
             < version >${spring.amqp.version}</ version >
             < exclusions >
                 < exclusion >
                     < groupId >org.springframework</ groupId >
                     < artifactId >spring-core</ artifactId >
                 </ exclusion >
             </ exclusions >
         </ dependency >
         < dependency >
             < groupId >org.springframework.amqp</ groupId >
             < artifactId >spring-rabbit</ artifactId >
             < version >${spring.amqp.version}</ version >
             < exclusions >
                 < exclusion >
                     < groupId >org.springframework</ groupId >
                     < artifactId >spring-core</ artifactId >
                 </ exclusion >
                 < exclusion >
                     < groupId >org.springframework</ groupId >
                     < artifactId >spring-messaging</ artifactId >
                 </ exclusion >
                 < exclusion >
                     < groupId >org.springframework</ groupId >
                     < artifactId >spring-tx</ artifactId >
                 </ exclusion >
                 < exclusion >
                     < groupId >org.springframework</ groupId >
                     < artifactId >spring-context</ artifactId >
                 </ exclusion >
             </ exclusions >
         </ dependency >
    </ dependencies >

  4. 连接配置(rabbitmq-config.properties)

    #RabbitMQ服务器工厂参数设置
    rmq.addresses=10.200.0.150:5672
    rmq.username=root
    rmq.password=123456
    #命名规范：容器名称.[队列特点or路由特点].使用的平台名称.作用
    #@容器名称：queue、exchange
    #@队列特点：非持久化标记(undurable)、延时队列(delay)、优先级队列(priority)
    #@路由特点：direct、topic、fanout、headers
    #@使用的平台名称：xiangshang、xiangqian……
    #@作用：干什么的
    #eg：消息队列（queue.xiangshang.message）、延时消息队列（queue.delay.xiangshang.message）、普通路由（exchange.direct.xiangshang.common）、通用路由（exchange.direct.xiangshang.common）
    rmq.queue.xiangshang.test=queue.xiangshang.test
    rmq.queue.undurable.xiangshang.test=queue.undurable.xiangshang.test
    rmq.queue.priority.xiangshang.test=queue.priority.xiangshang.test
    rmq.queue.delay.xiangshang.test=queue.delay.xiangshang.test
    rmq.exchange.direct.xiangshang.test=exchange.direct.xiangshang.test
    rmq.exchange.fanout.xiangshang.test=exchange.fanout.xiangshang.test
    rmq.exchange.headers.xiangshang.test=exchange.headers.xiangshang.test

  5. xml配置(rabbitConfiguration.xml)

    <? xml  version = "1.0"  encoding = "UTF-8" ?>
    < beans  xmlns = "<a href="http://www.springframework.org/schema/beans" "="" style="color: rgb(59, 115, 175); text-decoration: none; border-radius: 0px !important; background: none !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 20px !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important;">http://www.springframework.org/schema/beans"  xmlns:xsi = "<a href="http://www.w3.org/2001/XMLSchema-instance" "="" style="color: rgb(59, 115, 175); text-decoration: none; border-radius: 0px !important; background: none !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 20px !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important;">http://www.w3.org/2001/XMLSchema-instance"
    xmlns:rabbit = "<a href="http://www.springframework.org/schema/rabbit" "="" style="color: rgb(59, 115, 175); text-decoration: none; border-radius: 0px !important; background: none !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 20px !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important;">http://www.springframework.org/schema/rabbit"
    xmlns:context = "<a href="http://www.springframework.org/schema/context" "="" style="color: rgb(59, 115, 175); text-decoration: none; border-radius: 0px !important; background: none !important; border: 0px !important; bottom: auto !important; float: none !important; height: auto !important; left: auto !important; line-height: 20px !important; margin: 0px !important; outline: 0px !important; overflow: visible !important; padding: 0px !important; position: static !important; right: auto !important; top: auto !important; vertical-align: baseline !important; width: auto !important; box-sizing: content-box !important; min-height: auto !important;">http://www.springframework.org/schema/context"
         xsi:schemaLocation="http://www.springframework.org/schema/rabbit http://www.springframework.org/schema/rabbit/spring-rabbit-1.6.xsd
             http://www.springframework.org/schema/beans  http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
             http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd ">
         < description >rabbitMQ连接服务配置</ description >
         
         < context:property-placeholder  location = "classpath:rabbitmq-config.properties" />
         
         <!-- 连接配置 -->
         < rabbit:connection-factory  id = "connectionFactory"  addresses = "${rmq.addresses}"  username = "${rmq.username}"  password = "${rmq.password}"  />
         < rabbit:admin  connection-factory = "connectionFactory"  />
         <!-- 消息转换器 -->
         < bean  id = "gsonConverter"  class = "org.springframework.amqp.support.converter.Jackson2JsonMessageConverter"  />
         <!-- 连接模板 -->
         < rabbit:template  id = "rabbitTemplate"  connection-factory = "connectionFactory"  message-converter = "gsonConverter"  exchange = "${rmq.exchange.direct.xiangshang.test}"  />
         <!-- 消息队列  begin -->
         < rabbit:queue  name = "${rmq.queue.xiangshang.test}"  durable = "true"  />
         < rabbit:queue  name = "${rmq.queue.undurable.xiangshang.test}"  durable = "false"  />
         < rabbit:queue  name = "${rmq.queue.priority.xiangshang.test}"  durable = "false" >
             < rabbit:queue-arguments >
                 < entry  key = "x-max-priority" >
                     < value  type = "java.lang.Integer" >10</ value >
                 </ entry >
             </ rabbit:queue-arguments >
         </ rabbit:queue >
         < rabbit:queue  name = "${rmq.queue.delay.xiangshang.test}" >
             < rabbit:queue-arguments >
                 < entry  key = "x-message-ttl" >
                     < value  type = "java.lang.Long" >60000</ value >
                 </ entry >
                 < entry  key = "x-dead-letter-exchange"  value = "${rmq.exchange.direct.xiangshang.test}" />
                 < entry  key = "x-dead-letter-routing-key"  value = "${rmq.queue.xiangshang.test}" />
             </ rabbit:queue-arguments >
         </ rabbit:queue >
         <!-- 消息队列 end -->
         <!-- 消息路由  begin -->
         < rabbit:direct-exchange  name = "${rmq.exchange.direct.xiangshang.test}" >
             < rabbit:bindings >
                 < rabbit:binding  queue = "${rmq.queue.xiangshang.test}"  key = "${rmq.queue.xiangshang.test}"  />
                 < rabbit:binding  queue = "${rmq.queue.undurable.xiangshang.test}"  key = "${rmq.queue.undurable.xiangshang.test}"  />
                 < rabbit:binding  queue = "${rmq.queue.priority.xiangshang.test}"  key = "${rmq.queue.priority.xiangshang.test}"  />
                 < rabbit:binding  queue = "${rmq.queue.delay.xiangshang.test}"  key = "${rmq.queue.delay.xiangshang.test}"  />
             </ rabbit:bindings >
         </ rabbit:direct-exchange >
         
         <!-- 发布订阅 -->
         < rabbit:fanout-exchange  name = "${rmq.exchange.fanout.xiangshang.test}" >
             < rabbit:bindings >
                 < rabbit:binding  queue = "${rmq.queue.xiangshang.test}"   />
                 < rabbit:binding  queue = "${rmq.queue.undurable.xiangshang.test}"  />
             </ rabbit:bindings >
         </ rabbit:fanout-exchange >
         
         <!-- 路由转发 -->
         < rabbit:headers-exchange  name = "${rmq.exchange.headers.xiangshang.test}" >
             < rabbit:bindings >
                 < rabbit:binding  queue = "${rmq.queue.delay.xiangshang.test}" >
                     < rabbit:binding-arguments >
                         < entry  key = "x-match"  value = "all" />
                         < entry  key = "operator"  value = "xsjf" />
                         < entry  key = "sex"  value = "male" />
                     </ rabbit:binding-arguments >
                 </ rabbit:binding >
             </ rabbit:bindings >
         </ rabbit:headers-exchange >
         <!-- 消息路由  end -->
         
         <!-- 监听器  begin -->
         <!-- 消息接收：DirectListener.java继承MessageListener接口实现onMessage方法即可，concurrency表示并发处理的监听数量 -->
         < bean  id = "directListener"  class = "com.xiangshang.mq.listener.DirectListener"  />
         < rabbit:listener-container  connection-factory = "connectionFactory"  message-converter = "gsonConverter"  concurrency = "1"  acknowledge = "manual" >
             < rabbit:listener  queues = "${rmq.queue.xiangshang.test},${rmq.queue.undurable.xiangshang.test}"  ref = "directListener"  />
         </ rabbit:listener-container >
         <!-- 监听器  end -->
    </ beans >

  6. 客户端发送（DirectQueueTest.java示例）

    package  com.xiangshang.mq.test;
    import  java.util.Random;
    import  org.springframework.amqp.core.AmqpTemplate;
    import  org.springframework.amqp.core.Message;
    import  org.springframework.amqp.core.MessageDeliveryMode;
    import  org.springframework.amqp.core.MessageProperties;
    import  org.springframework.beans.BeansException;
    import  org.springframework.context.ConfigurableApplicationContext;
    import  org.springframework.context.support.ClassPathXmlApplicationContext;
    public  class  DirectQueueTest {
         private  static  String RMQ_QUEUE_XIANGSHANG_TEST;
         private  static  String RMQ_QUEUE_UNDURABLE_XIANGSHANG_TEST;
         private  static  String RMQ_QUEUE_PRIORITY_XIANGSHANG_TEST;
         private  static  String RMQ_QUEUE_DELAY_XIANGSHANG_TEST;
         
         private  static  String RMQ_EXCHANGE_DIRECT_XIANGSHANG_TEST;
         private  static  String RMQ_EXCHANGE_FANOUT_XIANGSHANG_TEST;
         private  static  String RMQ_EXCHANGE_HEADERS_XIANGSHANG_TEST;
         
         private  static  ConfigurableApplicationContext context =  null ;
         private  static  AmqpTemplate rabbitTemplate =  null ;
         
         static  {
             RMQ_QUEUE_XIANGSHANG_TEST =  "queue.xiangshang.test" ;
             RMQ_QUEUE_UNDURABLE_XIANGSHANG_TEST =  "queue.undurable.xiangshang.test" ;
             RMQ_QUEUE_PRIORITY_XIANGSHANG_TEST =  "queue.priority.xiangshang.test" ;
             RMQ_QUEUE_DELAY_XIANGSHANG_TEST =  "queue.delay.xiangshang.test" ;
             
             RMQ_EXCHANGE_DIRECT_XIANGSHANG_TEST =  "exchange.direct.xiangshang.test" ;
             RMQ_EXCHANGE_FANOUT_XIANGSHANG_TEST =  "exchange.fanout.xiangshang.test" ;
             RMQ_EXCHANGE_HEADERS_XIANGSHANG_TEST =  "exchange.headers.xiangshang.test" ;
             
             try  {
                 context =  new  ClassPathXmlApplicationContext( "rabbitConfiguration.xml" );
             }  catch  (BeansException e) {
                 e.printStackTrace();
             }
             rabbitTemplate = context.getBean( "rabbitTemplate" , AmqpTemplate. class );
         }
         
         public  static  void  main(String[] args) {
             demo1();
         }
         
         /**
          * 对队列发送消息
          */
         public  static  void  demo1() {
             String sendMsg =  "队列消息."  + String.valueOf( new  Random().nextDouble());
             
             /*
              * 默认路由已配置为exchange.direct.xiangshang.test
              * 发送普通消息：rabbit服务重启后，数据丢失
              */
             MessageProperties mp1 =  new  MessageProperties();
             mp1.setDeliveryMode(MessageDeliveryMode.NON_PERSISTENT);
             Message msg1 =  new  Message(sendMsg.getBytes(), mp1);
             rabbitTemplate.convertAndSend(RMQ_QUEUE_XIANGSHANG_TEST, msg1);
             rabbitTemplate.convertAndSend(RMQ_EXCHANGE_DIRECT_XIANGSHANG_TEST, RMQ_QUEUE_XIANGSHANG_TEST, msg1); // 效果同上
             rabbitTemplate.convertAndSend(RMQ_QUEUE_UNDURABLE_XIANGSHANG_TEST, msg1);
             
             /*
              *  发送持久化消息：rabbit服务重启后，持久化队列数据可恢复(默认情况是持久化的)
              */
             rabbitTemplate.convertAndSend(RMQ_QUEUE_XIANGSHANG_TEST, sendMsg);
             rabbitTemplate.convertAndSend(RMQ_QUEUE_UNDURABLE_XIANGSHANG_TEST, sendMsg);
         }
         
         /**
          * 发送广播：此时广播下所有队列均可接收到数据
          */
         public  static  void  demo2() {
             String sendMsg =  "广播消息."  + String.valueOf( new  Random().nextDouble());
             rabbitTemplate.convertAndSend(RMQ_EXCHANGE_FANOUT_XIANGSHANG_TEST, RMQ_QUEUE_UNDURABLE_XIANGSHANG_TEST, sendMsg);
         }
         
         /**
          * 优先级队列
          */
         public  static  void  demo3() {
             for  ( int  i =  0 ; i <  10 ; i++) {
                 int  priority =  new  Random().nextInt( 10 );
                 String sendMsg =  "队列消息."  + String.valueOf( new  Random().nextDouble()) +  "["  + priority +  "]" ;
                 System.out.println(sendMsg);
                 MessageProperties mp =  new  MessageProperties();
                 mp.setPriority(priority);
                 Message msg =  new  Message(sendMsg.getBytes(), mp);
                 rabbitTemplate.convertAndSend(RMQ_QUEUE_PRIORITY_XIANGSHANG_TEST, msg);
             }
         }
         
         /**
          * 延迟消息队列
          * 1.当前rabbitMQ没有自动排序的队列，它所支持的队列是无序的
          * 2.队列遵守先进先出，因此它执行的顺序是确认第一条数据过期时间为基准，如果第二条过期时间在第一条之前，第二条不会在第一条之前执行
          *   eg：队列数据过期时间依次为 30s后、10秒后、20秒后，此时必须等到30秒后队列才出数据
          * 3.因此，延迟消息功能需要规范以下几点：
          *   3.1 每个延迟业务申明独有的路由、队列，并标注业务使用说明
          *   3.2 延迟队列最好设置消息的最大过期时间，到期后要转发的路由和队列
          *   3.3 header采用全部匹配，路由中需匹配与生产端header相同
          */
         public  static  void  demo4() {
             for  ( int  i =  0 ; i <  3 ; i++) {
                 int  delay = (i +  1 ) *  2  *  1000 ;
                 String sendMsg =  "队列消息."  + String.valueOf( new  Random().nextDouble()) +  "["  + delay +  "]" ;
                 System.out.println(sendMsg);
                 
                 MessageProperties mp =  new  MessageProperties();
                 mp.setExpiration(String.valueOf(delay)); // 设置消息过期时间
                 
                 mp.setHeader( "operator" ,  "xsjf" );
                 mp.setHeader( "sex" ,  "male" );
                 
                 Message msg =  new  Message(sendMsg.getBytes(), mp);
                 rabbitTemplate.convertAndSend(RMQ_EXCHANGE_HEADERS_XIANGSHANG_TEST,  "" , msg);
             }
         }
    }

  7. 消息监听（DirectListener.java示例）

    package  com.xiangshang.mq.listener;
    import  org.springframework.amqp.core.Message;
    import  org.springframework.amqp.rabbit.core.ChannelAwareMessageListener;
    import  com.rabbitmq.client.Channel;
     
    public  class  DirectListener  implements  ChannelAwareMessageListener {
         /* (non-Javadoc)
          * @see org.springframework.amqp.core.MessageListener#onMessage(org.springframework.amqp.core.Message)
          */
         @Override
         public  void  onMessage(Message message, Channel channel)  throws  Exception {
             System.out.println( "DirectListener 获取的消息内容："  +  new  String(message.getBody()));
             channel.basicAck(message.getMessageProperties().getDeliveryTag(),  false ); // 返回成功ack
             // channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, true);// 返回失败ack，并且数据重新入队
             Thread.currentThread().sleep( 1000 );
         }
    }

硬核！SpringBoot集成RabbitMQ消息队列搭建与ACK消息确认入门
【优快云】
06-28 716
1.Windows下安装RabbitMQ的步骤详解+图解（erlang+RabbitMQ） 2.SpringBoot集成RabbitMQ参考文章 1.RabbitMQ介绍 RabbitMQ是实现AMQP（高级消息队列协议）的消息中间件的一种，最初起源于金融系统，用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。RabbitMQ主要是为了实现系统之间的双向解耦而实现的。当生产者大量产生数据时，消费者无法快速消费，那么需要一个中间层。保存这个数据。 AMQP，即Advan
RabbitMQ的使用（JAVA）
热门推荐
..............
11-15 1万+
Java快速上手的MQ上线！
rabbitmq开发规范
07-04
1：rabbitmq的命名规范 2：rabbitmq生产者开发规范 3：rabbitmq消费者开发规范
RabbitMQ 使用指南
weixin_47531845的博客
10-12 211
消息中间件利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数据通信来进行分布式系统的集成。通过提供消息传递和消息排队模型，它可以在分布式环境下扩展进程间的通信。对于消息中间件，常见角色大致也就有 Producer（生产者）、Consumer（消费者）。 常见的消息中间件产品: 1). ActiveMQ ActiveMQ 是 Apache 出品，最流行的，能力强劲的开源消息总线。ActiveMQ 是一个完全支持 JMS1.1 和 J2EE 1.4 规范的 JMS Provider 实现。我们..
RabbitMQ 使用教程
最新发布
小凯的博客
06-19 1332
方便快速学习RabbitMQ
Rabbitmq 使用及规范
说不如做
04-10 1325
Direct：处理路由键，需要将一个队列绑定到交换机上，要求该消息与一个特定的路由键完全匹配。# 消费者每次从队列获取的消息数量 (默认一次250个)，配置消息的预读数量控制消费者一次性从队列中读取多少条消息，做到能者多劳的配置（因为在实际的生产环境中每个服务器的配置不可能完全相同，带来的处理消息的时间也不一样）。Message :消息：服务与应用程序之间传送的数据，由Properties和body组成，Properties可是对消息进行修饰，比如消息的优先级，延迟等高级特性，Body则就是消息体的内容。
RabbitMQ 使用规范
iijik55的博客
04-22 1370
******一、**命名规范 1.Queue设计 A生产消息，指定由B消费，这样的话就定义一个队列。 A生产消息，由B和C共同消费，因B和C都为多个节点，故系统定义为两个不同队列，虽然消息是相同的。 A和B生产消息，由C消费，可定义一个队列，也可定义两个队列。为便于区分消息生产者和消费者，定义消息队列名为生产者模块简称_消息参数_消费者模块简称，按照此思路，此种场景也需定义两个队列。 如示例，队列名与队列ID一致： 2.Exchange设计**** 如示例，交换机exchange命名以消费方BasicD
2.1_springboot2.x消息介绍&RabbitMQ运行机制
含江君
10-14 286
1、概述 1.大多应用中，可通过消息服务中间件来提升系统异步通信、扩展解耦能力 2.消息服务中两个重要概念： ​ 消息代理（message broker）即消息服务器 和目的地（destination） 当消息发送者发送消息以后，将由消息代理接管，消息代理保证消息传递到指定目的地。 3.消息队列主要有两种形式的目的地 1.队列（queue）：点对点消息通信（point-to-point...
RabbitMQ入门6：Spring Boot整合RabbitMQ；（入门级演示）
小枯林的博客
05-11 761
说明： （1） 一：创建两个Spring Boot项目，分别充当Producer和Consumer； 关于Spring Boot项目的创建，可以参考【Spring Boot入门三：创建Spring Boot项目；（包括【Spring 官网start.spring.io】方式，【IDEA集成的Spring Initializr】方式）】或者【Spring Boot电商项目8：数据库设计与项目初始化三：创建Spring Boot项目；】； 1.创建【spring-boot-rabbitmq-pro
RabbitMQ 学习(三) —— rabbitmq整合spring、springboot、springcloudstream
hxyascx的博客
03-17 424
RabbitMQ整合Spring AMQP实战 RabbitAdmin RabbitAdmin类可以很好的操作RabbitMQ，在Spring中直接进行注入即可。（注意：autoStartup必须要设置为true，否则Spring容器不会加载RabbitAdmin类） RabbitAdmin底层实现就是从Spring容器中获取Exchange、Bingding、RoutingKey以及Queue的...
spring-cloud-starter-stream-rabbit MQ使用规范
03-12
各个微服务统一使用spring-cloud-starter-stream-rabbit 为规范各个微服务之间消息队列的交换机、通道、队列、消息投递更加便于识别、扩展和维护特进行以下要求
rabbitMQ的api及规范说明书.doc
07-24
Mq 一种应用程序对应用程序的通信方法. AMQP 一个提供统一消息服务的应用层标准高级消息队列协议 Erlang Erlang是一种通用的面向并发的编程语言，目的是创造一种可以应对大规模并发活动的编程语言和运行环境。
Rabbit扩展开发规范
06-05
简短的文字资料，中文。介绍了严格遵循MVC开发规范的相关知识。依赖注入、尽量使用NuGet中的组件与扩展、尽量不要去违反与修改框架和原有组件已经定义的行为、慎重使用静态类型、尽量使用Lazy来包装注入的服务（Framework自身的服务除外）、规范的命名方式、严格遵循MVC开发规范
RabbitMQ技术分享
04-02
此ppt主要介绍的是RabbitMQ,简单功能、过程，优缺点、和其他MQ对比等。还有一些资料的连接。
rabbitmq的使用笔记
weixin_34050389的博客
02-02 123
2019独角兽企业重金招聘Python工程师标准&gt;&gt;&gt; ...
RabbitMQ基础
qq_45412648的博客
09-05 1149
MQ全称消息队列），是在消息的传输过程中保存消息的容器。多用于分布式系统之间进 行通信。AMQP，即 Advanced Message Queuing Protocol（高级消息队列协议），是一个网络协议，是应用层协议 的一个开放标准，为面向消息的中间件设计。基于此协议的客户端与消息中间件可传递消息，并不受客户端/中 间件不同产品，不同的开发语言等条件的限制。2006年，AMQP 规范发布。类比HTTP。
Rabbitmq五种使用方式使用规则
qq_40093255的博客
04-05 640
点对点 工作模式（Task model） 广播模式（直连）fanout 发送消息流程： 可以有多个消费者 每个消费者有自己的queue 每个队列都要绑定到exchange（交换机） 生产者发送的消息，只能发送到交换机，交换机绝对要发给哪个队列，生产者无法决定 交换机把消息发送绑定过的所有队列 队列的消费者都能拿到消息，实现一条消息被多个消费者消费 路由模式之订阅（direct） 在...
RabbitMQ的使用建议
走错路的程序员
12-29 1785
经过长达4年多的使用经验, 发现网上有很多的误解和错误的代码. 为清楚一些错误的观念和使用方式. 特意写了这个文章统一大家的编程规范和命名规范, 方便系统开发和系统集成. 增加了一些其它文章中的常见问题 和使用指南.和命名指南 首先要建立代码连接,然后绑定,然后发送. 代码中与RabbitMQ的连接是保持一打开永久使用的长连接的好呢? 还是每次需要都打开的好? 在数据库操作的时候是建议每次执行查询都打开连接, 然后再关上. 那么在操作RabbitMQ的时候, 是否也应该如此呢? 我的建议如下: 摘抄自.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值