SpringBoot融合RabbitMQ的方案

最新推荐文章于 2024-05-13 16:15:23 发布

think12

最新推荐文章于 2024-05-13 16:15:23 发布

阅读量328

点赞数

分类专栏： RabbitMQ 文章标签： java

本文链接：https://blog.csdn.net/think12/article/details/109693893

版权

RabbitMQ 专栏收录该内容

3 篇文章

订阅专栏

本文详细介绍了如何在SpringBoot应用中集成RabbitMQ，包括RabbitMQ管理控制台的配置，如添加用户、虚拟主机、交换器和队列的创建，以及代码配置，如配置连接工厂、RabbitTemplate和消息监听。同时，文中还列举了广播和单播模式的使用场景，并提出了自定义命名规范。此外，提供了发送和接收消息的示例代码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

SpringBoot融合RabbitMQ的方案。

大体分两块内容：

RabbitMQ管控台配置的内容。
代码书写的内容。
常见场景。
自定义起名规范。

一、RabbitMQ管控台配置的内容：

1、添加用户，用管理员账户，登录到管控台，选择Admin标签，选择Users，注意添加用户时候的tag（如果不选择tag则代表None，只能程序中使用）。

在此，我们选择的Tags是policymaker，具体的参见详细说明。

2、添加虚拟主机，还是用管理员账户添加。

3、管控台创建交换器：

用新创建的账户登录到管控台，然后直接添加。注意Type字段，

              direct：默认交换器。单一模式。需要指定具体的routingkey，如果路由键匹配的话，消息就投递到相应的队列。
              topic：单一模式，类似于direct，但可以添加通配符。
              fanout：广播模式。发布/订阅模式的交换器，当你发送一条消息的时候，交换器会把消息广播到所有附加到这个交换器的队列上。
                      如果多个机器监听了同一个queue，只有一个机器消费掉该内容。
                      该交换器可以添加多个不同的queue来实现广播模式。
              headers：允许你匹配AMQP消息的header而非路由键，除此之外headers交换器和direct交换器完全一致，但性能却很差，几乎用不到。

4、管控台创建队列：

用新创建的账户登录到管控台，

5、管控台关联交换器和队列：

用新创建的账户登录到管控台

二、代码相关内容：

1、在application.properties文件中添加配置

#添加rabbitmq队列支持
rabbitmq.host=qingsu-rabbitmq-test
rabbitmq.port=5672

rabbitmq.bd.username=user_bd_system
rabbitmq.bd.password=user_bd_system
rabbitmq.bd.virtual-host=virtualhosts_bd_system

2、代码中添加RabbitMQConfig文件

/**
 * @author :
 * @Date: 2020年11月14日
 */
@Configuration
public class RabbitMqBDConfig {
    
    @Value("${rabbitmq.host}")
    private String host;
    
    @Value("${rabbitmq.port}")
    private String port;
    
    /**
     * 原有的队列
     */
    @Value("${rabbitmq.bd.username}")
    private String username;
    
    @Value("${rabbitmq.bd.password}")
    private String password;
    
    @Value("${rabbitmq.bd.virtual-host}")
    private String virtualHost;
    
    /**
     * 创建连接工厂
     *
     * @return
     */
    @Bean(name = "bdConnectionFactory")
    @Primary
    public ConnectionFactory connectionFactory() {
        final CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setAddresses(host + ":" + port);
        connectionFactory.setUsername(username);
        connectionFactory.setPassword(password);
        connectionFactory.setVirtualHost(virtualHost);
        connectionFactory.setPublisherConfirms(true); //必须要设置
        return connectionFactory;
    }
    
    /**
     * rabbitTemplate模版
     *
     * @param connectionFactory
     * @return
     */
    @Bean(name = "bdRabbitTemplate")
    @Primary
    public RabbitTemplate rabbitTemplate(@Qualifier("bdConnectionFactory") final ConnectionFactory connectionFactory) {
        final RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        return rabbitTemplate;
    }
    
    /**
     * 工程中使用的rabbitMessagingTempalte模版
     *
     * @param rabbitTemplate
     * @return
     */
    @Bean("bdRabbitMessagingTemplate")
    @Primary
    public RabbitMessagingTemplate rabbitMessagingTemplate(@Qualifier("bdRabbitTemplate") final RabbitTemplate
                                                                       rabbitTemplate) {
        final RabbitMessagingTemplate rabbitMessagingTemplate = new RabbitMessagingTemplate();
        rabbitMessagingTemplate.setRabbitTemplate(rabbitTemplate);
        return rabbitMessagingTemplate;
    }
    
    /**
     * 监听配置
     *
     * @param configurer
     * @param connectionFactory
     * @return
     */
    @Bean(name = "bdRabbitListenerContainerFactory")
    @Primary
    public SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory(final
                                                                                   SimpleRabbitListenerContainerFactoryConfigurer configurer,
                                                                               @Qualifier("bdConnectionFactory")
                                                                               final ConnectionFactory
                                                                                       connectionFactory) {
        final SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        configurer.configure(factory, connectionFactory);
        return factory;
    }
    
}

3、添加消息监听代码

/**
 * 队列监听
 *
 * @author
 * @Date: 2020年11月14日
 */
@Service
public class BDMessageCustomer {
    
    /**
     * 接收消息
     *
     * @param message 队列传过来的消息
     */
    @RabbitListener(queues = "queue_bd_content_pay", containerFactory = "bdRabbitListenerContainerFactory")
    public void receiveFooQueue(Message message) throws UnsupportedEncodingException {
        String content = new String(message.getBody(), "UTF-8");
        System.out.print(content);
    }
}

4、添加发送消息代码

public class RabbitMessageSend {
    
    @Resource(name = "bdRabbitMessagingTemplate")
    private RabbitMessagingTemplate rabbitMessagingTemplate;
    
    @Test
    public void testStatisticsScore() {
        rabbitMessagingTemplate.convertAndSend("exchanges_bd_house_state", "queue_bd_house_state", "{'name':'exchanges_bd_house_state'}");

    }
}

三、常用场景：
   1、广播模式（多个队列都接收消息）。
       使用场景：创建了一个用户，需要给该用户发送邮件、短信。则：
       创建一个交换器，创建两个queue，该交换器绑定这两个queue。
       exchange的type选择fanout，然后在exchange详情页面，绑定两个队列即可。
   2、单播模式（一个队列都接收消息）。
       exchange的type选择direct即可。然后在exchange详情页面，绑定该队列，并输入routingkey(相当于秘钥)，通过秘钥找到该队列。
   3、关于routingkey的说明：
       只是在exchange的type选择direct、topic时候有用。主要是关联exchange和queue。

四、自定义起名规范：

    1、username：登录到管理台、程序中使用的名称。
        起名规则：user_系统名称
    2、password：密码。
        起名规则：随意
    3、virtualhost：虚拟主机。类似于分组。
        起名规则：virtualhost_系统名称
    4、exchange：交换器。发送消息的时候，会指定交换器。
        起名规则：exchange_系统名称_模块_功能
    5、routingkey：路由规则。在交换器类型选择direct、topic的时候有效。选择fanout的时候无效。
        起名规则：一般是用queue代替
    6、queue：队列。
        起名规则：queue_系统名称_模块_功能