RabbitMq 使用说明

最新推荐文章于 2023-03-19 08:45:36 发布

chicheese

最新推荐文章于 2023-03-19 08:45:36 发布

阅读量541

点赞数

文章标签： rabbitmq java

本文链接：https://blog.csdn.net/qq_34828100/article/details/129425459

版权

1. 声明交换机和队列，以及交换机和队列绑定

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

@Slf4j
@Configuration
public class CeshiQueue {
    //延迟交换机fanout
    public static final String DELAY_EXCHANGE_NAME = "delay_exchange_name";
    //延时队列A
    public static final String DELAY_QUEUE_A_NAME = "delay_queue_a_name";
    //延时队列B
    public static final String DELAY_QUEUE_B_NAME = "delay_queue_b_name";
    //延时队列A路由Key
    public static final String DELAY_ROUTING_KEY_A_NAME = "delay_routing_key_a_name";
    //延时队列B路由Key
    public static final String DELAY_ROUTING_KEY_B_NAME = "delay_routing_key_b_name";

    //死信交换机
    public static final String DEAD_LETTER_EXCHANGE_NAME = "dead_letter_exchange_name";
    //死信队列A
    public static final String DEAD_LETTER_QUEUE_A_NAME = "dead_letter_queue_a_name";
    //死信队列B
    public static final String DEAD_LETTER_QUEUE_B_NAME = "dead_letter_queue_b_name";
    //死信队列A路由Key
    public static final String DEAD_LETTER_ROUTING_KEY_A_NAME = "dead_letter_routing_key_a_name";
    //死信队列B路由Key
    public static final String DEAD_LETTER_ROUTING_KEY_B_NAME = "dead_letter_routing_key_b_name";

    /**
     * 声明延时交换机 fanout
     *
     * @return
     */
    @Bean(DELAY_EXCHANGE_NAME)
    public Exchange DELAY_EXCHANGE_NAME() {
        // return ExchangeBuilder.fanoutExchange(DELAY_EXCHANGE_NAME).durable(true).build();
        return ExchangeBuilder.directExchange(DELAY_EXCHANGE_NAME).durable(true).build();
    }

    /**
     * 声明死信交换机 direct
     *
     * @return
     */
    @Bean(DEAD_LETTER_EXCHANGE_NAME)
    public Exchange DEAD_LETTER_EXCHANGE_NAME() {
        return ExchangeBuilder.directExchange(DEAD_LETTER_EXCHANGE_NAME).durable(true).build();
    }

    /**
     * 声明延时队列A
     * 并绑定死信交换机 和 死信队列A  根据路由key
     *
     * @return
     */
    @Bean(DELAY_QUEUE_A_NAME)
    public Queue DELAY_QUEUEA_NAME() {
        Map map = new HashMap();
        map.put("x-dead-letter-exchange", DEAD_LETTER_EXCHANGE_NAME);
        map.put("x-dead-letter-routing-key", DEAD_LETTER_QUEUE_A_NAME);
        //设置此队列延时时间 6秒
        map.put("x-message-ttl", 6000);
        return QueueBuilder.durable(DELAY_QUEUE_A_NAME).withArguments(map).build();
    }

    /**
     * 声明延时队列B
     * 并绑定死信交换机 和 死信队列B  根据路由key
     *
     * @return
     */
    @Bean(DELAY_QUEUE_B_NAME)
    public Queue DELAY_QUEUEB_NAME() {
        Map map = new HashMap();
        map.put("x-dead-letter-exchange", DEAD_LETTER_EXCHANGE_NAME);
        map.put("x-dead-letter-routing-key", DEAD_LETTER_QUEUE_B_NAME);
        //设置此队列延时时间 12秒
        map.put("x-message-ttl", 12000);
        return QueueBuilder.durable(DELAY_QUEUE_B_NAME).withArguments(map).build();
    }

    /**
     * 声明死信队列A
     *
     * @return
     */
    @Bean(DEAD_LETTER_QUEUE_A_NAME)
    public Queue DEAD_LETTER_QUEUEA_NAME() {
        return new Queue(DEAD_LETTER_QUEUE_A_NAME);
    }

    /**
     * 声明死信队列B
     *
     * @return
     */
    @Bean(DEAD_LETTER_QUEUE_B_NAME)
    public Queue DEAD_LETTER_QUEUEB_NAME() {
        return new Queue(DEAD_LETTER_QUEUE_B_NAME);
    }

    /**
     * 延时队列A绑定交换机
     *
     * @param queue
     * @param exchange
     * @return
     */
    @Bean
    public Binding delayQueueABinding(@Qualifier(DELAY_QUEUE_A_NAME) Queue queue, @Qualifier(DELAY_EXCHANGE_NAME) Exchange exchange) {
//        return BindingBuilder.bind(queue).to(exchange).with("").noargs();
        return BindingBuilder.bind(queue).to(exchange).with(DELAY_ROUTING_KEY_A_NAME).noargs();
    }

    /**
     * 延时队列B绑定交换机
     *
     * @param queue
     * @param exchange
     * @return
     */
    @Bean
    public Binding delayQueueBBinding(@Qualifier(DELAY_QUEUE_B_NAME) Queue queue, @Qualifier(DELAY_EXCHANGE_NAME) Exchange exchange) {
        // return BindingBuilder.bind(queue).to(exchange).with("").noargs();
        return BindingBuilder.bind(queue).to(exchange).with(DELAY_ROUTING_KEY_B_NAME).noargs();
    }
    /**
     * 死信队列A绑定交换机
     * @param queue
     * @param exchange
     * @return
     */
    @Bean
    public Binding deadLetterQueueABinding(@Qualifier(DEAD_LETTER_QUEUE_A_NAME)Queue queue, @Qualifier(DEAD_LETTER_EXCHANGE_NAME) Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with(DEAD_LETTER_QUEUE_A_NAME).noargs();
    }
    /**
     * 死信队列B绑定交换机
     * @param queue
     * @param exchange
     * @return
     */
    @Bean
    public Binding deadLetterQueueBBinding(@Qualifier(DEAD_LETTER_QUEUE_B_NAME)Queue queue, @Qualifier(DEAD_LETTER_EXCHANGE_NAME) Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with(DEAD_LETTER_QUEUE_B_NAME).noargs();
    }

}

2. 生产者发送消息

import com.core.rabbitmq.queue.CeshiQueue;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

@Slf4j
@RestController
@RequestMapping("/provider")
public class ProviderController {

    @Autowired
    RabbitTemplate rabbitTemplate;  //使用RabbitTemplate,这提供了接收/发送等等方法

    @GetMapping("/ceshiDelay1")
    public void ceshi() {
        System.out.println("provider ================" + new Date());
        //发送消息
        Map map = new HashMap();
        map.put("name", "老六");
        map.put("age", "18");
        //第一个参数发送给哪个交换机   第二个路由key  我们延时交换机是fanout所以路由key为空   第三个发送对象
//        rabbitTemplate.convertAndSend(CeshiQueue.DELAY_EXCHANGE_NAME, "", map);
        rabbitTemplate.convertAndSend(CeshiQueue.DELAY_EXCHANGE_NAME, CeshiQueue.DELAY_ROUTING_KEY_A_NAME, map
//                ,message -> {
//                    message.getMessageProperties().setExpiration(1000 * 6 + "");
//                    message.getMessageProperties().setDelay(6 * 1000);
//                    return message;
//                }););
        System.out.println("订单提交成功，请及时付款");
    }

3. 消费者消费消息

import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.handler.annotation.Headers;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.Date;
import java.util.Map;

/**
 * 小程序订单超时未支付关闭订单
 *
 * @date 2023/03/03
 */
@Component
@Slf4j
//@RequiredArgsConstructor
public class ConsumerListener {

 @RabbitListener(queues = CeshiQueue.DEAD_LETTER_QUEUE_A_NAME)
    public void process2(Map order, Message message, @Headers Map<String, Object> headers, Channel channel) {
        log.info("消費者 订单号消息", order);
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        log.info("订单 延时队列，消费者 订单号消息【{}】", order);
        log.info("订单 延时队列，消费者 订单号消息【{}】", headers);
        log.info("订单 延时队列，消费者 订单号消息【{}】", message);
        log.info("订单 延时队列，消费者 订单号消息【{}】", channel);
        log.info("订单 延时队列，消费者 订单号消息【{}】", deliveryTag);

        System.out.println(new Date() + "消费者 执行结束...." + message);
        try {      
            // 如果没有错误，则执行此步，表示成功签收; 手动签收，第一个参数表示消息的deliveryTag，第二个参数表示是否允许多条消息同时被签收
            channel.basicAck(deliveryTag, false);
        } catch (Exception e) {
            // requeue为true则重新入队列，否则丢弃或者进入死信队列  
            /**
             * @param deliveryTag 消息序号
             * @param multiple 是否批量处理（true:批量拒绝所有小于deliveryTag的消息；false:只处理当前消息）
             * @param requeue 拒绝是否重新入队列 （true:消息重新入队；false:禁止消息重新入队）
             */
            channel.basicReject(deliveryTag, false);
            log.error("订单  超时支付异常，系统重新关闭订单【{}】", deliveryTag);
        }
    }
}

注意：生产者发送延迟队列里，用延迟路由key，想要得到延迟效果，需要用死信队列来监听，如果用延迟队列监听就得不到延迟效果，延迟队列就会立即受到消息(初学者会遇到的坑)。

4. BasicReject

拒收，是接收端在收到消息的时候响应给RabbitMQ服务的一种命令，告诉服务器不应该由我处理，或者拒绝处理，扔掉。接收端在发送reject命令的时候可以选择是否要重新放回queue中。如果没有其他接收者监控这个queue的话，要注意一直无限循环发送的危险。

BasicDeliverEventArgs ea = (BasicDeliverEventArgs)consumer.Queue.Dequeue();
channel.BasicReject(ea.DeliveryTag, false);

BasicReject方法第一个参数是消息的DeliveryTag，对于每个Channel来说，每个消息都会有一个DeliveryTag，一般用接收消息的顺序来表示：1,2,3,4 等等。第二个参数是是否放回queue中，requeue。

BasicReject一次只能拒绝接收一个消息，而BasicNack方法可以支持一次0个或多个消息的拒收，并且也可以设置是否requeue。

channel.BasicNack(3, true, false);

在第一个参数DeliveryTag中如果输入3，则消息DeliveryTag小于等于3的，这个Channel的，都会被拒收。

5. RabbitMQ 消息确认机制ACK

ack 机制保证的是broker和消费者之间的可靠性

ack 表示的是消费端收到消息后的确认方式，有三种确认方式

        自动确认：acknowledge="none"（默认）
        手动确认：acknowledge="manual"
        根据异常情况确认：acknowledge="auto"（这种方式使用麻烦，不作讲解）
自动确认的解释：

当消息一旦被 Consumer 接收到，则自动确认收到，并将相应消息从 RabbitMQ 的消息缓存中移除
手动确认的解释：

在实际业务处理中，很可能消费端收到消息后业务处理出现异常，那么该消息就会丢失；
如果设置了手动确认方式，则需要在业务处理成功后，调用 channel.basicAck() 手动签收；如果出现异常，则调用 channel.basicNack()方法，让 broker 自动重新发送消息给消费端。

rabbitMQ消息中间件的延时队列以及死信队列的使用和应用场景_出一个场景问mq的用法(延迟、死信)

rabbitmq-BasicReject

RabbitMQ ACK消息确认机制快速入门

chicheese

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
RabbitMq 使用说明

拒收，是接收端在收到消息的时候响应给RabbitMQ服务的一种命令，告诉服务器不应该由我处理，或者拒绝处理，扔掉。BasicReject方法第一个参数是消息的DeliveryTag，对于每个Channel来说，每个消息都会有一个DeliveryTag，一般用接收消息的顺序来表示：1,2,3,4 等等。在第一个参数DeliveryTag中如果输入3，则消息DeliveryTag小于等于3的，这个Channel的，都会被拒收。ack 表示的是消费端收到消息后的确认方式，有三种确认方式。
复制链接

扫一扫