每天进步一点点---------RabbitMq

最新推荐文章于 2023-10-08 15:47:51 发布
最新推荐文章于 2023-10-08 15:47:51 发布
阅读量1.3k 收藏 1
点赞数 1
分类专栏： 畅购商城 文章标签： rabbitmq java 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45759288/article/details/122896520
版权

题记

看了很多网上教程，对RabbitMq有了一个初步的了解，但是仍然没有想明白，在生产环境中，如何使用才会稳定、可靠、安全，因此记录从零-1的学习过程，在学习过程中练习和熟悉RabbitMq。
资料：
官网文档
黑马Java就业班2.1
【学相伴】RabbitMQ最新完整教程IDEA版通俗易懂 | KuangStudy | 狂神说 | 学相伴飞哥 推荐

一、RabbitMq概念熟悉

网上很多教程都是SpringBoot集成RabbitMq，对于我这种连Mq本身都不了解的人来说已经跳过了一部分，所以先使用RabbitMq本身尝试一下Mq的概念，然后再通过SpringBoot集成RabbitMq，对于可靠的rabbitMq集群，后序练习，熟悉概念的过程是通过RabbitMq的web页面直接去查看的。

1. 页面头信息
可以很清晰的看到，头部包含RabbitMq的版本、ErLang语言的版本、上次数据刷新的时间、virtualHost、当前登录用户、集群名称，下面重点看一下集群名称和virtualHost。
在这里插入图片描述

**集群名称**：单机部署的RabbitMq也会有集群名称，为节点的名称，本案例为docker启动，设置的*hostname=my-rabbit*，因此此处显示的是集群名称，点击集群名称，也是可以修改集群名称的。

在这里插入图片描述
virtualHost：虚拟主机，和虚拟机类似，每个virtualHost 是相互隔离的 exchange 、message、queue 互不相通，因此可以认为一个virtualHost为一个rabbitMq实例，虚拟主机可以通过下图添加，Tags标签的作用暂时还未了解，如果哪位大神熟悉，还请帮忙留言指导。
在这里插入图片描述
user:可以自己控制用户，控制权限，包括对哪个virtualhost进行权限控制、对topic交换机进行权限控制。权限的设置类型如下

	Configure regexp：对queue或exchange新建和配置的权限。
	Write regexp：对一个queue或exchange写消息的权限。
	Read regexp：对一个queue或exchange读消息的权限。
	
	.* 表示对所有queue和exchange有此权限。
	^$ 表示对所有的queue和exchage没有此权限。
	^(hello.*)$ 表示只有以hello开头的queue或exchage的权限
	^(hello.*|team.*)$ 表示有以hello和team开头的queue或exchange的权限。

在这里插入图片描述

2. Limits
和VirtualHost、User一起的功能还包含Feature Flags、policy、Limits,Feature Flags和policy还未看到，不太懂，先跳过，Limits就很明显了，和Linux的ulimit类似，可以控制队列和连接的最大值。
在这里插入图片描述

3. Connection、Channel 、queues

这三个概念是比较好理解的，找一个网上大神的图，可以很清楚的说明，生产消息（生产者）连接RabbitMq，为一个Connection可以包含多个Channel，RabbitMq通过exchange（交换机）对消息进行路由到Queue(队列)。
在这里插入图片描述
在这里插入图片描述
参考黑马部分代码如下，可以明确看到ConnectionFactory获取Connection，Connection获取channel。

        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.8.102");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();

二、RabbitMq主要消息模式

实践6种消息模式之前，先搭建集成RabbitMq的SpringBoot工程，方便验证。
（1）引入下面的依赖

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

（2）在SpringBoot工程中创建exchange和queue等有两种方式，一种是注解方式，一种是xml方式，注解方式更加简便，此处使用注解形式，application.yml配置如下：

spring:
  application:
    name: provider
  rabbitmq:
    username: guest
    password: guest
    host: 192.168.8.102
    port: 5672
    virtual-host: mall

注：对于virtualHost设置的名称问题，是没有必要设置/mall的，具体可以参考大神的博客《rabbitmq 虚拟主机vhost名称设置问题》,virtualhost是需要提前创建好的，否则会报错。
（3）定义一个User类作为要发送的对象

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private String userName;
    private String sex;
    private String lover;
    private Integer age;
    private Integer height;
}

（4）创建MqConfig，即注解方式生成交换机，队列等

@Configuration
public class HelloMqConfig {

    @Value("${rabbitconfig.helloqueue.name}")
    String queueName;

    /**
     * 定制JSON格式的消息转换器
     *
     * @return
     */
    @Bean
    public MessageConverter messageConverter() {
        return new Jackson2JsonMessageConverter();
    }

    //1、定义一个消息队列
    @Bean
    public Queue direct_queue() {
        return QueueBuilder.durable(queueName).build();
    }
}

注：测试时发现，当发送消息时，才会真正的创建，不发送消息不会创建。

1. HelloWorld模式
helloworld模式没有指定交换机，其实使用的是默认交换机，在创建后的界面也可以很明确的看到，默认交换机其实就是一个direct交换机，routekey为队列名称即可。
在这里插入图片描述
在这里插入图片描述
（1）手动验证发送
选择virtualHost为mall，然后添加queue，在exchanges中选择defaultExchange，publish消息的时候添加routekey为queue名称即可。
在这里插入图片描述
（2）注解代码
发送端代码为：

@Configuration
public class HelloMqConfig {

    @Value("${rabbitconfig.helloqueue.name}")
    String queueName;

    /**
     * 定制JSON格式的消息转换器
     *
     * @return
     */
    @Bean
    public MessageConverter messageConverter() {
        return new Jackson2JsonMessageConverter();
    }

    //1、定义一个消息队列
    @Bean
    public Queue direct_queue() {
        return QueueBuilder.durable(queueName).build();
    }
}

发送的代码为：
rabbitTemplate.convertAndSend("hello", new User("hhh", "male", "zzz", 18, 20));

消费端代码为：
只要消费端一直执行着，就能消费掉消息

@Component
public class HelloListener {

    @RabbitListener(queues = "hello")
    public void reviceMessage(String message) {
        System.out.println("接收了消息" + message);
    }
}

2. WorkQueue模式
workQueue模式和简单模式并没有太大的区别，只是增加了一个消费端，我们直接消费端复制一份或者多起一个实例来尝试一下，两个消费端默认的执行方式是轮询模式。
在这里插入图片描述
消费端1的回显为：

接收了消息{"userName":"hhh","sex":"male","lover":"zzz","age":20,"height":20}
接收了消息{"userName":"hhh","sex":"male","lover":"zzz","age":22,"height":20}
接收了消息{"userName":"hhh","sex":"male","lover":"zzz","age":24,"height":20}
接收了消息{"userName":"hhh","sex":"male","lover":"zzz","age":26,"height":20}
接收了消息{"userName":"hhh","sex":"male","lover":"zzz","age":28,"height":20}
接收了消息{"userName":"hhh","sex":"male","lover":"zzz","age":30,"height":20}
接收了消息{"userName":"hhh","sex":"male","lover":"zzz","age":32,"height":20}
接收了消息{"userName":"hhh","sex":"male","lover":"zzz","age":34,"height":20}
接收了消息{"userName":"hhh","sex":"male","lover":"zzz","age":36,"height":20}
接收了消息{"userName":"hhh","sex":"male","lover":"zzz","age":38,"height":20}

消费端2的回显为：

接收了消息{"userName":"hhh","sex":"male","lover":"zzz","age":21,"height":20}
接收了消息{"userName":"hhh","sex":"male","lover":"zzz","age":23,"height":20}
接收了消息{"userName":"hhh","sex":"male","lover":"zzz","age":25,"height":20}
接收了消息{"userName":"hhh","sex":"male","lover":"zzz","age":27,"height":20}
接收了消息{"userName":"hhh","sex":"male","lover":"zzz","age":29,"height":20}
接收了消息{"userName":"hhh","sex":"male","lover":"zzz","age":31,"height":20}
接收了消息{"userName":"hhh","sex":"male","lover":"zzz","age":33,"height":20}
接收了消息{"userName":"hhh","sex":"male","lover":"zzz","age":35,"height":20}
接收了消息{"userName":"hhh","sex":"male","lover":"zzz","age":37,"height":20}
接收了消息{"userName":"hhh","sex":"male","lover":"zzz","age":39,"height":20}

参考大神博客《Springboot中RabbitMQ公平模式》，即使增加了不同的延时，仍然消费如上，处理能力强的消费端并没有处理更多的消息，可以在消费端增加下面的配置，改变为公平模式。

  rabbitmq:
    username: guest
    password: guest
    host: 192.168.8.102
    port: 5672
    virtual-host: mall
    listener:
    下面的两个配置都需要有
      simple:
        prefetch: 0
        acknowledge-mode: manual

此时需要将消费端修改为手动确认，Listener修改如下

    @RabbitListener(queues = "hello")
    public void reviceMessage(Message message, Channel channel) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("接收了消息" + new String(message.getBody()));
        try {
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), true);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

3. Publish/subscribe 模式
发布订阅模式和设计模式的观察者实现的功能类似，需要定义一个交换机，多个队列，不同的消费者消费不同的队列消息即可。
在这里插入图片描述
（1）手动尝试
添加fanoutExchange，然后修改bind即可，注意routekey为空。
在这里插入图片描述
查看queue的绑定交换机会显示交换机名称，不会显示类似，看着像未绑定成功，其实绑定成功了。
在这里插入图片描述
（2）代码实现
provider实现队列创建：

@Configuration
public class FanOutMqConfig {

    @Value("${rabbitconfig.fanoutqueue.name}")
    String queueName;

    /**
     * 定制JSON格式的消息转换器
     *
     * @return
     */
    @Bean
    public MessageConverter messageConverter() {
        return new Jackson2JsonMessageConverter();
    }

    @Bean
    public FanoutExchange fanoutExchange() {
        return ExchangeBuilder.fanoutExchange(queueName).durable(true).build();
    }

    //1、定义一个消息队列
    @Bean
    public Queue fanoutQueue1() {
        return QueueBuilder.durable(queueName + "1").build();
    }

    //1、定义一个消息队列
    @Bean
    public Queue fanoutQueue2() {
        return QueueBuilder.durable(queueName + "2").build();
    }

    @Bean
    public Binding fanoutQueue1Bind() {
        return BindingBuilder.bind(fanoutQueue1()).to(fanoutExchange());
    }

    @Bean
    public Binding fanoutQueue2Bind() {
        return BindingBuilder.bind(fanoutQueue2()).to(fanoutExchange());
    }
}

Consumer指定消费的队列，直接改代码中的指定队列即可，运行后可以看到两者打印一直。
在这里插入图片描述
4. Routing 路由模式
路由模式是交换机指定路由，匹配方法为全匹配，创建完成后，查看一下绑定关系如下：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

Provider代码：
路由模式和发布订阅模式交换机类型改变，绑定时，增加路由key即可。

@Configuration
public class RouteMqConfig {

    String queueName = "directQueue";

    @Bean
    public DirectExchange routeExchange() {
        return ExchangeBuilder.directExchange(queueName).durable(true).build();
    }

    //1、定义一个消息队列
    @Bean
    public Queue directQueue1() {
        return QueueBuilder.durable(queueName + "1").build();
    }

    //1、定义一个消息队列
    @Bean
    public Queue directQueue2() {
        return QueueBuilder.durable(queueName + "2").build();
    }

    @Bean
    public Binding queue1Binding(){
        return BindingBuilder.bind(directQueue1()).to(routeExchange()).with("info");
    }

    @Bean
    public Binding queue2Binding(){
        return BindingBuilder.bind(directQueue2()).to(routeExchange()).with("error");
    }

}

消费者正常绑定到队列消费即可，按照年龄奇数和偶数的方式增加到了两个队列，消费的时候可以明显看到已分开。
在这里插入图片描述
5. Topics 模式
在这里插入图片描述
主体模式其实就是在路由模式的基础上，支持了对key的通配符匹配（星号以及井号），以满足更加复杂的消息分发场景。
“#” : 匹配一个或者多个
“*”：匹配一个
只是key不同，不做尝试

三、细节技术点

1. 消息可靠性
消息可靠性即MQ接收到消息之后的应答和消费端消费后的应答，

  • Confirm确认模式：从Producer到exchange，则会返回一个confirmACK
  • return回退模式：从exchange到消费端失败则会返回一个returnback
    生产端消息确认机制：
@Configuration
@Slf4j
public class RouteMqConfig {
    String queueName = "directQueue";

    @Bean
    public RabbitTemplate getRabbitTemplate(ConnectionFactory connectionFactory) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        rabbitTemplate.setReturnCallback((message, replyCode, replyText, exchange, routingKey) -> {
            String correlationId = message.getMessageProperties().getCorrelationId();
            log.debug("消息：{} 发送失败, 应答码：{} 原因：{} 交换机: {}  路由键: {}", correlationId, replyCode, replyText, exchange, routingKey);
        });

        rabbitTemplate.setConfirmCallback((correlationData, ack, cause) -> {
            if (ack) {
                 log.debug("消息发送到exchange成功,id: {}", correlationData.getId());
            } else {
                log.debug("消息发送到exchange失败,原因: {}", cause);
            }
        });

        rabbitTemplate.setMessageConverter(new Jackson2JsonMessageConverter());

        return rabbitTemplate;
    }


    @Bean
    public DirectExchange routeExchange() {
        return ExchangeBuilder.directExchange(queueName).durable(true).build();
    }

    @Bean
    public DirectExchange deadExchange() {
        return ExchangeBuilder.directExchange("deadexchange").durable(true).build();
    }

    //1、定义一个消息队列
    @Bean
    public Queue directQueue1() {
        return QueueBuilder.durable(queueName + "1").build();
    }

    //1、定义一个消息队列
    @Bean
    public Queue deadQueue1() {
        return QueueBuilder.durable("deadQueue").build();
    }

    //1、定义一个消息队列
    @Bean
    public Queue directQueue2() {
        return QueueBuilder.durable(queueName + "2").deadLetterExchange("deadexchange").deadLetterRoutingKey("dead").ttl(5000).build();
    }

    @Bean
    public Binding queue1Binding() {
        return BindingBuilder.bind(directQueue1()).to(routeExchange()).with("info");
    }

    @Bean
    public Binding queue2Binding() {
        return BindingBuilder.bind(directQueue2()).to(routeExchange()).with("error");
    }

    @Bean
    public Binding deadQueueBinding() {
        return BindingBuilder.bind(deadQueue1()).to(deadExchange()).with("dead");
    }
}

yml增加下面的两个参数
    publisher-confirm-type: correlated
    publisher-returns: true

消费端确认方式：

yml配置
手动应答，应答ACK时消息会背消费掉，应答Nack时，消息会进入死信队列
    listener:
      simple:
        prefetch: 5
        acknowledge-mode: manual

@Component
public class HelloListener {

    @RabbitListener(queues = "directQueue1")
    public void reviceMessage(Message message, Channel channel) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            try {
            	// 异常时，应答Nack，不重发，否则会使得上面的重试失效，造成死循环
                channel.basicNack(message.getMessageProperties().getDeliveryTag(),false,false);
            } catch (IOException ioException) {
                ioException.printStackTrace();
            }
        }
        System.out.println("接收了消息" + new String(message.getBody()));
        try {
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), true);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2. 延迟队列
是通过死信队列实现的，设置TTL，如果30分钟还未被消费，则进入死信队列。

3. 死信队列
死信队列即无法处理的消息重新找一个交换机发送到一个队列，可以右专门的消费端处理，出现的原因包含下面几种情况：

  • 消息被拒绝(basic.reject / basic.nack)，并且requeue = false
  • 消息TTL过期
  • 队列达到最大长度

在上面的基础上构造死信队列也很简单，加一个死信交换机并且绑定队列和routekey，在队列设置私信队列“x-dead-letter-exchange”和“x-dead-letter-routing-key”的时候设置成死信队列即可。

@Configuration
public class RouteMqConfig {

    String queueName = "directQueue";

    @Bean
    public DirectExchange routeExchange() {
        return ExchangeBuilder.directExchange(queueName).durable(true).build();
    }

    @Bean
    public DirectExchange deadExchange() {
        return ExchangeBuilder.directExchange("deadexchange").durable(true).build();
    }

    //1、定义一个消息队列
    @Bean
    public Queue directQueue1() {
        return QueueBuilder.durable(queueName + "1").build();
    }

    //1、定义一个消息队列
    @Bean
    public Queue deadQueue1() {
        return QueueBuilder.durable("deadQueue").build();
    }

    //1、定义一个消息队列
    @Bean
    public Queue directQueue2() {
        Map<String, Object> args = new HashMap<>();
        args.put("x-message-ttl", 5000);
        args.put("x-dead-letter-exchange","deadexchange");
        args.put("x-dead-letter-routing-key","dead");
        return QueueBuilder.durable(queueName + "2").withArguments(args).build();
    }

    @Bean
    public Binding queue1Binding() {
        return BindingBuilder.bind(directQueue1()).to(routeExchange()).with("info");
    }

    @Bean
    public Binding queue2Binding() {
        return BindingBuilder.bind(directQueue2()).to(routeExchange()).with("error");
    }
    @Bean
    public Binding deadQueueBinding() {
        return BindingBuilder.bind(deadQueue1()).to(deadExchange()).with("dead");
    }
}

4. 消费端限流
消费端限流即消费端修改成手动确认，然后设置每次处理5个情况

    listener:
      simple:
        prefetch: 5
        acknowledge-mode: manual

5. TTL
有两种方式，一种是消息添加TTL，一种是队列添加TTL，单独消息的未想明白什么场景使用，练习队列添加TTL，
添加队列的时候，添加一个args即可，单位ms，超过TTL时间的消息会自动删除，和死信队列一起使用，防止消息丢失

        Map<String, Object> args = new HashMap<>();
        args.put("x-message-ttl", 5000);
        return QueueBuilder.durable(queueName + "2").withArguments(args).build();

在这里插入图片描述
6. 消息追踪
开启后性能会下降，但是很好用
7. 消息补偿

8. 幂等性保障

应用案例

案例以后遇到的时候再维护

攀登程序猿
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【原创】RabbitMQ 之 Configure（翻译）
weixin_34293059的博客
05-28 147
2019独角兽企业重金招聘Python工程师标准>>> ...
RabbitMQ基础教程
zhiqiuqiu2的博客
11-24 1550
消息队列（Message Queue），我们一般简称为MQ。消息队列中间件是分布式系统中重要的组件，具有异步性、松耦合、分布式、可靠性等特点。用于实现高性能、高可用、可伸缩和最终一致性架构。是大型分布式系统不可缺少的中间件。目前主流的消息队列有RocketMQ、Kafka、RabbitMQ、ZeroMQ、MetaMQ等。消息队列在很多业务场景中都会使用到，例如：异步处理、应用解耦、流量消锋、数据同步、日志处理等等。下面是一个消息队列最简单的架构模型。
RabbitMQ 安装、web访问、命令、配置、Python操作
freeking101的博客
07-12 2930
RabbitMQ 安装，使用 ( Pytho )
RabbitMQ入门_15_访问控制
denggouda2767的博客
06-13 413
参考资料：https://www.rabbitmq.com/access-control.html A. 核心概念 Virtual Host：虚拟主机为 RabbitMQ 中的资源提供了逻辑分组与隔离 资源：资源是虚拟主机中的实体，例如队列和交换机。不同虚拟主机中的同名实体是不同的资源 B. Rabbit 访问控制基本流程 当客户端尝试建立到 RabbitMQ 的连接时，必须指定虚...
196、管理 RabbitMQ 的用户
Java 领域技术分享
10-08 982
管理 RabbitMQ 的用户
rabbitmq-server3.10.5
01-10
rabbitmq-server3.10.5
rabbitmq-c:RabbitMQ C客户端
05-10
有关该库的公告会定期在rabbitmq-c用户上发布，并交叉发布到rabbitmq-users。 最新稳定版 可以在以下位置找到rabbitmq-c的最新稳定版本： 文献资料 v0.8.0 +的API文档可以从以下位置查看： 入门 建造和安装 先决...
rabbitmq-jar包
06-29
amqp-client-3.2.4.jar amqp-client-5.3.0.jar rabbitmq-jar包
rabbitmq-mqtt：RabbitMQ MQTT插件
03-02
rabbitmq-plugins enable rabbitmq_mqtt 插件使用的默认端口为1883 。 文献资料 可从rabbitmq.com获得。 贡献 参见 。 运行测试 克隆RabbitMQ伞库之后，转到rabbitmq-mqtt目录并运行 make tests 这将打开一个启用了...
rabbitmq-server-3.7.15安装包
07-13
rabbitmq-server-3.7.15安装包以及依赖文件，包含erlang-20.3.6-1.el7.centos.x86_64.rpm、socat-1.7.3.2-2.el7.x86_64.rpm、rabbitmq-server-3.7.15-1.el7.noarch.rpm
Rabbitmq安装笔记
08-09
主要是笔者在本地环境安装rabbitmq-server同时安装对MQTT插件的应用，整理成文档以供分享
RebbitMQ简单介绍
12-05
自己学习的的时候总结的RebbitMQ从安装到JAVA代码比较易懂
rabbitmq创建账号
weixin_48215755的博客
07-04 2210
rabbitmq创建账号
Ansible 使用playbook编译安装apache
YangLuxxx123
07-22 402
Ansible 使用playbook编译安装apache 1.关闭防火墙 //关闭防火墙 --- - hosts: apache tasks: - name: stop firewalld service: name: firewalld state: stopped - name: lineinfile: path: /etc/selinux/config regexp: "^SELINU
一看就懂的 RabbitMQ 使用教程
咸鱼老罗的博客
02-25 675
一天，阿强接到一个需求，将公网的服务的执行结果通知到内网的服务上。阿强一想，很简单阿，只要在公网搭一个简单的消息服务，给公网系统提供一个存储消息接口；给内网系统提供一个查询消息接口，消息存在 mysql。内网服务跑个定时器，轮询查询接口。他麻溜的搭好服务，实现业务并通过自测。嗯，奈斯。 这个项目的负责人阿明同学，看了阿强的实现，认为添加新服务增加维护部署成本，轮询每次都要查询数据库降低性能，推荐使用 RabbitMQ，并说服了阿强。 阿强用 docker 启动一个单节点的 RabbitMQ，在管理台进行配
RabbitMQ配置
weixin_34062469的博客
05-12 1271
配置文件 1、配置文件位置 rabbitmq的系统配置文件一般是rabbitmq.conf,可以登录后台查看它的路径，如果你是源码安装，最初这个文件是没有的，需要手动创建； 小弟服务器上地址：C:\Users\Administrator\AppData\Roaming\RabbitMQ 配置文件：c:/Users/ADMINI~1/AppData/Roaming/Ra...
RabbitMQ界面管理和命令管理
极客神殿
03-20 6557
RabbitMQ vhost管理RabbitMQ vhost 全称为Virtual Host(虚拟主机)，一个broker里可以开设多个vhost，用作不同用户的权限分离。权限控制组，用户只能关联到一个vhost上，一个vhost中可以有若干个Exchange和Queue，默认的vhost是”/” 一、通过RabbitMQ管理后台管理vhosthttp://localhost:15672/#/vho
rabbitmq技术的一些感悟
每天积累一点，一年后你会发现，自己变化很大
01-30 2331
Rabbitmq 初识rabbitmq RabbitMQ是流行的开源消息队列系统，用erlang语言开发。RabbitMQ是AMQP（高级消息队列协议）的标准实现。如果不熟悉AMQP，直接看RabbitMQ的文档会比较困难。不过它也只有几个关键概念，这里简单介绍 几个概念说明： Broker：简单来说就是消息队列服务器实体。 Exchange：消息交换机，它指定消息按
RabbitMQ
言程序
12-04 921
MQ是消费-生产者模型的一个典型的代表，一端往消息队列中不断写入消息，而另一端则可以读取或者订阅队列中的消息。    在项目应用中，将一些无需即时返回且耗时的操作提取出来，进行异步处理，这种异步处理的方式将大大的节省服务器的请求响应时间，从而提高了系统的吞吐量。     1. RabbitMQ安装。 通过wget下载压缩包，安装MQ。使用命令：rabbitmq-plugins ena
rabbitmq-comsuer和rabbitmq-trigger插件
最新发布
05-07
1. rabbitmq-comsuer插件是一个消费者插件，用于从RabbitMQ队列中接收消息并进行处理。它可以连接到RabbitMQ服务器，并订阅一个或多个队列，以接收消息。一旦有消息到达队列，消费者插件将触发相应的处理逻辑，可以...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值