RabbitMQ实战:高效部署分布式消息队列 PDF

  • 更新时间:
  • 3711人关注
  • 点击下载

给大家带来的一篇关于RabbitMQ相关的电子书资源,介绍了关于RabbitMQ、RabbitMQ实战、分布式消息方面的内容,本书是由电子工业出版社出版,格式为PDF,资源大小89.47 MB,Alvaro编写,目前豆瓣、亚马逊、当当、京东等电子书综合评分为:8.8分

资源详情相关推荐
RabbitMQ实战:高效部署分布式消息队列
  • 出版社:电子工业出版社
  • 作者:Alvaro
  • 大小:89.47 MB
  • 类别:RabbitMQ
  • 热度:179
  • 深入RabbitMQ
  • RabbitMQ实战指南
  • 分布式系统常用技术及案例分析
  • 分布式机器学习:算法、理论与实践
  • 《RabbitMQ实战:高效部署分布式消息队列》对RabbitMQ做了全面、翔实的讲解,体现了两位专家的真知灼见。《RabbitMQ实战:高效部署分布式消息队列》首先介绍了有关MQ的历史,然后从基本的消息通信原理讲起,带领读者一路探索RabbitMQ的消息通信世界。这当中不仅包含了针对单台RabbitMQ服务器和RabbitMQ集群的讲解,还教导读者如何使用各种工具来进行监控。《RabbitMQ实战:高效部署分布式消息队列》内容浅显易懂,文笔风趣幽默。《RabbitMQ实战:高效部署分布式消息队列》中包含了丰富的、可以运行的示例程序源代码,读者可以自行下载并运行,这种亲身实践有助于加深对相关主题的理解。对于初学者来说,这样的编排非常适用。...

    AlvaroVidela,是一名专门从事基于MQ应用程序的开发者和架构师。JasonJ.W.Williams,是消息通信服务供应商DigiTar公司的CTO,他领导着设计与开发工作。...

    目录

    • 第1章 天降奇兵1
    • 1.1 住在别人的地下城堡 3
    • 1.2 救世主AMQP 5
    • 1.3 RabbitMQ简史 5
    • 1.4 百里挑一 8
    • 1.5 在UNIX系统上安装RabbitMQ 8
    • 1.5.1 为什么环境很重要——生活在Erlang 的世界里 9
    • 1.5.2 获取安装包 9
    • 1.5.3 设置文件夹结构 9
    • 1.5.4 首次运行Rabbit 10
    • 1.6 总结 12
    • 第2章 理解消息通信13
    • 2.1 消费者和生产者(这可不是经济学课程哦) 14
    • 2.2 从底部开始构造:队列 17
    • 2.3 联合起来:交换器和绑定 22
    • 2.4 多租户模式:虚拟主机和隔离 27
    • 2.5 我的消息去哪儿了呢?持久化和你的策略 28
    • 2.6 把所有内容结合起来:一条消息的一生 32
    • 2.7 使用发送方确认模式来确认投递 37
    • 2.8 总结 40
    • 第3章 运行和管理Rabbit 42
    • 3.1 服务器管理 43
    • 3.1.1 启动节点 43
    • 3.1.2 停止节点 45
    • 3.1.3 关闭和重启应用程序:有何差别 46
    • 3.1.4 Rabbit 配置文件 46
    • 3.2 请求许可 48
    • 3.2.1 管理用户 49
    • 3.2.2 Rabbit 的权限系统 50
    • 3.3 检查 54
    • 3.3.1 查看数据统计 54
    • 3.3.2 理解RabbitMQ 日志 59
    • 3.4 修复Rabbit:疑难解答 63
    展开阅读
    精选笔记:Spring Boot系列教程之7步集成RabbitMQ的方法

    11小时33分钟前回答

    前言

    RabbitMQ是一种我们经常使用的消息中间件,RabbitMQ是实现AMQP(高级消息队列协议)的消息中间件的一种,最初起源于金融系统,用于在分布式系统中存储转发消息,在易用性、扩展性、高可用性等方面表现不俗。RabbitMQ主要是为了实现系统之间的双向解耦而实现的。当生产者大量产生数据时,消费者无法快速消费,那么需要一个中间层。保存这个数据。

    AMQP,即Advanced Message Queuing Protocol,高级消息队列协议,是应用层协议的一个开放标准,为面向消息的中间件设计。消息中间件主要用于组件之间的解耦,消息的发送者无需知道消息使用者的存在,反之亦然。AMQP的主要特征是面向消息、队列、路由(包括点对点和发布/订阅)、可靠性、安全。

    RabbitMQ是一个开源的AMQP实现,服务器端用Erlang语言编写,支持多种客户端,如:Python、Ruby、.NET、Java、JMS、C、PHP、ActionScript、XMPP、STOMP等,支持AJAX。用于在分布式系统中存储转发消息,在易用性、扩展性、高可用性等方面表现不俗。

    今天这篇,我们来看看Spring Boot是如何集成RabbitMQ,发送消息和消费消息的。同时我们介绍下死信队列。

    集成RabbitMQ

    集成RabbitMQ只需要如下几步即可

    1、添加maven依赖

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

    2、添加配置文件application.yaml

    在application.yaml添加配置内容如下

    spring: rabbitmq:
     host: 192.168.1.161
     port: 5672
     username: guest
     password: guest
     cache:
     channel: size: 10
     listener:
     type: simple
     simple:
     acknowledge-mode: auto
     concurrency: 5
     default-requeue-rejected: true
     max-concurrency: 100
     retry:
     enabled: true # initial-interval: 1000ms
     max-attempts: 3 # max-interval: 1000ms
     multiplier: 1
     stateless: true # publisher-confirms: true</pre>

    注意:

    这里最基本的配置只需要配置host,port,username和password四个属性即可

    其他属性都有各自的含义,比如retry是用于配置重试策略的,acknowledge-mode是配置消息接收确认机制的。

    3、编写配置类

    编写RabbitConfig配置类,采用Java Configuration的方式配置RabbitTemplate、Exchange和Queue等信息,具体如下所示

    package com.jackie.springbootdemo.config;
    
    import org.springframework.amqp.core.*;
    import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory;
    import org.springframework.amqp.rabbit.connection.ConnectionFactory;
    import org.springframework.amqp.rabbit.core.RabbitTemplate;
    import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
    import org.springframework.beans.factory.InitializingBean;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.beans.factory.config.ConfigurableBeanFactory;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.Scope;
    
    import java.util.HashMap;
    import java.util.Map;
    
    @Configuration public class RabbitMQConfig implements InitializingBean { @Autowired
     SimpleRabbitListenerContainerFactory simpleRabbitListenerContainerFactory;
    
     @Override
     public void afterPropertiesSet() throws Exception {
     simpleRabbitListenerContainerFactory.setMessageConverter(new Jackson2JsonMessageConverter());
     } @Bean("jackson2JsonMessageConverter")
     public Jackson2JsonMessageConverter jackson2JsonMessageConverter(ConnectionFactory connectionFactory) {
     return new Jackson2JsonMessageConverter();
     } @Bean("rabbitTemplate")
     @Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)
     public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory,
      @Qualifier("jackson2JsonMessageConverter") Jackson2JsonMessageConverter jackson2JsonMessageConverter) {
     RabbitTemplate template = new RabbitTemplate(connectionFactory);
     template.setMessageConverter(new Jackson2JsonMessageConverter());
     return template;
     } // --------------------- 声明队列 ------------------------
     @Bean
     public Queue demoQueue() {
     return new Queue("demo_queue");
     } // --------------------- 声明exchange ------------------------ @Bean
     public DirectExchange demoExchange() {
     return new DirectExchange("demo_exchange");
     } // --------------------- 队列绑定 ------------------------
     @Bean
     public Binding bindingAlbumItemCreatedQueue(DirectExchange demoExchange,
      Queue demoQueue) {
     return BindingBuilder.bind(demoQueue).to(demoExchange).with("100");
     } }

    注意

    这里声明了Direct模式的Exchange,声明一个Queue,并通过routing-key为100将demo_queue绑定到demo_exchange,这样demo_queue就可以接收到demo_exchange发送的消息了。

    4、编写消息发送类

    package com.jackie.springbootdemo.message;
    
    import org.springframework.amqp.rabbit.core.RabbitTemplate;
    import org.springframework.amqp.rabbit.support.CorrelationData;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    @Component public class Sender implements RabbitTemplate.ConfirmCallback { private RabbitTemplate rabbitTemplate;
    
     /**
     * 构造方法注入 */ @Autowired
     public Sender(RabbitTemplate rabbitTemplate) {
     this.rabbitTemplate = rabbitTemplate;
     rabbitTemplate.setConfirmCallback(this); //rabbitTemplate如果为单例的话,那回调就是最后设置的内容
     } public void sendMsg(String content) {
     rabbitTemplate.convertAndSend("demo_exchange", "100", content);
     } /**
     * 回调 */ @Override
     public void confirm(CorrelationData correlationData, boolean ack, String cause) {
     System.out.println(" 回调id:" + correlationData);
     if (ack) {
     System.out.println("消息成功消费");
     } else {
     System.out.println("消息消费失败:" + cause);
     }
     } }

    注意

    发送内容content,路由到routing-key为100上,则我们就可以在demo_queue队列中看到发送的消息内容了

    confirm函数是回调函数,这里因为没有消费者,且acknoledge-mode是auto(其他两种值分别是none和manual),所以ack是false。

    5、编写发送消息测试类

    package com.jackie.springbootdemo;
    
    import com.jackie.springbootdemo.message.Sender;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    import org.springframework.test.context.web.WebAppConfiguration;
    
    @RunWith(SpringRunner.class) @SpringBootTest(classes = SpringbootDemoApplication.class) @WebAppConfiguration public class RabbitApplicationTests { @Autowired
     Sender sender;
    
     @Test
     public void contextLoads() throws Exception {
     sender.sendMsg("test");
     } } 

    运行该测试类,我们可以看到如下结果

    Spring Boot系列教程之7步集成RabbitMQ的方法

    6、编写消息消费类

    package com.jackie.springbootdemo.message;
    
    import org.springframework.amqp.rabbit.annotation.RabbitListener;
    import org.springframework.stereotype.Component;
    
    @Component public class Receiver { @RabbitListener(queues = "demo_queue")
     public void created(String message) {
     System.out.println("orignal message: " + message);
     } } 

    注意

    消息消费类也非常简单,添加注解@RabbitListener,指定要监听的队列名称即可

    除了注解@RabbitListener,我们经常还能看到@RabbitHandler,这两个注解可以配合起来使用。

    @RabbitListener 标注在类上面表示当有收到消息的时候,就交给 @RabbitHandler 的方法处理,具体使用哪个方法处理,根据 MessageConverter 转换后的参数类型,形如

    @RabbitListener(queues = "demo_queue") public class Receiver { @RabbitHandler public void processMessage1(String message) {
     System.out.println(message);
     } @RabbitHandler
     public void processMessage2(byte[] message) {
     System.out.println(new String(message));
     } }

    7、运行消息发送测试类

    Spring Boot系列教程之7步集成RabbitMQ的方法

    从执行结果可以看到,因为有了消费者,所以这次打印的结果是"消息消费成功"

    而且,我们看到Receiver类将消息消费并打印出消息的内容为"test"。

    代码已经提交至项目rome:https://github.com/DMinerJackie/rome (本地下载)

    总结

    以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,如果有疑问大家可以留言交流,谢谢大家对码农之家的支持。

    展开阅读
    精选笔记:浅谈Java消息队列总结篇(ActiveMQ、RabbitMQ、ZeroMQ、Kafka)

    2小时31分钟前回答

    一、消息队列概述

    消息队列中间件是分布式系统中重要的组件,主要解决应用解耦,异步消息,流量削锋等问题,实现高性能,高可用,可伸缩和最终一致性架构。目前使用较多的消息队列有ActiveMQ,RabbitMQ,ZeroMQ,Kafka,MetaMQ,RocketMQ。

    二、消息队列应用场景

    以下介绍消息队列在实际应用中常用的使用场景。异步处理,应用解耦,流量削锋和消息通讯四个场景。

    2.1异步处理

    场景说明:用户注册后,需要发注册邮件和注册短信。传统的做法有两种 1.串行的方式;2.并行方式

    a、串行方式:将注册信息写入数据库成功后,发送注册邮件,再发送注册短信。以上三个任务全部完成后,返回给客户端。

    浅谈Java消息队列总结篇(ActiveMQ、RabbitMQ、ZeroMQ、Kafka)

    b、并行方式:将注册信息写入数据库成功后,发送注册邮件的同时,发送注册短信。以上三个任务完成后,返回给客户端。与串行的差别是,并行的方式可以提高处理的时间

    浅谈Java消息队列总结篇(ActiveMQ、RabbitMQ、ZeroMQ、Kafka) 

    假设三个业务节点每个使用50毫秒钟,不考虑网络等其他开销,则串行方式的时间是150毫秒,并行的时间可能是100毫秒。

    因为CPU在单位时间内处理的请求数是一定的,假设CPU1秒内吞吐量是100次。则串行方式1秒内CPU可处理的请求量是7次(1000/150)。并行方式处理的请求量是10次(1000/100)

    小结:如以上案例描述,传统的方式系统的性能(并发量,吞吐量,响应时间)会有瓶颈。如何解决这个问题呢?

    引入消息队列,将不是必须的业务逻辑,异步处理。改造后的架构如下:

    浅谈Java消息队列总结篇(ActiveMQ、RabbitMQ、ZeroMQ、Kafka)

    按照以上约定,用户的响应时间相当于是注册信息写入数据库的时间,也就是50毫秒。注册邮件,发送短信写入消息队列后,直接返回,因此写入消息队列的速度很快,基本可以忽略,因此用户的响应时间可能是50毫秒。因此架构改变后,系统的吞吐量提高到每秒20 QPS。比串行提高了3倍,比并行提高了两倍。

    2.2应用解耦

    场景说明:用户下单后,订单系统需要通知库存系统。传统的做法是,订单系统调用库存系统的接口。如下图:

    浅谈Java消息队列总结篇(ActiveMQ、RabbitMQ、ZeroMQ、Kafka)

    传统模式的缺点:假如库存系统无法访问,则订单减库存将失败,从而导致订单失败,订单系统与库存系统耦合

    如何解决以上问题呢?引入应用消息队列后的方案,如下图:

    浅谈Java消息队列总结篇(ActiveMQ、RabbitMQ、ZeroMQ、Kafka)

    订单系统:用户下单后,订单系统完成持久化处理,将消息写入消息队列,返回用户订单下单成功

    库存系统:订阅下单的消息,采用拉/推的方式,获取下单信息,库存系统根据下单信息,进行库存操作

    假如:在下单时库存系统不能正常使用。也不影响正常下单,因为下单后,订单系统写入消息队列就不再关心其他的后续操作了。实现订单系统与库存系统的应用解耦

    2.3流量削峰

    流量削锋也是消息队列中的常用场景,一般在秒杀或团抢活动中使用广泛。

    应用场景:秒杀活动,一般会因为流量过大,导致流量暴增,应用挂掉。为解决这个问题,一般需要在应用前端加入消息队列。

    a、可以控制活动的人数

    b、可以缓解短时间内高流量压垮应用

    浅谈Java消息队列总结篇(ActiveMQ、RabbitMQ、ZeroMQ、Kafka)

    用户的请求,服务器接收后,首先写入消息队列。假如消息队列长度超过最大数量,则直接抛弃用户请求或跳转到错误页面。

    秒杀业务根据消息队列中的请求信息,再做后续处理。

    2.4日志处理

    日志处理是指将消息队列用在日志处理中,比如Kafka的应用,解决大量日志传输的问题。架构简化如下:

    浅谈Java消息队列总结篇(ActiveMQ、RabbitMQ、ZeroMQ、Kafka)

    日志采集客户端,负责日志数据采集,定时写受写入Kafka队列。

    Kafka消息队列,负责日志数据的接收,存储和转发。

    日志处理应用:订阅并消费kafka队列中的日志数据。

    2.5消息通讯

    消息通讯是指,消息队列一般都内置了高效的通信机制,因此也可以用在纯的消息通讯。比如实现点对点消息队列,或者聊天室等。

    点对点通讯:

    浅谈Java消息队列总结篇(ActiveMQ、RabbitMQ、ZeroMQ、Kafka)

    客户端A和客户端B使用同一队列,进行消息通讯。

    聊天室通讯:

    浅谈Java消息队列总结篇(ActiveMQ、RabbitMQ、ZeroMQ、Kafka)

    客户端A,客户端B,客户端N订阅同一主题,进行消息发布和接收。实现类似聊天室效果。

    以上实际是消息队列的两种消息模式,点对点或发布订阅模式。模型为示意图,供参考。

    三、消息中间件示例

    3.1电商系统

    浅谈Java消息队列总结篇(ActiveMQ、RabbitMQ、ZeroMQ、Kafka)

    消息队列采用高可用,可持久化的消息中间件。比如Active MQ,Rabbit MQ,Rocket Mq。

    应用将主干逻辑处理完成后,写入消息队列。消息发送是否成功可以开启消息的确认模式。(消息队列返回消息接收成功状态后,应用再返回,这样保障消息的完整性)

    扩展流程(发短信,配送处理)订阅队列消息。采用推或拉的方式获取消息并处理。

    消息将应用解耦的同时,带来了数据一致性问题,可以采用最终一致性方式解决。比如主数据写入数据库,扩展应用根据消息队列,并结合数据库方式实现基于消息队列的后续处理。

    3.2日志收集系统

    浅谈Java消息队列总结篇(ActiveMQ、RabbitMQ、ZeroMQ、Kafka)

    分为Zookeeper注册中心,日志收集客户端,Kafka集群和Storm集群(OtherApp)四部分组成。

    Zookeeper注册中心,提出负载均衡和地址查×××

    日志收集客户端,用于采集应用系统的日志,并将数据推送到kafka队列

    Kafka集群:接收,路由,存储,转发等消息处理

    Storm集群:与OtherApp处于同一级别,采用拉的方式消费队列中的数据

    MQ选型对比文档

    浅谈Java消息队列总结篇(ActiveMQ、RabbitMQ、ZeroMQ、Kafka)

    综合选择RabbitMq

    Kafka是linkedin开源的MQ系统,主要特点是基于Pull的模式来处理消息消费,追求高吞吐量,一开始的目的就是用于日志收集和传输,0.8开始支持复制,不支持事务,适合产生大量数据的互联网服务的数据收集业务。

    RabbitMQ是使用Erlang语言开发的开源消息队列系统,基于AMQP协议来实现。AMQP的主要特征是面向消息、队列、路由(包括点对点和发布/订阅)、可靠性、安全。AMQP协议更多用在企业系统内,对数据一致性、稳定性和可靠性要求很高的场景,对性能和吞吐量的要求还在其次。

    RocketMQ是阿里开源的消息中间件,它是纯Java开发,具有高吞吐量、高可用性、适合大规模分布式系统应用的特点。RocketMQ思路起源于Kafka,但并不是Kafka的一个Copy,它对消息的可靠传输及事务性做了优化,目前在阿里集团被广泛应用于交易、充值、流计算、消息推送、日志流式处理、binglog分发等场景。

    ZeroMQ只是一个网络编程的Pattern库,将常见的网络请求形式(分组管理,链接管理,发布订阅等)模式化、组件化,简而言之socket之上、MQ之下。对于MQ来说,网络传输只是它的一部分,更多需要处理的是消息存储、路由、Broker服务发现和查找、事务、消费模式(ack、重投等)、集群服务等。

    RabbitMQ/Kafka/ZeroMQ 都能提供消息队列服务,但有很大的区别。

    在面向服务架构中通过消息代理(比如 RabbitMQ / Kafka等),使用生产者-消费者模式在服务间进行异步通信是一种比较好的思想。

    因为服务间依赖由强耦合变成了松耦合。消息代理都会提供持久化机制,在消费者负载高或者掉线的情况下会把消息保存起来,不会丢失。就是说生产者和消费者不需要同时在线,这是传统的请求-应答模式比较难做到的,需要一个中间件来专门做这件事。其次消息代理可以根据消息本身做简单的路由策略,消费者可以根据这个来做负载均衡,业务分离等。

    缺点也有,就是需要额外搭建消息代理集群(但优点是大于缺点的 ) 。

    ZeroMQ 和 RabbitMQ/Kafka 不同,它只是一个异步消息库,在套接字的基础上提供了类似于消息代理的机制。使用 ZeroMQ 的话,需要对自己的业务代码进行改造,不利于服务解耦。

    RabbitMQ 支持 AMQP(二进制),STOMP(文本),MQTT(二进制),HTTP(里面包装其他协议)等协议。Kafka 使用自己的协议。

    Kafka 自身服务和消费者都需要依赖 Zookeeper。

    RabbitMQ 在有大量消息堆积的情况下性能会下降,Kafka不会。毕竟AMQP设计的初衷不是用来持久化海量消息的,而Kafka一开始是用来处理海量日志的。

    总的来说,RabbitMQ 和 Kafka 都是十分优秀的分布式的消息代理服务,只要合理部署,不作,基本上可以满足生产条件下的任何需求。

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持码农之家。

    展开阅读

    资源下载

    相关资源

    • Spring Boot 2精髓:从构建小系统到架构分布式大系统

      Spring Boot 2精髓:从构建小系统到架构分布式大系统

      这本书系统介绍了Spring Boot 2的主要技术,涵盖Spring Boot框架、Spring MVC、视图技术、数据库访问技术,并且介绍多环境部署、自动装配、单元测试等高级特性,介绍如何平滑地用Spring Boot实现分布式架构等

      大小:174.8 MBSpringBoot

      立即下载
    • ZooKeeper分布式过程协同技术详解

      ZooKeeper分布式过程协同技术详解

      本书分三部分,共10章。第一部分(第1~2章)阐述ApacheZooKeeper这类系统的设计目的和动机,并介绍分布式系统的一些必要背景知识。第1章介绍ZooKeeper可以做什么,以及其设计如何支撑这些任务

      大小:4.51 MBZooKeeper

      立即下载
    • 云系统管理:大规模分布式系统设计与运营

      云系统管理:大规模分布式系统设计与运营

      本书分为两个部分-----设计和运营。 第一部分捕捉我们在大规模、复杂、基于云的分布式计算系统设计上的想法。在引言之后,我们从下向上逐层介绍设计的每个要素。我们从系统管理员(而

      大小:285 MB云系统

      立即下载
    • 深入分布式缓存:从原理到实践

      深入分布式缓存:从原理到实践

      本书从大型互联网系统的应用角度探讨分布式缓存的书籍,包含了原理、框架、架构、案例等多方面的视角,帮助对读者对分布式缓存有一个体系化的认识

      大小:153.2 MB分布式缓存

      立即下载

    学习笔记

    7小时21分钟前回答

    SpringAOP+RabbitMQ+WebSocket实战详解

    背景 最近公司的客户要求,分配给员工的任务除了有微信通知外,还希望PC端的网页也能实时收到通知。管理员分配任务是在我们的系统A,而员工接受任务是在系统B。两个系统都是现在已投入使用的系统。 技术选型 根据需求我们最终选用SpringAOP+RabbitMQ+WebSocket。 SpringAOP可以让我们不修改原有代码,直接将原有service作为切点,加入切面。RabbitMQ可以让A系统和B系统解耦。WebSocket则可以达到实时通知的要求。 SpringAOP AOP称为面向切面编程,在程序开发中主要用来解决一些系统层面上的问题,比如日志,事务,权限等待。是Spring的核心模块,底层是通过动态代理来实现(动态代理将在之后的文章重点介绍)。……

    18小时30分钟前回答

    springboot整合rabbitmq的示例代码

    概述 RabbitMQ是一个开源的消息代理和队列服务器,用来通过普通协议在完全不同的应用之间共享数据,或者简单地将作业队列以便让分布式服务器进行处理。 它现实了AMQP协议,并且遵循Mozilla Public License开源协议,它支持多种语言,可以方便的和spring集成。 消息队列使用消息将应用程序连接起来,这些消息通过像RabbitMQ这样的消息代理服务器在应用程序之间路由。 基本概念 Broker 用来处理数据的消息队列服务器实体 vhost 由RabbitMQ服务器创建的虚拟消息主机,拥有自己的权限机制,一个broker里可以开设多个vhost,用于不同用户的权限隔离,vhost之间是也完全隔离的。 productor 产生用于消息通信的数据 chan……

    10小时26分钟前回答

    Python rabbitMQ如何实现生产消费者模式

    (一)安装一个消息中间件,如:rabbitMQ (二)生产者 sendmq.py import pikaimport sysimport time # 远程rabbitmq服务的配置信息username = 'admin' # 指定远程rabbitmq的用户名密码pwd = 'admin'ip_addr = '10.1.7.7'port_num = 5672 # 消息队列服务的连接和队列的创建credentials = pika.PlainCredentials(username, pwd)connection = pika.BlockingConnection(pika.ConnectionParameters(ip_addr, port_num, '/', credentials))channel = connection.channel()# 创建一个名为balance的队列,对queue进行durable持久化设为True(持久化第一步)channel.queue_declare(queue='balance', durable=True) message_str = 'Hello World!'for i in range(100000000): # n RabbitMQ a message can never be sent directly to the queue, it always needs to go through an exchange……