springboot多线程消费rabbitmq

最新推荐文章于 2025-01-09 15:03:39 发布

非ban必选

最新推荐文章于 2025-01-09 15:03:39 发布

阅读量227

点赞数 1

分类专栏： SpringBoot 文章标签： java-rabbitmq spring boot rabbitmq

本文链接：https://blog.youkuaiyun.com/zsj777/article/details/144773388

版权

SpringBoot 专栏收录该内容

89 篇文章

订阅专栏

1、

package com.yh.im.config;


import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.stereotype.Component;

@Component
@Slf4j
public class ConfirmCallBack1 implements RabbitTemplate.ConfirmCallback {
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String s) {
        if (!ack) {
            log.info("ConfirmCallBack1消息发送交换机失败：{}", s);
        } else {
            log.info("ConfirmCallBack1消息发送交换机成功");
        }
    }
}

package com.yh.im.config;

import com.rabbitmq.client.Channel;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.support.converter.MessageConversionException;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.amqp.SimpleRabbitListenerContainerFactoryConfigurer;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Primary;
import org.springframework.core.task.SimpleAsyncTaskExecutor;
import org.springframework.stereotype.Component;

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

@Data
@Component("mq1RabbitmqConfig")
@ConfigurationProperties(prefix = "spring.rabbitmq.mq1") //读取mq1的配置信息
@Slf4j
@ConditionalOnProperty(name = "spring.rabbitmq.mq1.enable", havingValue = "true") //是否启用
public class MQ1RabbitConfiguration {
    private String host;
    private Integer port;
    private String username;
    private String password;
    public static final String FANOUTEXCHANGEONE = "fanoutExchangeOne1";
    public static final String ZJXLQUEUE = "zjxlQueue1";

    @Autowired
    private ReturnCallBack1 returnCallBack1;
    @Autowired
    private ConfirmCallBack1 confirmCallBack1;

    @Bean(name = "mq1ConnectionFactory")
    //命名mq1的ConnectionFactory,如果项目中只有一个mq则不必如此
    @Primary
    public ConnectionFactory createConnectionFactory() {
        //消息队列1的连接
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setHost(host);
        connectionFactory.setPort(port);
        connectionFactory.setUsername(username);
        connectionFactory.setPassword(password);
        //开启发送到交换机和队列的回调
        connectionFactory.setPublisherConfirmType(CachingConnectionFactory.ConfirmType.CORRELATED);

//        Channel channel = connectionFactory.createConnection().createChannel(false);
//        // 声明queue,exchange,以及绑定
//        try {
//            channel.exchangeDeclare(FANOUTEXCHANGEONE /* exchange名称 */, "fanout"/* 类型 */);
//            // durable,exclusive,autodelete
//            channel.queueDeclare(ZJXLQUEUE, true, false, false, null);
//            // (如果没有就)创建Queue
//        } catch (Exception e) {
//            log.error("mq declare queue exchange fail ", e);
//        } finally {
//            try {
//                channel.close();
//            } catch (Exception e) {
//                log.error("mq channel close fail", e);
//            }
//
//        }
        return connectionFactory;
    }

    @Bean(name = "mq1RabbitTemplate")
    //命名mq1的RabbitTemplate,如果项目中只有一个mq则不必如此
    @Primary
    public RabbitTemplate brainRabbitTemplate(@Qualifier("mq1ConnectionFactory") ConnectionFactory connectionFactory) {
        //消息生产
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        //发送消息时设置强制标志，仅当提供了returnCallback时才适用
        rabbitTemplate.setMandatory(true);
        //确保消息是否发送到交换机，成功与失败都会触发
        rabbitTemplate.setConfirmCallback(confirmCallBack1);
        //确保消息是否发送到队列，成功发送不触发，失败触发
        rabbitTemplate.setReturnCallback(returnCallBack1);
        return rabbitTemplate;
    }

    @Bean(name = "simpleRabbitListenerContainerFactory1")
    @Primary
    public SimpleRabbitListenerContainerFactory firstFactory(
            SimpleRabbitListenerContainerFactoryConfigurer configurer,
            @Qualifier("mq1ConnectionFactory") ConnectionFactory connectionFactory
    ) {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();

        // 消息确认模式，默认为 AUTO
        factory.setAcknowledgeMode(AcknowledgeMode.AUTO);

        // 并发消费者数，默认为 1
        factory.setConcurrentConsumers(5);
        factory.setConsumerBatchEnabled(true);
        factory.setBatchListener(true);
        // 最大并发消费者数，默认为 1
        factory.setMaxConcurrentConsumers(10);
        // 拒绝未确认的消息并重新将它们放回队列，默认为 true
        factory.setDefaultRequeueRejected(false);
        // 容器启动时是否自动启动，默认为 true
        factory.setAutoStartup(true);
        // 每个消费者在一次请求中预获取的消息数，默认为 1
        factory.setPrefetchCount(5);
        // 从队列中接收消息的超时时间，默认为 0，表示没有超时限制
        factory.setReceiveTimeout(0L);
        // 用于异步消息处理的线程池。默认情况下，容器使用一个简单的 SimpleAsyncTaskExecutor
        factory.setTaskExecutor(new SimpleAsyncTaskExecutor());
        // 如果消息处理器尝试监听不存在的队列，是否抛出异常。默认为 true
        factory.setMissingQueuesFatal(false);


        configurer.configure(factory, connectionFactory);
        return factory;
    }

    @Bean(name = "fanoutExchangeOne")
    public FanoutExchange fanoutExchange() {
//        Direct exchange（直连交换机）
//        Fanout exchange（扇型交换机）
//        Topic exchange（主题交换机）
//        Headers exchange（头交换机）
//        Dead Letter Exchange（死信交换机）
        return new FanoutExchange(FANOUTEXCHANGEONE);
    }

    @Bean(name = "zjxlQueue")
    public Queue zjxlQueue() {
        Map<String, Object> argsMap = new HashMap<String, Object>();
        argsMap.put("x-max-priority", 5);
        Queue queue = new Queue(ZJXLQUEUE, true, false, false, argsMap);
//        Queue queue = new Queue(ZJXLQUEUE);
        return queue;
    }

    @Bean(name = "zjxlTopicBinding")
    public Binding topicBinding(@Qualifier("zjxlQueue") Queue queue, FanoutExchange exchange) {
        //绑定队列4到fanoutExchange  队列3和队列4都能消费fanoutExchange的消息
        return BindingBuilder.bind(queue).to(exchange);
    }

}

package com.yh.im.config;


import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.BatchMessageListener;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
@Slf4j
public class Receiver1  {




    @RabbitListener(queues = MQ1RabbitConfiguration.ZJXLQUEUE, containerFactory = "simpleRabbitListenerContainerFactory1")
    public void onMessage(Message messages) {
        System.out.println(Thread.currentThread().getName());
        System.out.println(new String(messages.getBody()));
        System.out.println(messages.getMessageProperties().getHeaders());
    }
}

package com.yh.im.config;

import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.stereotype.Component;

@Component
@Slf4j
public class ReturnCallBack1 implements RabbitTemplate.ReturnCallback {
    @Override
    public void returnedMessage(Message message, int i, String s, String s1, String s2) {

    }
}