RabbitMQ的使用

最新推荐文章于 2023-04-12 10:36:39 发布
最新推荐文章于 2023-04-12 10:36:39 发布
阅读量2.1k 收藏
点赞数
分类专栏： docker RabbitMQ 文章标签： spring boot java docker
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shz_123/article/details/123331323
版权

1.MQ的简介

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

MQ的优势：

  • 应用解耦
  • 任务异步处理
  • 消锋填谷

常见的 MQ 产品有很多，在这里我们主要简绍RabbitMQ这个产品


2.RabbitMQ的简绍

RabbitMQ的基础架构如下：

在这里插入图片描述

RabbitMQ提供了6种模式：

  • 简单模式
  • work模式
  • Publish/Subscribe发布与订阅模式
  • Routing路由模式
  • Topics主题模式
  • RPC模式（暂不简绍）

3.RabbitMQ结合SpringBoot的使用

在这里主要简绍Publish/Subscribe发布与订阅模式，Routing路由模式，Topics主题模式

3.1 RabbitMQ的安装

参考文档：https://blog.csdn.net/shz_123/article/details/122803739?spm=1001.2014.3001.5502

3.2 创建SpringBoot项目

  • 创建springboot项目，添加pom文件依赖（生产者Producer模块，消费者Consumer模块一样）
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--RabbitMQ的依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
  • application.yml文件配置RabbitMQ相关信息（要与RabbitMQ一致）（生产者Producer模块，消费者Consumer模块一样）；
spring:
 rabbitmq:
 #rabbitmq安装宿主机IP
 host: 192.168.126.140
 #登录管理控制台端口
 port: 5672
 #登录管理控制台的用户名
 username: admin
 password: 123456
 virtual-host: /song

在这里插入图片描述

3.3 在Producer模块创建config类， 注入RabbitTemplate对象，通过RabbitTemplate对象发送消息到交换机，在Consumer模块中创建Listener类来接收信息**

  • Publish/Subscribe发布与订阅模式的config（生产者发送消息，所有消费者都可以接收到消息，没有路由key值）
package com.song.springbootrabbitmqproducer.config;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 *Publish/Subscribe发布与订阅模式的config
 * @author song
 */
@Configuration
public class PublishModelConfig {
    /**队列_1名称*/
    public static final String PUBLISH_QUEUE_1 = "publish_queue_1";
    /**队列_2名称*/
    public static final String PUBLISH_QUEUE_2 = "publish_queue_2";
    /**交换器名称*/
    public static final String PUBLISH_EXCHANGE = "publish_exchange";

    /**
     * 申明交换机 durable=true表示持久化
     * @return 申明好的交换机
     */
    @Bean("publishEx")
    public Exchange getExchange() {
        return ExchangeBuilder.fanoutExchange(PUBLISH_EXCHANGE).durable(true).build();
    }

    /**
     * 申明队列  持久化
     * @return 申明好的队列
     */
    @Bean("publishQueue1")
    public Queue getQueue1(){
        return QueueBuilder.durable(PUBLISH_QUEUE_1).build();
    }

    /**
     * 申明队列  持久化
     * @return 申明好的队列
     */
    @Bean("publishQueue2")
    public Queue getQueue2(){
        return QueueBuilder.durable(PUBLISH_QUEUE_2).build();
    }

    /**
     * 将队列_1与交换器进行绑定
     * @param queue 要绑定的队列
     * @param exchange 要绑定的交换器
     * @return 绑定好的信息
     */
    @Bean
    public Binding getBinding1(@Qualifier("publishQueue1") Queue queue,
                              @Qualifier("publishEx") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("").noargs();
    }
    /**
     * 将队列_2与交换器进行绑定
     * @param queue 要绑定的队列
     * @param exchange 要绑定的交换器
     * @return 绑定好的信息
     */
    @Bean
    public Binding getBinding2(@Qualifier("publishQueue2") Queue queue,
                              @Qualifier("publishEx") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("").noargs();
    }
}

测试 发布与订阅模式

@SpringBootTest
class SpringbootRabbitmqProducerApplicationTests {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Test
    void test1() {
      //发送消息===》发布与订阅模式
        rabbitTemplate.convertAndSend(PublishModelConfig.PUBLISH_EXCHANGE,"","发布与订阅模式");
    }
}

在RabbitMQ管理控制台可以看到，两个队列分别都接收到了一条信息

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

在Consumer模块接收信息

@Component
public class MyListener{
    @RabbitListener(queues = "publish_queue_2")
    public void pubListener2(String message) {
        System.out.println("消费者2======接收到的消息为：" + message);
    }

    @RabbitListener(queues = "publish_queue_1")
    public void pubListener1(String message) {
        System.out.println("消费者1=====接收到的消息为：" + message);
    }
}

测试

@SpringBootTest
class SpringbootRabbitmqCustomerApplicationTests {
    @Autowired
    private MyListener myListener;
    @Test
    //测试设置为死循环，只要生产者发送消息，消费者就可以接收
    void test() {
        while(true){
        }
    }
}

在RabbitMQ管理控制台可以看到
在这里插入图片描述
在这里插入图片描述

Routing路由模式的config（生产者发送消息，交换机根据routingKey将消息分发到队列，在由消费者接收）

  /**
   * Routing路由模式的config
   * @author song
   */
  @Configuration
  public class RoutingModelConfig {
      /**队列名称 routingkey=insert*/
      public static final String ROUTING_QUEUE_KEY_INSERT = "routing_queue_key_insert";
      /**队列_1名称 routingkey=delete*/
      public static final String ROUTING_QUEUE_KEY_DELETE = "routing_queue_key_delete";
      /**交换器名称*/
      public static final String ROUTING_EXCHANGE = "routing_exchange";
      
  /**
  * 申明交换机 durable=true表示持久化
  * @return 申明好的交换机
  */
  @Bean("routingEx")
  public Exchange getExchange() {
      return ExchangeBuilder.directExchange(ROUTING_EXCHANGE).durable(true).build();
  }
  /**
   * 申明队列  持久化
   * @return 申明好的队列
   */
  @Bean("routingQueue_insert")
  public Queue getQueue1(){
      return QueueBuilder.durable(ROUTING_QUEUE_KEY_INSERT).build();
  }

  /**
   * 申明队列  持久化
   * @return 申明好的队列
   */
  @Bean("routingQueue_delete")
  public Queue getQueue2(){
      return QueueBuilder.durable(ROUTING_QUEUE_KEY_DELETE).build();
  }

  /**
   * 队列名称 路由key=insert与交换器进行绑定
   * @param queue 要绑定的队列
   * @param exchange 要绑定的交换器
   * @return 绑定好的信息
   */
  @Bean
  public Binding getRoutBinding1(@Qualifier("routingQueue_insert") Queue queue,
                             @Qualifier("routingEx") Exchange exchange){
      return BindingBuilder.bind(queue).to(exchange).with("insert").noargs();
  }
  /**
   * 队列_1名称 路由key=delete与交换器进行绑定
   * @param queue 要绑定的队列
   * @param exchange 要绑定的交换器
   * @return 绑定好的信息
   */
  @Bean
  public Binding getRoutBinding2(@Qualifier("routingQueue_delete") Queue queue,
                             @Qualifier("routingEx") Exchange exchange){
      return BindingBuilder.bind(queue).to(exchange).with("delete").noargs();
  }

}

测试 routing路由模式

@SpringBootTest
class SpringbootRabbitmqProducerApplicationTests {
  @Autowired
  private RabbitTemplate rabbitTemplate;
  @Test
  void test2() {
      rabbitTemplate.convertAndSend(RoutingModelConfig.ROUTING_EXCHANGE,"insert","routing模式====routingKey:" +
              "insert");

      rabbitTemplate.convertAndSend(RoutingModelConfig.ROUTING_EXCHANGE,"delete","routing模式====routingKey:" +
              "delete");
  }
}

在RabbitMQ管理控制台可以看到
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在Consumer模块接收信息

@Component
public class MyListener{

    @RabbitListener(queues = "routing_queue_key_delete")
    public void routListener2(String message) {
        System.out.println("消费者2======接收到的消息为：" + message);
    }

    @RabbitListener(queues = "routing_queue_key_insert")
    public void routListener1(String message) {
        System.out.println("消费者1=====接收到的消息为：" + message);
    }
}

测试 与 上述发布与订阅模式一样，不再叙述，直接看结果

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

  • Topics通配符模式的config（生产者发送消息，交换机根据routingKey将消息分发到队列，在由消费者接收）

    Topic 类型与 Routining相比，都是可以根据 RoutingKey 把消息路由到不同的队列。只不过 Topic 类型

Exchange 可以让队列在绑定 Routing key 的时候使用通配符！
Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert

通配符规则：
#：匹配一个或多个词
*：匹配不多不少恰好1个词

/**Topics主题模式的config
 * @author song
 */
@Configuration
public class TopicModelConfig {
    /**队列名称 路由key=item.#    */
    public static final String TOPIC_QUEUE_KEY_MONEY = "topic_queue_key_#";
    /**队列_1名称 路由key=item.*  */
    public static final String TOPIC_QUEUE_KEY_ONE = "topic_queue_key_*";
    /**交换器名称*/
    public static final String TOPIC_EXCHANGE = "topic_exchange";

    /**
     * 申明交换机 durable=true表示持久化
     * @return 申明好的交换机
     */
    @Bean("topicEx")
    public Exchange getExchange() {
        return ExchangeBuilder.topicExchange(TOPIC_EXCHANGE).durable(true).build();
    }

    /**
     * 申明队列  持久化
     * @return 申明好的队列
     */
    @Bean("topicQueue_#")
    public Queue getQueue1(){
        return QueueBuilder.durable(TOPIC_QUEUE_KEY_MONEY).build();
    }

    /**
     * 申明队列  持久化
     * @return 申明好的队列
     */
    @Bean("routingQueue_*")
    public Queue getQueue2(){
        return QueueBuilder.durable(TOPIC_QUEUE_KEY_ONE).build();
    }

    /**
     * 队列名称 路由key=item.# 与交换器进行绑定
     * @param queue 要绑定的队列
     * @param exchange 要绑定的交换器
     * @return 绑定好的信息
     */
    @Bean
    public Binding getTopBinding1(@Qualifier("topicQueue_#") Queue queue,
                                   @Qualifier("topicEx") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("item.#").noargs();
    }
    /**
     * 队列名称 路由key=item.* 与交换器进行绑定
     * @param queue 要绑定的队列
     * @param exchange 要绑定的交换器
     * @return 绑定好的信息
     */
    @Bean
    public Binding getTopBinding2(@Qualifier("routingQueue_*") Queue queue,
                                   @Qualifier("topicEx") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("item.*").noargs();
    }
}

测试 Topics通配符模式

@SpringBootTest
class SpringbootRabbitmqProducerApplicationTests {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Test
    void test3() {
        rabbitTemplate.convertAndSend(TopicModelConfig.TOPIC_EXCHANGE,
                "item.insert","商品新增，routing key 为item.insert");

        rabbitTemplate.convertAndSend(TopicModelConfig.TOPIC_EXCHANGE,
                "item.update.date", "商品修改，routing key 为item.update.date");
        rabbitTemplate.convertAndSend(TopicModelConfig.TOPIC_EXCHANGE,
                "item.delete", "商品删除，routing key 为item.delete");
    }
}

在RabbitMQ管理控制台可以看到

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

在Consumer模块接收信息

@Component
public class MyListener{
    @RabbitListener(queues = "topic_queue_key_#")
    public void topListener1(String message) {
        System.out.println("消费者1=====接收到的消息为：" + message);
    }

    @RabbitListener(queues = "topic_queue_key_*")
    public void topListener2(String message) {
        System.out.println("消费者2=====接收到的消息为：" + message);
    }
}

测试 与 上述发布与订阅模式一样，不再叙述，直接看结果

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

3.4 小结

  • Publish/Subscribe发布与订阅模式 交换机需要与队列进行绑定，绑定之后；一个消息可以被多个消费者都收到。
  • Routing路由模式 Routing模式要求队列在绑定交换机时要指定routing key，消息会转发到符合routing key的队列。
  • Topics通配符模式 Topic主题模式可以实现 Publish/Subscribe发布与订阅模式 和 Routing路由模式 的功能；只是Topic在配置routing key 的时候可以使用通配符，显得更加灵活。

4.RabbitMQ的高级特性

1.消息的可靠投递

在使用 RabbitMQ 的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景。

RabbitMQ 为我们提供了两种方式用来控制消息的投递可靠性模式。

  • confirm 确认模式

    消息从 producer 到 exchange 发生错误，则会返回一个 confirmCallback

  • return 退回模式

    消息从 exchange–>queue 投递失败则会返回一个 returnCallback 。

消息的可靠投递配置

  spring:
  rabbitmq:
    #rabbitmq安装宿主机IP
    host: 192.168.126.140
    #端口
    port: 5672
    #登录管理控制台的用户名
    username: admin
    password: 123456
    virtual-host: /song

    #消息的可靠投递
    # 旧版本 开启 confirm 确认模式
    # publisher-confirms: true
    # 新版的开启 confirm 确认模式
    publisher-confirm-type: correlated
    # 开启 return 退回模式
    publisher-returns: true

测试

 /**
     * 确认模式测试
     */
    @Test
    void confirmTest() {
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {

            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                System.out.println("confirm方法被执行了....");
                if (ack) {
                    //接收成功
                    System.out.println("接收成功消息" + cause);
                } else {
                    //接收失败
                    System.out.println("接收失败消息" + cause);
                    //做一些处理，让消息再次发送。
                }
            }
        });

//        rabbitTemplate.convertAndSend(TopicModelConfig.TOPIC_EXCHANGE,
//                "item.insert", "商品新增，routing key 为item.insert");
        rabbitTemplate.convertAndSend("error",
                "item.insert", "商品新增，routing key 为item.insert");
    }

模拟当发送消息时，交换机名称不对时，结果

在这里插入图片描述

/**
     * 返回模式测试
     */
    @Test
    public void testReturn() {
        //设置交换机处理失败消息的模式
        rabbitTemplate.setMandatory(true);
        //2.设置ReturnCallBack

        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
            /**
             *
             * @param message 消息对象
             * @param replyCode 错误码
             * @param replyText 错误信息
             * @param exchange 交换机
             * @param routingKey 路由键
             */
            @Override
            public void returnedMessage(Message message, int replyCode, String
                    replyText, String exchange, String routingKey) {
                System.out.println("return 执行了....");
                System.out.println(message);
                System.out.println(replyCode);
                System.out.println(replyText);
                System.out.println(exchange);
                System.out.println(routingKey);
                //处理
            }
        });
        //3. 发送消息
        //rabbitTemplate.convertAndSend(TopicModelConfig.TOPIC_EXCHANGE, "item.insert",
        //        "message confirm....");
        rabbitTemplate.convertAndSend(TopicModelConfig.TOPIC_EXCHANGE, "item1.insert",
                "message confirm....");
    }

模拟当发送消息时，routingKey不对时，结果

在这里插入图片描述

2.Consumer Ack 与 消费端限流

ack指Acknowledge，确认。 表示消费端收到消息后的确认方式。

有三种确认方式：

  • 自动确认：acknowledge=“none”

    自动确认是指，当消息一旦被Consumer接收到，则自动确认收到，并将相应 message从RabbitMQ 的消息缓存中移除。但是在实际业务处理中，很可能消息接收到，业务处理出现异常，那么该消息就会丢失

  • 手动确认：acknowledge="manual

    手动确认方式，则需要在业务处理成功后，调用channel.basicAck()，手动签收，如果出现异常，则调用channel.basicNack()方法，让其自动重新发送消息

  • 根据异常情况确认：acknowledge=“auto”，（这种方式使用麻烦，不作讲解）

    消费端限流：是消费端每次从mq拉取限定个数的消息来消费


Consumer Ack 与 消费端限流 的配置文件（消费端配置）

spring:
  rabbitmq:
    host: 192.168.126.140
    port: 5672
    username: admin
    password: 123456
    virtual-host: /song
    listener:
      # RabbitMQ模式使用simple  simple支持事务的
      simple:
        # Consumer ACK机制：设置为手动签收
        acknowledge-mode: manual
        # 限流,配置3 表示消费端每次向MQ拉取最大3条消息
        prefetch: 3

消费者接收消息的代码

当消费者接收消息出错时

在这里插入图片描述

3.TTL

Time To Live，消息过期时间设置

  • 当消息到达存活时间后，还没有被消费，会被自动清除。

  • RabbitMQ可以对消息设置过期时间，也可以对整个队列（Queue）设置过期时间。

  • 设置队列过期时间使用参数：x-message-ttl，单位：ms(毫秒)，会对整个队列消息统一过期

  • 设置消息过期时间使用参数：expiration。单位：ms(毫秒)，当该消息在队列头部时（消费时），会单独判断这一消息是否过期。
    如果两者都进行了设置，以时间短的为准。

    管控台中设置队列TTL
    在这里插入图片描述

在列队代码中设置队列TTL

/**
     * 申明队列  持久化
     * @return 申明好的队列
     */
    @Bean("routingQueue_*")
    public Queue getQueue2(){
        return QueueBuilder.durable(TOPIC_QUEUE_KEY_ONE).withArgument("x-message-ttl",10000).build();
    }

在消息代码中设置队列TTL

@Test
    void test2() {
        rabbitTemplate.convertAndSend(RoutingModelConfig.ROUTING_EXCHANGE, "insert", "routing模式====routingKey:" +
                "insert", new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                message.getMessageProperties().setExpiration("5000");//设置消息过期时间为5秒
                return message;
            }
        });
    }

4.死信队列

死信队列，英文缩写：DLX 。Dead Letter Exchange（死信交换机），当消息成为Deadmessage后，可以被重新发送到另一个交换机，这个交换机就是DLX。

在这里插入图片描述

消息成为死信的三种情况：

  1. 队列消息长度到达限制；
  2. 消费者拒接消费消息，basicNack/basicReject,并且不把消息重新放入原目标队列,requeue=false；
  3. 原队列存在消息过期设置，消息到达超时时间未被消费；

管控台中设置死信队列

在这里插入图片描述


在代码中设置死信队列

 @Bean
    public Exchange exchangeDlx(){
        return ExchangeBuilder.topicExchange("dead_exchange").build();
    }

    @Bean
    public Queue queueNormalDlx(){
        return QueueBuilder.durable("queue_Normal_DLX")//正常队列的名称
                .withArgument("x-dead-letter-exchange","dead_exchange")//设置改队列的死信交换机
                .withArgument("x-dead-letter-routing-key","dlx.xf")//设置该队列的发送消息时指定的routingkey
                .withArgument("x-message-ttl",10000)//设置队列中消息的过期时间
                .withArgument("x-max-length",10).build();//设置队列的最大容量
    }

5.延迟队列

延迟队列，即消息进入队列后不会立即被消费，只有到达指定时间后，才会被消费。

但是可以使用：TTL+死信队列 组合实现延迟队列的效果。

shz_123
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
16-云原生监控体系-rabbitmq_exporter监控 RabbitMQ-[部署&Dashborad&告警规则实战]
qq_22648091的博客
05-28 395
下载地址 https://github.com/kbudde/rabbitmq_exporter/releases 中有适合各种平台的版本。如果选择使用 json 格式的配置文件进行配置，那需要给配置文件中出现的所有 key 配置值，因为没有默认值。github 地址 https://github.com/kbudde/rabbitmq_exporter。所有 metrics（golang/prometheus 除外）都以。可以是 json 格式的配置文件，也可以使用。风格的文件进行配置。
RabbitMQ
weixin_45638744的博客
09-26 424
MQ概述 MQ全称 Message Queue（消息队列），是在消息的传输过程中保存消息的容器。多用于分布式系统之间进行通信。 小结 MQ，消息队列，存储消息的中间件 分布式系统通信两种方式：直接远程调用 和 借助第三方 完成间接通信 发送方称为生产者，接收方称为消费者 MQ 的优势和劣势 优势 劣势 应用解耦 系统可用性降低 异步提速 系统复杂度提高 削峰填谷 一致性问题 MQ 的优势 应用解耦(提高系统容错性和可维护性) 异步提速(提升用户体验和系统吞吐量)
RabbitMQ详解
xiakewudi的专栏
08-08 448
介绍RabbitMQ前，有必须先了解一下AMQP协议。AMQP协议是一个高级抽象层消息通信协议，RabbitMQ是AMQP协议的实现。它主要包括以下组件：   1. Server(broker): 接受客户端连接，实现AMQP消息队列和路由功能的进程。 2. Virtual Host:其实是一个虚拟概念，类似于权限控制组，一个Virtual Host里面可以有若干个Exchange和Queu
rabbitMQ总结
liyanghao809433131的博客
03-30 452
rabbitMQ其实跟mysql等数据库差不多，都是需要通过url,账号，密码等去链接public static Connection getConnection() throws Exception { //定义连接工厂 ConnectionFactory factory = new ConnectionFactory(); //设置服务地址 factory.se...
微服务SpringCloud使用Turbine+RabbitMQ+Dashboard聚合监控数据
weixin_41660508的博客
03-17 726
在搭建springcloud微服务时，可以使用Turbine进行监控多个微服务，用dashboard展示数据。 不过在springboot1.5.x+springcloudEdgware版，使用消息中间间收集数据时会出现一个错误，导致Turbine整合rabbitmq项目无法运行。 错误信息：org.springframework.context.ApplicationContextExcep...
RabbitMQ使用规范
08-04
RabbitMQ使用规范 概述 RabbitMQ是基于AMQP高性能的开源消息队列服务器，可以用来实现消息的发布、订阅和routing。该规范旨在为RabbitMQ的使用提供一个统一的标准，确保RabbitMQ的使用符合公司的技术架构和安全要求...
RabbitMq使用手册
12-07
RabbitMq 使用手册 本文档为 RabbitMq 使用手册，介绍了 RabbitMq 的应用场景和开发指导。RabbitMq 是一个由 Erlang 开发的 AMQP（Advanced Message Queue）流行的开源消息队列系统。RabbitMq 的结构图如下： ...
RabbitMQ使用总结
03-13
内容为自己总结的RabbitMQ的经验，内容大致有：安装顺序、关键文件路径、常用命令、集群注意事项等，有用的请收入
rabbitMQ使用手册
06-03
RabbitMQ 使用手册 RabbitMQ 是一个流行的消息队列系统，它提供了多种交换机类型，每种交换机类型都有其特点和用途。下面我们将详细介绍 RabbitMQ 中的 Fanout Exchange、Direct Exchange 和 Topic Exchange。 ...
采用RabbitMQ收集数据监控-服务搭建
失忆๑的博客
09-05 314
一）在使用Turbine出现的问题 1.前面提到使用的Turbine进行数据监控的虽然能够解决的集群服务的监控的问题，但是的也存在问题，比如频繁的配置，我们需要在Turbine内配置需要监控的服务，这是非常不好的，假如有1000个服务呢？那配置起来就很繁琐了，而且配置的服务不易管理，增加了管理的难度。 2.在实际的应用中我们并不采用turbine进行集群服务的监控，而是采用在服务和Turbine之...
RabbitMQ添加监控
evasnowind的专栏
11-18 265
主要参考这篇官方文档： https://www.rabbitmq.com/monitoring.html 有如下接口： /api/overview GET请求，集群概况 /api/nodes/{node} GET请求，获取单个节点情况 /api/nodes GET请求，获取所有节点情况 /api/queues/{vhost}/{qname} GET请求，获取队列情况...
rabbitMq例子实现
GoodMorning_1992的博客
08-05 149
rabbitMq发送消息: rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGE_TOPIC_DQPT, RabbitMQConfig.QUEUE_QF_TOPUP, JSONObject.toJSONString(qbOrderVo)); rabbitMq初始化数据: public static final String EXCHANGE_TOPIC_DQPT = “exchange_topic_dqpt”; public static final S
『RabbitMQ』RabbitMQ高可用部署架构——镜像集群
老陈聊架构
05-29 2496
📣读完这篇文章里你能收获到 - RabbitMQ多种模式的区别及概念，手把手带你搭建高可用集群，接入HaProxy做高可用负载均衡，针对生产突发的异常场景提进行测试验证
RabbitMQ使用场景简单介绍
Sam_Deep_Thinking
09-15 2202
概述 Rabbit MQ的使用场景非常多，典型的场景主要分为下面几种： 跨系统的异步通信 基于pub/sub模型的事件驱动 削峰 下面主要是讲自己以前用过MQ的场景，简要的介绍一下。 秒杀订单之削峰 sec-kill-order独立集群的职责有三个： 接收所有瞬时涌入的秒杀请求，并以先进先出的方式将请求保存到队列里，将请求排队，起到削峰的作用； 提供拉取数据接口，给秒杀业务处理层使用...
RabbitMq图形界面创建队列操作步骤及控制台使用说明
qq_34041723的博客
04-12 4162
版本：RabbitMQ 3.9.7 控台台访问路径： http://localhost:15672/#/queues（1）输入自定义的队列名称 （2）其他输入参数为默认值即可 （3）点击【Add queue】创建队列成功 登录后，您将看到 RabbitMQ 的控制台界面。该界面将显示以下几个主要部分：Overview：概览页面提供了关于 RabbitMQ 节点、队列和交换机等的统计信息。Connections：连接页面提供了有关当前客户端连接的详细信息。Channels：通道页面提供了有关当前打开通道的详细
RabbitMq图形界面创建队列操作步骤
Thea_Li的博客
08-03 5040
RabbitMq
22-07-18 西安 RabbitMQ（02）spring整合RabbitMQ、SpringBoot整合RabbitMQ
m0_56799642的博客
07-18 571
由于这个方法需要的参数，我们可以推论出在，这三种模式下都是需要指定交换机的名字，类型。并且队列和交换机之间是有不同的绑定关系的。spring-rabbitmq.xml中配置监听器和队列名的绑定关系。/***参数1交换机名称*参数2路由键名（广播设置为空）*参数3发送的消息内容*/干什么作用的呢，就是在消费端在消费某一个队列的消息时会和一个监听器匹配，消息的内容可由该监听器拿到。指定要连接的MQ服务器，因为是简单模式，就只是创建队列（指定队列名）就好了。*参数3发送的消息内容。................
RabbitMQ使用
最新发布
08-26
RabbitMQ使用Erlang作为其底层开发语言，这使得它能够充分利用Erlang在并发处理和容错性方面的优势。 AMQP（Advanced Message Queuing Protocol）是一个开放标准的消息队列协议，用于在应用程序之间进行可靠的消息...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值