RabbitMQ高级学习

最新推荐文章于 2023-10-25 22:34:02 发布

林园857

最新推荐文章于 2023-10-25 22:34:02 发布

阅读量117

点赞数 1

文章标签： java

本文链接：https://blog.csdn.net/weixin_44464850/article/details/119563160

版权

springboot整合rabbitMQ

1.提供者

配置文件application.yml

server:
  port: 8001
spring:
  application:
    name: rabbitmq-provider
  rabbitmq:
    host: localhost
    port: 5672
    username: admin
    password: 123456
    virtual-host: admin

所用到的依赖

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
            <version>2.1.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.1.6.RELEASE</version>
        </dependency>
    </dependencies>

开始配置队列的信息

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
@Configuration
public class DirectRabbitConfig {
 
    //队列 起名：TestDirectQueue
    @Bean
    public Queue TestDirectQueue() {
        // durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
        // exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
        // autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
        //   return new Queue("TestDirectQueue",true,true,false);
 
        //一般设置一下队列的持久化就好,其余两个就是默认false
        return new Queue("TestDirectQueue",true);
    }
 
    //Direct交换机 起名：TestDirectExchange
    @Bean
    DirectExchange TestDirectExchange() {
      //  return new DirectExchange("TestDirectExchange",true,true);
        return new DirectExchange("TestDirectExchange",true,false);
    }
 
    //绑定  将队列和交换机绑定, 并设置用于匹配键：TestDirectRouting
    @Bean
    Binding bindingDirect() {
        return BindingBuilder.bind(TestDirectQueue()).to(TestDirectExchange()).with("TestDirectRouting");
    }
    
    //后面需要
    @Bean
    DirectExchange lonelyDirectExchange() {
        return new DirectExchange("lonelyDirectExchange");
    }
 
}

进行消息推送

@RestController
public class SendMessageController {

    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    
     @GetMapping("/sendDirectMessage")
    //也可以使用注解的方式
//    @RabbitListener(bindings = @QueueBinding(value = @Queue()))
    public String sendDirectMessage(){
        String messageId=String.valueOf(UUID.randomUUID());

        String messageData="test message,hello";
        String createTime= LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));

        Map<String, Object> map = new HashMap<>();
        map.put("messageId",messageId);
        map.put("messageData",messageData);
        map.put("createTime",createTime);

        rabbitTemplate.convertAndSend("TestDirectExchange","TestDirectRouting",map);

        return "上传成功";
    }
   
}

2.消费者

server:
  port: 8002
spring:
  application:
    name: rabbitmq-consumer
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: admin
    password: 123456
    virtual-host: admin

所用到的jar

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
            <version>2.1.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.1.6.RELEASE</version>
        </dependency>
    </dependencies>

开始配置队列的信息

@Configuration
public class DirectRabbitConfig {

    @Bean
    public Queue TestDirectQueue(){
        return new Queue("TestDirectQueue",true);
    }

    @Bean
    DirectExchange TestDirectExchange(){
        return new DirectExchange("TestDirectQueue",true,false);
    }

    @Bean
    Binding bindingDirect(){
        return BindingBuilder.bind(TestDirectQueue()).to(TestDirectExchange()).with("TestDirectRouting");
    }
}

监听队列信息

@Component
@RabbitListener(queues = "TestDirectQueue")//监听的队列名称 TestDirectQueue
public class DirectReceiver {
 
    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("DirectReceiver消费者收到消息  : " + testMessage.toString());
    }
 
}

使用TopicExchange主题交换机

创建TopicRabbitConfig.java

package com.it.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class TopicRabbitConfig {

    public final static String man="topic.man";
    public final static String woman="topic.woman";

    @Bean
    public Queue firstQueue(){
        return new Queue(TopicRabbitConfig.man);
    }

    @Bean
    public Queue secondQueue(){
        return new Queue(TopicRabbitConfig.woman);
    }

    @Bean
    TopicExchange exchange(){
        return new TopicExchange("topicExchange");
    }

    @Bean
    Binding bindingExchangeMessage(){
        return BindingBuilder.bind(firstQueue()).to(exchange()).with(man);
    }

    @Bean
    Binding bindingExchangeMessage2(){
        return BindingBuilder.bind(secondQueue()).to(exchange()).with("topic.#");
    }

}

消息推送

   @GetMapping("/sendTopicMessage1")
    public String sendTopicMessage1(){
        String messageId=String.valueOf(UUID.randomUUID());
        String messageData="message: M A N";
        String createTime=LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));

        Map<String,Object>map=new HashMap<>();
        map.put("messageId",messageId);
        map.put("messageData",messageData);
        map.put("createTime",createTime);

        rabbitTemplate.convertAndSend("topicExchange","topic.man",map);
        return "MAN上传成功";
    }

    @GetMapping("/sendTopicMessage2")
    public String sendTopicMessage2(){
        String messageId=String.valueOf(UUID.randomUUID());
        String messageData="message: W O M A N";
        String createTime=LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));

        Map<String,Object>map=new HashMap<>();
        map.put("messageId",messageId);
        map.put("messageData",messageData);
        map.put("createTime",createTime);

        rabbitTemplate.convertAndSend("topicExchange","topic.woman",map);
        return "WOMAN上传成功";
    }

消费者，创建TopicManReceiver.java

package com.it.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class TopicRabbitConfig {
    //绑定
    public final static String man="topic.man";
    public final static String woman="topic.woman";

    @Bean
    public Queue firstQueue(){
        return new Queue(TopicRabbitConfig.man);
    }

    @Bean
    public Queue secondQueue(){
        return new Queue(TopicRabbitConfig.woman);
    }

    @Bean
    TopicExchange exchange(){
        return new TopicExchange("topicExchange");
    }

    @Bean
    Binding bindingExchangeMessage(){
        return BindingBuilder.bind(firstQueue()).to(exchange()).with(man);
    }

     //将secondQueue和topicExchange绑定,而且绑定的键值为用上通配路由键规则topic.#
    // 这样只要是消息携带的路由键是以topic.开头,都会分发到该队列
    @Bean
    Binding bindingExchangeMessage1(){
        return BindingBuilder.bind(secondQueue()).to(exchange()).with("topic.#");
    }

}

监听队列


import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
import java.util.Map;
 
@Component
@RabbitListener(queues = "topic.woman")
public class TopicTotalReceiver {
 
    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("TopicTotalReceiver消费者收到消息  : " + testMessage.toString());
    }
}

接下来是使用Fanout Exchang 扇型交换机。

package com.it.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FanoutRabbitConfig {
    /**
     * 创建三个队列,将三个队列都绑定在交换机上
     * @return
     */

    @Bean
    public Queue queueA(){
        return new Queue("fanout.A");
    }

    @Bean
    public Queue queueB(){
        return new Queue("fanout.B");
    }

    @Bean
    public Queue queueC(){
        return new Queue("fanout.C");
    }

    @Bean
    FanoutExchange fanoutExchange(){
        return new FanoutExchange("fanoutExchange");
    }

    @Bean
    Binding bindingExchangeA(){
        return BindingBuilder.bind(queueA()).to(fanoutExchange());
    }

    @Bean
    Binding bindingExchangeB(){
        return BindingBuilder.bind(queueB()).to(fanoutExchange());
    }

    @Bean
    Binding bindingExchangeC(){
        return BindingBuilder.bind(queueC()).to(fanoutExchange());
    }
}

消息推送

 @GetMapping("/sendFanoutMessage")
    public String sendFanoutMessage(){
        String messageId=String.valueOf(UUID.randomUUID());
        String messageData="message: FANOUT";
        String createTime=LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));

        Map<String,Object>map=new HashMap<>();
        map.put("messageId",messageId);
        map.put("messageData",messageData);
        map.put("createTime",createTime);

        rabbitTemplate.convertAndSend("fanoutExchange",null,map);
        return "FANOUT上传成功";
    }

消费者A

@Component
@RabbitListener(queues = "fanout.A")
public class FanoutReceiverA {
 
    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("FanoutReceiverA消费者收到消息  : " +testMessage.toString());
    }
 
}

消费者B

@Component
@RabbitListener(queues = "fanout.B")
public class FanoutReceiverB {
 
    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("FanoutReceiverB消费者收到消息  : " +testMessage.toString());
    }
 
}

消费者C

@Component
@RabbitListener(queues = "fanout.C")
public class FanoutReceiverC {
 
    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("FanoutReceiverC消费者收到消息  : " +testMessage.toString());
    }
 
}

手动ACK确认机制，rabbitMQ中ack的确认机制，只能保证消息被消费了。但是，消费者这边出现了错误，后期只能通过日志方式追回。

在提供者的配置中加上

server:
  port: 8001
spring:
  application:
    name: rabbitmq-provider
  rabbitmq:
    host: localhost
    port: 5672
    username: admin
    password: 123456
    virtual-host: admin

    publisher-confirms: true #确认消息已发送到交换机
    publisher-returns: true #确认消息已发送到队列

然后是配置相关的消息确认回调函数，RabbitConfig.java：

@Configuration
public class RabbitConfig {

    @Bean
    public RabbitTemplate createRabbitTemplate(ConnectionFactory factory){
        RabbitTemplate rabbitTemplate = new RabbitTemplate();
        rabbitTemplate.setConnectionFactory(factory);

        //设置开启Mandatory,才能触发回调函数，无论消息推送结果怎么样都强制回调函数
        rabbitTemplate.setMandatory(true);

        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            @Override
            public void confirm(CorrelationData correlationData, boolean b, String s) {
                System.out.println("ConfirmCallback: "+"相关数据："+correlationData);
                System.out.println("ConfirmCallback: "+"确认情况："+b);
                System.out.println("ConfirmCallback: "+"原因："+s);
            }
        });

        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
            @Override
            public void returnedMessage(Message message, int replyCode, String replyText,
                                        String exchange, String routingKey) {
                System.out.println("ReturnCallback:     "+"消息："+message);
                System.out.println("ReturnCallback:     "+"回应码："+replyCode);
                System.out.println("ReturnCallback:     "+"回应信息："+replyText);
                System.out.println("ReturnCallback:     "+"交换机："+exchange);
                System.out.println("ReturnCallback:     "+"路由键："+routingKey);
            }
        });
        return rabbitTemplate;
    }
}

到这里，生产者推送消息的消息确认调用回调函数已经完毕。
可以看到上面写了两个回调函数，一个叫 ConfirmCallback ，一个叫 RetrunCallback；
那么以上这两种回调函数都是在什么情况会触发呢？

先从总体的情况分析，推送消息存在四种情况：

①消息推送到server，但是在server里找不到交换机
②消息推送到server，找到交换机了，但是没找到队列
③消息推送到sever，交换机和队列啥都没找到
④消息推送成功

 @GetMapping("/TestMessageAck")
    public String TestMessageAck(){
        String messageId=String.valueOf(UUID.randomUUID());
        String messageData="message: non-existent-exchange test message";
        String createTime=LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));

        Map<String,Object>map=new HashMap<>();
        map.put("messageId",messageId);
        map.put("messageData",messageData);
        map.put("createTime",createTime);

        //1.消息推送到server，但是在server里找不到交换机
        //触发的是 ConfirmCallback 回调函数
//        rabbitTemplate.convertAndSend("non-existent-exchange","TestDirectRouting",map);

        //2.消息推送到server，找到交换机了，但是没找到队列
        //触发的是 ConfirmCallback和RetrunCallback两个回调函数。
//        rabbitTemplate.convertAndSend("lonelyDirectExchange","TestDirectRouting",map);

        //3.消息推送到sever，交换机和队列啥都没找到
        //这种情况触发的是 ConfirmCallback 回调函数。
//                rabbitTemplate.convertAndSend("","",map);

        //4.消息推送成功
        rabbitTemplate.convertAndSend("TestDirectExchange","TestDirectRouting",map);

        return "测试手动确认机制";
    }

接下来我们继续，消费者接收到消息的消息确认机制。

和生产者的消息确认机制不同，因为消息接收本来就是在监听消息，符合条件的消息就会消费下来。
所以，消息接收的确认机制主要存在三种模式：

①自动确认，这也是默认的消息确认情况。 AcknowledgeMode.NONE
RabbitMQ成功将消息发出（即将消息成功写入TCP Socket）中立即认为本次投递已经被正确处理，不管消费者端是否成功处理本次投递。
所以这种情况如果消费端消费逻辑抛出异常，也就是消费端没有处理成功这条消息，那么就相当于丢失了消息。
一般这种情况我们都是使用try catch捕捉异常后，打印日志用于追踪数据，这样找出对应数据再做后续处理。

② 根据情况确认，这个不做介绍
③ 手动确认，这个比较关键，也是我们配置接收消息确认机制时，多数选择的模式。
消费者收到消息后，手动调用basic.ack/basic.nack/basic.reject后，RabbitMQ收到这些消息后，才认为本次投递成功。
basic.ack用于肯定确认
basic.nack用于否定确认（注意：这是AMQP 0-9-1的RabbitMQ扩展）
basic.reject用于否定确认，但与basic.nack相比有一个限制:一次只能拒绝单条消息

消费者端以上的3个方法都表示消息已经被正确投递，但是basic.ack表示消息已经被正确处理。
而basic.nack,basic.reject表示没有被正确处理：

着重讲下reject，因为有时候一些场景是需要重新入列的。

channel.basicReject(deliveryTag, true); 拒绝消费当前消息，如果第二参数传入true，就是将数据重新丢回队列里，那么下次还会消费这消息。设置false，就是告诉服务器，我已经知道这条消息数据了，因为一些原因拒绝它，而且服务器也把这个消息丢掉就行。下次不想再消费这条消息了。

使用拒绝后重新入列这个确认模式要谨慎，因为一般都是出现异常的时候，catch异常再拒绝入列，选择是否重入列。

但是如果使用不当会导致一些每次都被你重入列的消息一直消费-入列-消费-入列这样循环，会导致消息积压。

顺便也简单讲讲 nack，这个也是相当于设置不消费某条消息。

channel.basicNack(deliveryTag, false, true);
第一个参数依然是当前消息到的数据的唯一id;
第二个参数是指是否针对多条消息；如果是true，也就是说一次性针对当前通道的消息的tagID小于当前这条消息的，都拒绝确认。
第三个参数是指是否重新入列，也就是指不确认的消息是否重新丢回到队列里面去。

同样使用不确认后重新入列这个确认模式要谨慎，因为这里也可能因为考虑不周出现消息一直被重新丢回去的情况，导致积压

在消费者项目里，新建MessageListenerConfig.java上添加代码相关的配置代码：

package com.it.config;

import org.springframework.amqp.core.AcknowledgeMode;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MessageListenerConfig  {

    @Autowired
    private CachingConnectionFactory connectionFactory;

    @Autowired
    private MyAckReceiver myAckReceiver;

    @Bean
    public SimpleMessageListenerContainer simpleMessageListenerContainer(){
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory);
        container.setConcurrentConsumers(1);
        container.setMaxConcurrentConsumers(1);
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL);

        //设置一个队列
        container.setQueueNames("TestDirectQueue");

        //TODO 设置多个
        //如果同时设置多个如下： 前提是队列都是必须已经创建存在的
        //  container.setQueueNames("TestDirectQueue","TestDirectQueue2","TestDirectQueue3");


        //另一种设置队列的方法,如果使用这种情况,那么要设置多个,就使用addQueues
        //container.setQueues(new Queue("TestDirectQueue",true));
        //container.addQueues(new Queue("TestDirectQueue2",true));

        container.setMessageListener(myAckReceiver);
        return container;
    }


}

对应的手动确认消息监听类，MyAckReceiver.java（手动确认模式需要实现ChannelAwareMessageListener）：

package com.it.config;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
import org.springframework.stereotype.Component;

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

@Component
public class MyAckReceiver implements ChannelAwareMessageListener {
    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();

        try{
            String msg=message.toString();
            String[]msgArray=msg.split("'");
            Map<String, String> map = mapStringToMap(msgArray[1].trim(), 3);
            String messageId = map.get("messageId");
            String messageData = map.get("messageData");
            String createTime = map.get("createTime");

            //需要监听多个队列
//            if ("TestDirectQueue".equals(message.getMessageProperties().getConsumerQueue())){
//                System.out.println("消费的消息来自的队列名为："+message.getMessageProperties().getConsumerQueue());
//                System.out.println("消息成功消费到  messageId:"+messageId+"  messageData:"+messageData+"  createTime:"+createTime);
//                System.out.println("执行TestDirectQueue中的消息的业务处理流程......");
//
//            }
//
//            if ("fanout.A".equals(message.getMessageProperties().getConsumerQueue())) {
//                System.out.println("消费的消息来自的队列名为：" + message.getMessageProperties().getConsumerQueue());
//                System.out.println("消息成功消费到  messageId:" + messageId + "  messageData:" + messageData + "  createTime:" + createTime);
//                System.out.println("执行fanout.A中的消息的业务处理流程......");
//            }
            

            System.out.println("  MyAckReceiver  messageId:"+messageId+"  messageData:"+messageData+"  createTime:"+createTime);
            System.out.println("消费的主题消息来自："+message.getMessageProperties().getConsumerQueue());
            channel.basicAck(deliveryTag, true); //第二个参数，手动确认可以被批处理，当该参数为 true 时，则可以一次性确认 delivery_tag 小于等于传入值的所有消息
//			channel.basicReject(deliveryTag, true);//第二个参数，true会重新放回队列，所以需要自己根据业务逻辑判断什么时候使用拒绝


        }catch(Exception e){
            /**
             * 拒绝消费当前消息，如果第二参数传入true，就是将数据重新丢回队列里，那么下次还会消费这消息。设置false，就是告诉服务器，我已经知道这条消息数据了，因为一些原因拒绝它，而且服务器也把这个消息丢掉就行。 下次不想再消费这条消息了。
             *
             * 使用拒绝后重新入列这个确认模式要谨慎，因为一般都是出现异常的时候，catch异常再拒绝入列，选择是否重入列。
             *
             * 但是如果使用不当会导致一些每次都被你重入列的消息一直消费-入列-消费-入列这样循环，会导致消息积压。
             */
            channel.basicReject(deliveryTag,false);
            /**
             * channel.basicNack(deliveryTag, false, true);
             * 第一个参数依然是当前消息到的数据的唯一id;
             * 第二个参数是指是否针对多条消息；如果是true，也就是说一次性针对当前通道的消息的tagID小于当前这条消息的，都拒绝确认。
             * 第三个参数是指是否重新入列，也就是指不确认的消息是否重新丢回到队列里面去。
             *
             * 同样使用不确认后重新入列这个确认模式要谨慎，因为这里也可能因为考虑不周出现消息一直被重新丢回去的情况，导致积压。
             */
            e.printStackTrace();
        }
    }

    private Map<String,String> mapStringToMap(String str, int entryNum) {
        str=str.substring(1,str.length()-1);
        String[]strs=str.split(",",entryNum);
        Map<String,String>map=new HashMap<String,String>();
        for (String s : strs) {
            String key=s.split("=")[0].trim();
            String value=s.split("=")[1];
            map.put(key,value);
        }
        return map;
    }
}

RabbitMQ高级 - 过期时间TTL

过期时间 TTl表示可以对消息设置预期的时间，在这个时间内都可以被消费者接收获取；过了之后消息将自动被删除。RabbitMQ可以对消息和队列设置 TTL，目前有两种方法可以设置

第一种方法是通过队列属性设置，队列中所有消息都有相同的过期时间
第二种方法是对消息进行单独设置，每条消息 TTL可以不同

//路由
@Configuration
public class DirectRabbitConfig {
    //队列
    @Bean
    public Queue TestDirectQueue(){
        // durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
        // exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
        // autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
        //   return new Queue("TestDirectQueue",true,true,false);

        //设置队列的过期时间
        Map<String,Object> args=new HashMap<>();
        args.put("x-meesage-ttl",5000);
        return new Queue("TestDirectQueue",true,false,false,args);
    }

    @Bean
    DirectExchange TestDirectExchange(){
        return new DirectExchange("TestDirectExchange",true,false,null);
    }

    @Bean
    Binding bindingDirect(){
        return BindingBuilder.bind(TestDirectQueue()).to(TestDirectExchange()).with("TestDirectRouting");
    }


    @Bean
    DirectExchange lonelyDirectExchange(){
        return new DirectExchange("lonelyDirectExchange");
    }
}

消息推送

    @GetMapping("/sendDirectOrder")
    public String sendDirectOrder(){


        String orderId=UUID.randomUUID().toString();

        MessagePostProcessor processor = new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                message.getMessageProperties().setExpiration("5000");
                message.getMessageProperties().setContentEncoding("utf-8");
                return message;
            }
        };

        rabbitTemplate.convertAndSend("TestDirectExchange","TestDirectRouting",
                orderId,processor);
        return "订单生产成功："+orderId;
    }

消费者这边

@Configuration
public class DirectRabbitConfig {

    @Bean
    public Queue TestDirectQueue(){
        //设置过期时间
        Map<String,Object> args = new HashMap<>();
        args.put("x-message-ttl",5000);//这里一定是int类型
        return new Queue("TestDirectQueue",true,false,false,args);
    }

    @Bean
    DirectExchange TestDirectExchange(){
        return new DirectExchange("TestDirectQueue",true,false);
    }

    @Bean
    Binding bindingDirect(){
        return BindingBuilder.bind(TestDirectQueue()).to(TestDirectExchange()).with("TestDirectRouting");
    }
}

监听消息

@Component
@RabbitListener(queues = "TestDirectQueue")
//@RabbitListener(queues = "topic.woman")
public class DirectReceiverController {
    Logger logger=LoggerFactory.getLogger(DirectReceiverController.class);
//    @RabbitHandler
//    public void process(Map testMessage){
        System.out.println("DirectReceiver消费者收到消息："+testMessage);
//        System.out.println("TopicTotal消费者收到消息："+testMessage);
//    }

    /**
     * 获取队列时间
     * @param testMessage
     */
    @RabbitHandler
    public void process(String testMessage) throws InterruptedException {
     System.out.println("DirectReceiver消费者收到消息："+testMessage);
    }

}

RabbitMQ高级 - 削峰

在消费者这边配置

server:
  port: 8002
spring:
  application:
    name: rabbitmq-consumer
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: admin
    password: 123456
    virtual-host: admin
    listener:
      type: simple #简单的削峰
      simple:
        prefetch: 1 #消费者每次从队列获取的消息数量
        concurrency: 2 #消费者数量
        max-concurrency: 10 #启动消费者最大数量
        retry: #重试策略 不和mq有关，是消费者之间的重试
          enabled: true #开启消费者
          max-attempts: 2 #最大重试次数
          initial-interval: 2000 #重试间隔时间

监听消费

@Component
@RabbitListener(queues = "TestDirectQueue")
//@RabbitListener(queues = "topic.woman")
public class DirectReceiverController {
    Logger logger=LoggerFactory.getLogger(DirectReceiverController.class);
//    @RabbitHandler
//    public void process(Map testMessage){
        System.out.println("DirectReceiver消费者收到消息："+testMessage);
//        System.out.println("TopicTotal消费者收到消息："+testMessage);
//    }

    /**
     * 获取队列时间
     * @param testMessage
     */
    @RabbitHandler
    public void process(String testMessage) throws InterruptedException {
//        System.out.println("DirectReceiver消费者收到消息："+testMessage);
        Thread.sleep(2000);
        logger.info("消费者收到消息："+testMessage);
//        System.out.println("TopicTotal消费者收到消息："+testMessage);
    }

}

这篇rabbitMQ，是从csdn博主的文章基础上，加了一些其他的功能。非常感谢这位博主。原文地址

林园857

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
RabbitMQ高级学习

springboot整合rabbitMQ1.提供者配置文件application.ymlserver: port: 8001spring: application: name: rabbitmq-provider rabbitmq: host: localhost port: 5672 username: admin password: 123456 virtual-host: admin所用到的依赖 <dependenc
复制链接

扫一扫