com.emily.infrastructure.rabbitmq.amqp.RabbitMqAnnotationDrivenConfiguration Maven / Gradle / Ivy

Go to download
package com.emily.infrastructure.rabbitmq.amqp;

import com.emily.infrastructure.rabbitmq.RabbitMqProperties;
import org.springframework.amqp.rabbit.annotation.EnableRabbit;
import org.springframework.amqp.rabbit.config.AbstractRabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.config.ContainerCustomizer;
import org.springframework.amqp.rabbit.config.DirectRabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.listener.DirectMessageListenerContainer;
import org.springframework.amqp.rabbit.listener.RabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
import org.springframework.amqp.rabbit.retry.MessageRecoverer;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.boot.autoconfigure.amqp.AbstractRabbitListenerContainerFactoryConfigurer;
import org.springframework.boot.autoconfigure.amqp.RabbitProperties;
import org.springframework.boot.autoconfigure.amqp.RabbitRetryTemplateCustomizer;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

import static com.emily.infrastructure.rabbitmq.common.RabbitMqUtils.*;

/**
 * 配置RabbitMQ  注解驱动端点
 *
 * @author Emily
 * @since Created in 2022/11/17 10:27 上午
 */
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(EnableRabbit.class)
public class RabbitMqAnnotationDrivenConfiguration {

    private final ObjectProvider messageConverter;
    private final ObjectProvider messageRecoverer;
    private final ObjectProvider retryTemplateCustomizers;
    private final DefaultListableBeanFactory defaultListableBeanFactory;

    public RabbitMqAnnotationDrivenConfiguration(ObjectProvider messageConverter,
                                                 ObjectProvider messageRecoverer,
                                                 ObjectProvider retryTemplateCustomizers,
                                                 DefaultListableBeanFactory defaultListableBeanFactory) {
        this.messageConverter = messageConverter;
        this.messageRecoverer = messageRecoverer;
        this.retryTemplateCustomizers = retryTemplateCustomizers;
        this.defaultListableBeanFactory = defaultListableBeanFactory;
    }

    /**
     * 容器监听器工厂配置类
     * 返回默认配置类，将其它容器监听器工厂配置类注入IOC容器
     *
     * @param rabbitMqProperties 属性配置
     * @return 默认容器监听器工厂配置类
     */
    @Bean
    @ConditionalOnMissingBean
    public AbstractRabbitListenerContainerFactoryConfigurer rabbitListenerContainerFactoryConfigurer(RabbitMqProperties rabbitMqProperties) {
        String defaultConfig = Objects.requireNonNull(rabbitMqProperties.getDefaultConfig(), "RabbitMQ默认配置必须配置");
        Map dataMap = Objects.requireNonNull(rabbitMqProperties.getConfig(), "RabbitMQ连接配置不存在");
        AbstractRabbitListenerContainerFactoryConfigurer rabbitListenerContainerFactoryConfigurer = null;
        for (Map.Entry entry : dataMap.entrySet()) {
            String key = entry.getKey();
            RabbitProperties properties = entry.getValue();
            if (properties.getListener().getType().equals(RabbitProperties.ContainerType.DIRECT)) {
                DirectRabbitMqListenerContainerFactoryConfigurer configurer = new DirectRabbitMqListenerContainerFactoryConfigurer(properties);
                configurer.setMessageConverter(this.messageConverter.getIfUnique());
                configurer.setMessageRecoverer(this.messageRecoverer.getIfUnique());
                configurer.setRetryTemplateCustomizers(this.retryTemplateCustomizers.orderedStream().collect(Collectors.toList()));
                if (defaultConfig.equals(key)) {
                    rabbitListenerContainerFactoryConfigurer = configurer;
                } else {
                    defaultListableBeanFactory.registerSingleton(join(key, DIRECT_RABBIT_LISTENER_CONTAINER_FACTORY_CONFIGURER), configurer);
                }
            } else {
                SimpleRabbitMqListenerContainerFactoryConfigurer configurer = new SimpleRabbitMqListenerContainerFactoryConfigurer(properties);
                configurer.setMessageConverter(this.messageConverter.getIfUnique());
                configurer.setMessageRecoverer(this.messageRecoverer.getIfUnique());
                configurer.setRetryTemplateCustomizers(this.retryTemplateCustomizers.orderedStream().collect(Collectors.toList()));
                if (defaultConfig.equals(key)) {
                    rabbitListenerContainerFactoryConfigurer = configurer;
                } else {
                    defaultListableBeanFactory.registerSingleton(join(key, SIMPLE_RABBIT_LISTENER_CONTAINER_FACTORY_CONFIGURER), configurer);
                }
            }
        }
        return rabbitListenerContainerFactoryConfigurer;
    }

    /**
     * 获取容器监听器工厂类
     * 默认返回默认的容器监听器工厂类，其它的容器监听器工厂类注入IOC容器
     *
     * @param rabbitMqProperties        属性配置
     * @param simpleContainerCustomizer 自定义simple容器配置类
     * @param directContainerCustomizer 自定义direct容器配置类
     * @return 默认的容器监听器工厂类
     */
    @Bean(name = DEFAULT_RABBIT_LISTENER_CONTAINER_FACTORY)
    @ConditionalOnMissingBean(name = DEFAULT_RABBIT_LISTENER_CONTAINER_FACTORY)
    RabbitListenerContainerFactory rabbitListenerContainerFactory(RabbitMqProperties rabbitMqProperties,
                                                                  ObjectProvider> simpleContainerCustomizer,
                                                                  ObjectProvider> directContainerCustomizer) {
        String defaultConfig = Objects.requireNonNull(rabbitMqProperties.getDefaultConfig(), "RabbitMQ默认配置必须配置");
        Map dataMap = Objects.requireNonNull(rabbitMqProperties.getConfig(), "RabbitMQ连接配置不存在");
        RabbitListenerContainerFactory rabbitListenerContainerFactory = null;
        for (Map.Entry entry : dataMap.entrySet()) {
            String key = entry.getKey();
            RabbitProperties properties = entry.getValue();
            ConnectionFactory connectionFactory;
            AbstractRabbitListenerContainerFactoryConfigurer configurer;
            if (defaultConfig.equals(key)) {
                connectionFactory = defaultListableBeanFactory.getBean(DEFAULT_RABBIT_CONNECTION_FACTORY, ConnectionFactory.class);
                configurer = defaultListableBeanFactory.getBean(DEFAULT_RABBIT_LISTENER_CONTAINER_FACTORY_CONFIGURER, AbstractRabbitListenerContainerFactoryConfigurer.class);
            } else {
                connectionFactory = defaultListableBeanFactory.getBean(join(key, RABBIT_CONNECTION_FACTORY), ConnectionFactory.class);
                if (RabbitProperties.ContainerType.DIRECT.equals(properties.getListener().getType())) {
                    configurer = defaultListableBeanFactory.getBean(join(key, DIRECT_RABBIT_LISTENER_CONTAINER_FACTORY_CONFIGURER), DirectRabbitMqListenerContainerFactoryConfigurer.class);
                } else {
                    configurer = defaultListableBeanFactory.getBean(join(key, SIMPLE_RABBIT_LISTENER_CONTAINER_FACTORY_CONFIGURER), SimpleRabbitMqListenerContainerFactoryConfigurer.class);
                }
            }
            AbstractRabbitListenerContainerFactory factory;
            if (RabbitProperties.ContainerType.DIRECT.equals(properties.getListener().getType())) {
                factory = new DirectRabbitListenerContainerFactory();
                configurer.configure(factory, connectionFactory);
                directContainerCustomizer.ifUnique(factory::setContainerCustomizer);
            } else {
                factory = new SimpleRabbitListenerContainerFactory();
                configurer.configure(factory, connectionFactory);
                simpleContainerCustomizer.ifUnique(factory::setContainerCustomizer);
            }
            if (defaultConfig.equals(key)) {
                rabbitListenerContainerFactory = factory;
            } else {
                defaultListableBeanFactory.registerSingleton(join(key, RABBIT_LISTENER_CONTAINER_FACTORY), factory);
            }
        }
        return rabbitListenerContainerFactory;
    }
}