Rabbit高级特性

最新推荐文章于 2024-04-27 20:56:25 发布
最新推荐文章于 2024-04-27 20:56:25 发布
阅读量496 收藏
点赞数
分类专栏： rabbitmq
  1. 在使用Rabbit时，可能会遇到投递失败的情况，所以我门需要知道消息是否发送成功。
    1.1Confirm消息确认机制：
    在这里插入图片描述
    如何实现Confirm确认消息？

第一步：在channel上开启确认模式：channel.confirmSelect()

第二步：在channel上添加监听：addConfirmListener，监听成功和失败的返回结果，

根据具体的结果对消息进行重新发送、或者记录日志等后续处理。
rabbitmq 整个消息投递的路径为：

producer—>rabbitmq broker—>exchange—>queue—>consumer

消息从 producer 到 exchange 则会返回一个 confirmCallback 。

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

我们将利用这两个 callback 控制消息的可靠性投递。
1.2：使用Spring实现：
配置省略。
Producer开启确认模式：
1，在ConnectionFactory中设置 publisher-confirms=“true”
2，给RabbitTemplate设置ConfirmCallback回调函数。
代码：

@RunWith(SpringRunner.class)
@ContextConfiguration(locations = "classpath:spring_rabbitmq.xml")
public class Test {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @org.junit.Test
    public void test1()throws  Exception{
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback(){
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                if (ack){
                    System.out.println("成功");
                }else {
                    System.out.println("失败"+cause);
                }
            }

        });
        rabbitTemplate.convertAndSend("spring_exchange_confirm","confirm","鲨鱼的手臂");
        Thread.sleep(100);
    }

ConSumer代码：

<rabbit:listener-container connection-factory="connectionFactory" acknowledge="manual">
        <rabbit:listener ref="springConsumer" queue-names="spring_queue_confirm"></rabbit:listener>
    </rabbit:listener-container>

设置确认消息的方式为手动acknowledge=“manual”

添加ChannelAwareMessageListener监听

@Component
public class springConsumer implements ChannelAwareMessageListener {
    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try {
            System.out.println(new String(message.getBody()));
            channel.basicAck(deliveryTag,true);
        }catch (Exception e){
            e.printStackTrace();
            System.out.println("错了吧");
           channel.basicNack(deliveryTag,true,true);
        }
    }

}

使用自动确认，在实际开发中可能会出现，消息被确认接收之后但是业务代码出现了问题，消息就会丢失。但是使用手动确认，如果业务代码出现了问题，可以调用channel.basicNack()方法，让其自动重新发送消息。

  1. 回退机制：return listener
    当我门无法将消息推送到队列，就需要监听这种不可达消息。
    在这里插入图片描述
    代码：

在这里插入图片描述
Producer代码：

 @org.junit.Test
    public void test2()throws  Exception{
        rabbitTemplate.setMandatory(true);
        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
            @Override
            public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                System.out.println(replyText);
                System.out.println(new String(message.getBody()));
                System.out.println(replyCode);
            }
        });

        rabbitTemplate.convertAndSend("spring_exchange_confirm","confirmss","鲨鱼的手臂2");
        Thread.sleep(100);
    }

配置文件中的ConnectionFactory 设置publisher-returns=“true”，开启回退机制。
测试代码中设置 rabbitTemplate.setMandatory(true);
（设置Exchange处理消息的模式：默认为false，表示如果没有到达队列就会将消息舍弃，设置为true，表示如果没有到达队列会将消息发送到ReturnCallBack）。

  1. Consumer限流机制：确保ack机制为manual（手动确认机制）
    Consumer端配置文件
    在监听器添加prefetch=“1”（表示每次只取一个）
 <rabbit:listener-container connection-factory="connectionFactory" acknowledge="manual" prefetch="1">
        <rabbit:listener ref="springConsumer" queue-names="spring_queue_confirm"></rabbit:listener>
    </rabbit:listener-container>
  1. TTL(Time To Live):过期时间：
    Producer将消息推送至队列中，超过时间没有被Consumer端取出，就会被自动清除。（应用于订单支付）

代码：
Producer配置文件：

<rabbit:queue id="spring_queue_confirm_ttl" name="spring_queue_confirm_ttl" auto-declare="true">
        <rabbit:queue-arguments>
            <entry key="x-message-ttl" value="10000" value-type="java.lang.Integer"></entry>
        </rabbit:queue-arguments>
    </rabbit:queue>
    <rabbit:topic-exchange name="spring_exchange_confirm_ttl" auto-declare="true">
            <rabbit:bindings>
               <rabbit:binding pattern="ttl.*" queue="spring_queue_confirm_ttl"></rabbit:binding>
            </rabbit:bindings>
    </rabbit:topic-exchange>

给队列设置参数：x-message-ttl（注意参数不是随意设置具体参考RabbitMQ后台客户端。）
表示设置过期时间为10s。
在这里插入图片描述
Producer测试代码：

 @org.junit.Test
    public void test4() throws Exception {
        rabbitTemplate.setMandatory(true);
        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
            @Override
            public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                System.out.println(new String(message.getBody()));
                System.out.println(replyCode);
                System.out.println(replyText);
                System.out.println(exchange);
                System.out.println(routingKey);
            }
        });
        rabbitTemplate.convertAndSend("spring_exchange_confirm_ttl", "ttl.huhu", "鲨鱼的手臂4");
        Thread.sleep(100);
    }
  1. 死信队列DeadLetter Exchange(DLE)
    6.1当消息消息在队列中到了过期时间，会发送到另一个交换机上，这个交换机被称为死信队列。
    6.2消息成为死信的三种情况：
    1，到了存活时间消息未被消费；
    2，消费者拒接消费消息，basicNack/basicReject,并且不把消息重新放入原目标队列,requeue=false；
    3，队列消息长度到达限制；
<!--`````````````````创建死信队列``````````````````-->
    <rabbit:queue  id="spring_test_queue_dlx" name="spring_test_queue_dlx" auto-declare="true">
        <rabbit:queue-arguments>
            <entry key="x-dead-letter-exchange" value="spring_exchange_dlx"></entry>
            <entry key="x-dead-letter-routing-key" value="dlx.ddd"></entry>
            <entry key="x-max-length" value="10" value-type="java.lang.Integer"></entry>
        </rabbit:queue-arguments>
    </rabbit:queue>
    <rabbit:topic-exchange name="spring_test_exchange_dlx" auto-declare="true">
        <rabbit:bindings>
            <rabbit:binding pattern="dlx.*" queue="spring_test_queue_dlx"></rabbit:binding>
        </rabbit:bindings>
    </rabbit:topic-exchange>

    <rabbit:queue  id="spring_queue_dlx" name="spring_queue_dlx" auto-declare="true">

    </rabbit:queue>
    <rabbit:topic-exchange name="spring_exchange_dlx" auto-declare="true">
        <rabbit:bindings>
            <rabbit:binding pattern="dlx.*" queue="spring_queue_dlx"></rabbit:binding>
        </rabbit:bindings>
    </rabbit:topic-exchange>

解析：创建两个正常队列跟交换机，把一个交换机跟队列作为死信交换机跟死信队列。
正常队列绑定死信交换机：

 <rabbit:queue-arguments>
            <entry key="x-dead-letter-exchange" value="spring_exchange_dlx"></entry>
            <entry key="x-dead-letter-routing-key" value="dlx.ddd"></entry>
            <entry key="x-max-length" value="10" value-type="java.lang.Integer"></entry>
        </rabbit:queue-arguments>

配置表示如果队列长度到10，后面的消息就会进入死信交换机。
producer测试代码：

@org.junit.Test
    public void test5()throws Exception{
        rabbitTemplate.setMandatory(true);
        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
            @Override
            public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                System.out.println(new String(message.getBody()));
                System.out.println(replyCode);
                System.out.println(replyText);
                System.out.println(exchange);
                System.out.println(routingKey);
            }
        });
        for (int i = 0; i <20; i++) {
            rabbitTemplate.convertAndSend("spring_test_exchange_dlx", "dlx.huhu", "鲨鱼的手臂5");
        }

7.延时队列
例如用于订单系统中超过30分钟就会取消订单。
由于Rabbit中没有提供延时队列功能，我们可以采取TTL+死信队列组合的方式实现。
代码：
Producer配置文件：

 <!--````````````````创建延时队列`````````````````````-->
    <rabbit:queue  id="spring_test_queue_dlx_TTL" name="spring_test_queue_dlx_TTL" auto-declare="true">
        <rabbit:queue-arguments>
            <entry key="x-dead-letter-exchange" value="spring_exchange_dlx_TTL"></entry>
            <entry key="x-dead-letter-routing-key" value="dlx.ddd"></entry>
            <entry key="x-message-ttl" value="10000" value-type="java.lang.Integer"></entry>
        </rabbit:queue-arguments>
    </rabbit:queue>
    <rabbit:topic-exchange name="spring_test_exchange_dlx" auto-declare="true">
        <rabbit:bindings>
            <rabbit:binding pattern="dlx.*" queue="spring_test_queue_dlx_TTL"></rabbit:binding>
        </rabbit:bindings>
    </rabbit:topic-exchange>

    <rabbit:queue  id="spring_queue_dlx_TTL" name="spring_queue_dlx_TTL" auto-declare="true">

    </rabbit:queue>
    <rabbit:topic-exchange name="spring_exchange_dlx_TTL" auto-declare="true">
        <rabbit:bindings>
            <rabbit:binding pattern="dlx.*" queue="spring_queue_dlx_TTL"></rabbit:binding>
        </rabbit:bindings>
    </rabbit:topic-exchange>

Consumer配置文件代码：

  <rabbit:listener-container connection-factory="connectionFactory" acknowledge="manual">
        <rabbit:listener ref="springConsumer" queue-names="spring_queue_dlx_TTL"></rabbit:listener>
    </rabbit:listener-container>

注意的是，延时队列的效果一定要监听死信队列。

  1. RabbitAdmin的应用：
    ① 底层实现就是从Spring容器中获取Exchange，Bingding，Routingkey以及Queue的@bean声明
    ② 使用RabbitAdmin的execute方法执行对应的声明，修改和删除等一系列MQ的操作者
    比如：添加一个交换机，删除一个绑定， 清空一个队列里面的消息等等
    代码演示：
    新建一个项目pom文件起步配置：
<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>          
        </dependency>
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>          
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

新建程序入口：

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}

新建配置类

@Configuration
@ComponentScan({"com.xxx.*"})
public class RabbitMQConfig {
    @Bean
    public ConnectionFactory connectionFactory() {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setAddresses("localhost:5672");
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("my_vhost");
        return connectionFactory;
    }

    @Bean
    public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
        RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory);
        rabbitAdmin.setAutoStartup(true);
        return rabbitAdmin;

    }
}

新建测试类

@RunWith(SpringRunner.class)
@SpringBootTest
public class ApplicationTests {
    @Autowired
    private RabbitAdmin rabbitAdmin;
    @Test
    public void test1(){
        //声明交换机
        rabbitAdmin.declareExchange(new DirectExchange("springboot.test.direct",true,false));
        rabbitAdmin.declareExchange(new DirectExchange("springboot.test.topic",true,false));
        rabbitAdmin.declareExchange(new DirectExchange("springboot.test.fanout",true,false));
        //声明队列
        rabbitAdmin.declareQueue(new Queue("springboot.test.direct.queue",true));

        rabbitAdmin.declareQueue(new Queue("springboot.test.topic.queue",true));

        rabbitAdmin.declareQueue(new Queue("springboot.test.fanout.queue",true));
        //交换机与队列进行绑定

        rabbitAdmin.declareBinding(BindingBuilder.bind(new Queue("springboot.test.direct.queue",true)).to(new DirectExchange("springboot.test.direct",true,false)).with("direct"));
        rabbitAdmin.declareBinding(BindingBuilder.bind(new Queue("springboot.test.topic.queue",true)).to(new DirectExchange("springboot.test.topic",true,false)).with("user.#"));
        rabbitAdmin.declareBinding(
                BindingBuilder.bind(new Queue("springboot.test.fanout.queue",true))
                        .to(new FanoutExchange("springboot.test.fanout",true,false))
        );
    }
}

使用 SpringAMQP 去声明，就需要使用SpringAMQP 的如下模式，即声明 Bean 方式

/**  
     * 针对消费者配置  
     * 1. 设置交换机类型  
     * 2. 将队列绑定到交换机  
        FanoutExchange: 将消息分发到所有的绑定队列，无routingkey的概念  
        HeadersExchange ：通过添加属性key-value匹配  
        DirectExchange:按照routingkey分发到指定队列  
        TopicExchange:多关键字匹配  
     */  
    @Bean  
    public TopicExchange exchange001() {  
        return new TopicExchange("topic001", true, false);  
    }  

    @Bean  
    public Queue queue001() {  
        return new Queue("queue001", true); //队列持久  
    }  
    
    @Bean  
    public Binding binding001() {  
        return BindingBuilder.bind(queue001()).to(exchange001()).with("spring.*");  
    }  
    
    @Bean  
    public TopicExchange exchange002() {  
        return new TopicExchange("topic002", true, false);  
    }  
    
    @Bean  
    public Queue queue002() {  
        return new Queue("queue002", true); //队列持久  
    }
    
    @Bean  
    public Binding binding002() {  
        return BindingBuilder.bind(queue002()).to(exchange002()).with("rabbit.*");  
    } 
    
    @Bean  
    public Queue queue003() {  
        return new Queue("queue003", true); //队列持久  
    }
    
    @Bean  
    public Binding binding003() {  
        return BindingBuilder.bind(queue003()).to(exchange001()).with("mq.*");  
    } 
    
    @Bean  
    public Queue queue_image() {  
        return new Queue("image_queue", true); //队列持久  
    }
    
    @Bean  
    public Queue queue_pdf() {  
        return new Queue("pdf_queue", true); //队列持久  
    }
  1. RabbitMQ与SpringBoot整合
    Producer：
    pom文件起步依赖：
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
    </parent>

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

yml配置文件代码

spring:
  rabbitmq:
    host: 139.196.37.163
    port: 5672
    username: admin
    password: admin
    virtual-host: my_vhost

配置类：

    public static final String EXCHANGE_NAME = "boot_topic_exchange";
    public static final String QUEUE_NAME = "boot_queue";
    //交换机
    @Bean
    public Exchange bootExchange(){
        return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
    }
    //队列
    @Bean
    public Queue bootQueue(){
        return QueueBuilder.durable(QUEUE_NAME).build();
    }
    //绑定交换机与队列
    //noargs():表示不指定参数
    @Bean
    public Binding bootBinding(Queue bootQueue,Exchange bootExchange){
        return BindingBuilder.bind(bootQueue).to(bootExchange).with("boot.*").noargs();
    }

测试类（发送消息）：

@RunWith(SpringRunner.class)
@SpringBootTest
public class ProducerTest {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Test
    public void test1(){
        rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGE_NAME,"boot.haha","鲨鱼的手臂");
    }
}

Consumer（消费者代码）
pom.xml,yml配置文件跟Producer一样。
监听器类：

@Component
public class RabbimtMQListener{
    @RabbitListener(queues = "boot_queue")
    public void listBootQueue(Message message){
        System.out.println(new String(message.getBody()));
    }
}
  1. 百分百消息投递
    我们在工作时难免会遇到消息投递，而且需要保证消息不能丢失。
    在这里插入图片描述
    如图所示，在发送消息时，不像之前，直接编辑好消息就发送出去，在发送消息出去前做一些操作。
    Step 1： 首先把消息信息(业务数据）存储到数据库中，紧接着，我们再把这个消息记录也存储到一张消息记录表里（或者另外一个同源数据库的消息记录表）

Step 2：发送消息到MQ Broker节点（采用confirm方式发送，会有异步的返回结果）

Step 3、4：生产者端接受MQ Broker节点返回的Confirm确认消息结果，然后进行更新消息记录表里的消息状态。比如默认Status = 0 当收到消息确认成功后，更新为1即可！

Step 5：但是在消息确认这个过程中可能由于网络闪断、MQ Broker端异常等原因导致 回送消息失败或者异常。这个时候就需要发送方（生产者）对消息进行可靠性投递了，保障消息不丢失，100%的投递成功！（有一种极限情况是闪断，Broker返回的成功确认消息，但是生产端由于网络闪断没收到，这个时候重新投递可能会造成消息重复，需要消费端去做幂等处理）所以我们需要有一个定时任务，（比如每5分钟拉取一下处于中间状态的消息，当然这个消息可以设置一个超时时间，比如超过1分钟 Status = 0 ，也就说明了1分钟这个时间窗口内，我们的消息没有被确认，那么会被定时任务拉取出来）

Step 6：接下来我们把中间状态的消息进行重新投递 retry send，继续发送消息到MQ ，当然也可能有多种原因导致发送失败

Step 7：我们可以采用设置最大努力尝试次数，比如投递了3次，还是失败，那么我们可以将最终状态设置为Status = 2 ，最后 交由人工解决处理此类问题（或者把消息转储到失败表中）。

-- ----------------------------
-- Table structure for broker_message_log
-- ----------------------------
DROP TABLE IF EXISTS `broker_message_log`;
CREATE TABLE `broker_message_log` (
  `message_id` varchar(255) NOT NULL COMMENT '消息唯一ID',
  `message` varchar(4000) NOT NULL COMMENT '消息内容',
  `try_count` int(4) DEFAULT '0' COMMENT '重试次数',
  `status` varchar(10) DEFAULT '' COMMENT '消息投递状态 0投递中，1投递成功，2投递失败',
  `next_retry` timestamp NOT NULL DEFAULT '0000-00-00 00:00:00' ON UPDATE CURRENT_TIMESTAMP COMMENT '下一次重试时间',
  `create_time` timestamp NOT NULL DEFAULT '0000-00-00 00:00:00' ON UPDATE CURRENT_TIMESTAMP,
  `update_time` timestamp NOT NULL DEFAULT '0000-00-00 00:00:00' ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (`message_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Table structure for t_order
-- ----------------------------
DROP TABLE IF EXISTS `t_order`;
CREATE TABLE `t_order` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL,
  `message_id` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2018091102 DEFAULT CHARSET=utf8;
  1. 消息幂等性
    幂等性指一次和多次请求某一个资源，对于资源本身应该具有同样的结果。也就是说，其任意多次执行对资源本身所产生的影响均与一次执行的影响相同。
    比如我们扫码付款时，由于网卡，付款失败后又扫了一次码（码没有刷新），这样多次扫，我们会担心会不会多次扣款，但是设置消息幂等性后就不会出现多次扣款的事情。
    消息幂等性保障 乐观锁机制。
    我们可以在提交付款数据时添加一个版本属性。
    例如：`
id=1,money=500,version=1

消费者接收到

id=1,money=500,version=1

第一次执行SQL语句

第一次执行：version=1
update account set money = money - 500 , version = version + 1
where id = 1 and version = 1

第二次执行：version=2

第二次执行：version=2
update account set money = money - 500 , version = version + 1
where id = 1 and version = 1
cc成
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMQ高级
weixin_46949955的博客
08-26 507
1.1 消息可靠性投递 在使用 RabbitMQ 的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景。RabbitMQ 为我们提供了两种方式用来控制消息的投递可靠性模式。 confirm 确认模式 return 退回模式 rabbitmq 整个消息投递的路径为： ​ producer —> rabbitmq broker —> exchange —> queue —> consumer 消息从 producer 到 exchange 则会返回一个 confi
rabbit-scanner:带有HTML5 JavaScript支持的漏洞扫描程序
05-10
Watchrabbit-扫描仪 具有HTML5 / JavaScript支持的漏洞扫描程序。 由提供技术支持 当前的版本 2015年5月24日发布Rabbit-scanner 0.8.1 ！ 应该会很快出现在Maven中央。 正在运行的扫描仪 为了运行扫描程序，请向该应用程序的所有模块添加依赖关系，并使用@EnableSupervisiorService和@EnableAttackerService注释您的配置类。 然后，如果要实施自定义结果处理策略，请实施ResultProcessingStrategy 。 最后一步，使用OrderService将站点添加到测试中。 建筑工程 为了建立项目，请运行mvn clean install 。
SpringBoot+RabbitMQ，保证消息100%投递成功并被消费
zzy7075的专栏
07-02 1270
一、先扔一张图 说明: 本文涵盖了关于RabbitMQ很多方面的知识点, 如: 消息发送确认机制 消费确认机制 消息的重新投递 消费幂等性, 等等 这些都是围绕上面那张整体流程图展开的, 所以有必要先贴出来, 见图知意 二、实现思路 简略介绍163邮箱授权码的获取 编写发送邮件工具类 编写RabbitMQ配置文件 生产者发起调用 消费者发送邮件 定时任务定时拉取投递失败的消息, 重新投递 各种异常情况的测试验证 拓展: 使用动态代理实现消费端幂等性验证和消息确认(ack.
RabbitMQ通配符模式
最新发布
记录知识点的博客
04-27 1471
RabbitMQ通配符模式
RabbitMQ的简单使用
andews的博客
07-16 325
RabbitMQ RabbitMQ是一个基于AMQP(Advance Message Queue Protocol)通信协议的一种消息队列技术 JMS(Java Message Service) 是Java程序操作MQ的API规范，jms是在java应用API层面定义的一个标准，而AMQP为协议层定义的标准（具备跨语言的特性）。 RabbitMQ的基本操作 1. 导入rabbitMQ的依赖Jar包 2. 利用ConnectionFactory对象创建Connection对象（ConnectionFacto
RabbitMQ高级特性
qi341500的博客
03-25 1556
RabbitMQ高级特性 1、消息的可靠投递 2、Consumer Ack 3、消费端限流 4、TTL（存活时间/过期时间） 5、死信队列 6、延迟队列 7、日志与监控 8、消息追踪 9、消息可靠性保障--消息补偿 10、RabbitMQ集群搭建
rabbit的初次体验
06-16
在IT行业中，消息队列（Message Queue）是一种重要的中间件技术，它主要用于解耦系统间...在进一步学习中，还可以探索RabbitMQ的高级特性，如死信队列、消息确认机制、集群和高可用性等，以提升系统的稳定性和灵活性。
Rabbit Framework for MVC使用入门
06-05
**Rabbit Framework for MVC 使用入门** Rabbit Framework for MVC 是一个专门为构建基于模型-视图...继续深入学习，你会发现更多的高级特性，如过滤器、视图组件、依赖注入等，这些都将使你的MVC开发更加高效和便捷。
Spring高级之注解驱动开发视频教程
11-05
从应用场景分析，到基本用法的入门案例，再到高级特性的分析及使用，最后是执行原理的源码分析。让学生通过学习本套课程不仅可以知其然，还可以知其所以然。最终通过一个综合案例，实现灵活运用Spring框架中的各个...
rabbit安装及配置
04-30
总而言之，"rabbit安装及配置"涵盖了从安装基础到高级特性的全面知识，包括RabbitMQ的安装、配置文件详解、插件管理以及消息队列的基本原理。通过深入理解和实践，我们可以利用RabbitMQ构建可靠的分布式系统，实现...
交换机冗余环境优化之stp高级特性.doc
02-03
在实际操作中，可以通过命令行配置交换机上的这些高级特性，例如在接入端口启用PortFast，在上行链路上启用UplinkFast，以及全局启用BackboneFast，以提升网络的稳定性和响应速度。 总的来说，交换机冗余环境的优化...
rabbit_gra完整实例源码，测试可以使用.rar
06-15
【标题】"rabbit_gra完整实例源码，测试...总的来说，这个压缩包提供了从零开始学习和实践RabbitMQ的机会，涵盖了消息队列系统的基本使用和高级特性。对于想要提升消息中间件技能的开发者来说，这是一个宝贵的资源。
rabbit安装包.zip
06-24
**RabbitMQ 深度解析** RabbitMQ 是一款高度可扩展且极其灵活的消息队列服务，基于 Erlang 语言构建，它在分布式系统中...从安装到使用，再到高级特性，理解并熟练掌握 RabbitMQ 是提升系统性能和稳定性的重要步骤。
deHack-rabbit
03-31
通过解决每一个"德哈克兔"挑战，用户不仅可以提高编程技能，还能加深对JavaScript特性和最佳实践的理解。此外，这种互动式学习方式也有助于培养解决问题和调试代码的能力，这是任何程序员都必不可少的技能。
交换机的高级特性---端口镜像功能.doc
12-16
【交换机的高级特性——端口镜像功能】 在当今信息化社会，网络成为了信息交互的主要载体，无论是政府、金融机构的敏感数据，还是个人日常生活中的各种信息，都离不开网络的传输。随着大数据时代的到来，对网络数据...
rabbit_demo.rar
05-12
在实际项目中，还可以根据需要配置多个队列、交换机和绑定关系，以及利用RabbitMQ的其他高级特性，如工作队列、延迟队列、死信队列等，来实现更复杂的业务需求。 在"rabbit_demo.rar"的示例中，可能包含了完整的...
RabbitMQ如何实现延迟队列
weixin_44273388的博客
04-20 8750
rabbitmq实现延迟队列的方法
RabbitMQ消息的可靠性投递和接收
u010689849的博客
04-04 688
在rabbitmq中，作为消息的发送方希望杜绝任何的消息丢失或投递失败的场景。RabbitMQ为我们提供了两种方式来控制消息的投递可靠性模式。 confirm 确认模式 return 回退模式 rabbitmq中消息发送路径为：producer 》 borker 》exchange 》 queue 》consumer 消息从producer到exchange会返回一个confirmCallback回调函数（不管发送成功或失败都会回调，只是返回的值是false和true的区别），从exchange到q.
rabbitmq使用详解
love_yr的博客
12-17 2102
rabbitmq使用详解
怎样学Rabbit MQ
03-30
学习 Rabbit MQ 可以按照以下步骤： 1. 了解 Rabbit MQ 的基本概念，例如消息队列、生产者、消费者、交换机、队列等。 2. 下载并安装 Rabbit MQ。 3. 掌握 Rabbit MQ 的命令行工具，例如 Rabbit MQ 的管理工具 rabbitmqctl 和 Rabbit MQ 的 Web 界面管理工具 Rabbit MQ Management Console。 4. 使用 Rabbit MQ 的客户端库，例如 Rabbit MQ 的 Java 客户端库、Python 客户端库等。 5. 编写 Rabbit MQ 的生产者和消费者代码，例如使用 Java 客户端库编写 Rabbit MQ 的生产者和消费者代码。 6. 学习 Rabbit MQ 的高级特性，例如 Rabbit MQ 的消息确认机制、消息持久化等。 7. 学习 Rabbit MQ 的集群和高可用性，例如 Rabbit MQ 的镜像队列机制。 8. 学习 Rabbit MQ 的安全措施，例如 Rabbit MQ 的用户权限管理和 SSL/TLS 加密等。 9. 学习 Rabbit MQ 的性能优化，例如 Rabbit MQ 的性能监控和调优。 10. 参与 Rabbit MQ 的社区，例如参与 Rabbit MQ 的邮件列表、论坛、GitHub 等，并学习其他人的经验和技巧。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值