com.luues.rabbitmq.config.RabbitMQConfiguration Maven / Gradle / Ivy

Go to download
package com.luues.rabbitmq.config;

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.RabbitAdmin;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.transaction.RabbitTransactionManager;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;

@Configuration
public class RabbitMQConfiguration {

    @Autowired(required = false)
    private RabbitProducerConfig rabbitProducerConfig;

    @Bean(value = "officialRabbitTemplate")
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    public RabbitTemplate rabbitTemplate() {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(rabbitmqconnectionFactory());
        rabbitTemplate.setMessageConverter(jsonMessageConverter());
        // 消息是否成功发送到Exchange
        rabbitTemplate.setConfirmCallback((correlationData, ack, cause) -> {
            if (ack) {
                //LogUtil.info("消息成功发送到Exchange!");
            } else {
                //LogUtil.error("消息发送到Exchange失败, {}, cause: {}", correlationData, cause);
            }
        });
        rabbitTemplate.setMandatory(true);
        rabbitTemplate.setReturnCallback((message, replyCode, replyText, exchange, routingKey) -> {
            //LogUtil.error("消息从Exchange路由到Queue失败: exchange: {}, route: {}, replyCode: {}, replyText: {}, message: {}", exchange, routingKey, replyCode, replyText, message);
        });
        return rabbitTemplate;
    }

    // 初始化连接
    @Bean
    public ConnectionFactory rabbitmqconnectionFactory() {
        CachingConnectionFactory factory = new CachingConnectionFactory();
        factory.setHost(rabbitProducerConfig.getHost());
        factory.setPort(rabbitProducerConfig.getPort());
        factory.setUsername(rabbitProducerConfig.getUsername());
        factory.setPassword(rabbitProducerConfig.getPassword());
        //factory.setPublisherConfirms(true);
        //factory.setPublisherReturns(true);
        /*factory.setChannelCacheSize(100);
        factory.setCacheMode(CachingConnectionFactory.CacheMode.CHANNEL);*/
        return factory;
    }

    /**
     * 配置启用rabbitmq事务
     * @return
     */
    @Bean
    public RabbitTransactionManager rabbitTransactionManager() {
        RabbitTransactionManager transactionManager = new RabbitTransactionManager(rabbitmqconnectionFactory());
        return transactionManager;
    }

    @Bean
    public RabbitAdmin rabbitAdmin() {
        return new RabbitAdmin(rabbitmqconnectionFactory());
    }

    /*@Bean
    public SimpleMessageListenerContainer simpleMessageListenerContainer(){
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
        container.setConnectionFactory(connectionFactory());
        container.setExposeListenerChannel(true);
        container.addQueues(RabbitMQQueueEnum.getQueues());
        container.setAmqpAdmin(rabbitAdmin());
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL);
        container.setConcurrentConsumers(1);
        container.setMaxConcurrentConsumers(1);
        container.setMessageListener(rabbitMQDefaultListener);
        return container;
    }*/

    @Bean
    @Qualifier(value = QueueConstant.MANUAL)
    public SimpleRabbitListenerContainerFactory simpleRabbitListenerContainerFactory() {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factory.setConnectionFactory(rabbitmqconnectionFactory());
        //开启手动 ack，测试一个消息被Consumer拒收了，并且reject方法的参数里requeue是false。也就是说不会被再次放在队列里，被其他消费者使用
        factory.setAcknowledgeMode(AcknowledgeMode.MANUAL);
        //配置消息转化器，如果需要在消息通道channel中传输可序列化对象，需要此配置
        factory.setMessageConverter(jsonMessageConverter());
        return factory;
    }

    @Bean
    public MessageConverter jsonMessageConverter() {
        return new Jackson2JsonMessageConverter();
    }

}