RabbitMQ的Java应用(3) -- 使用spring-boot-starter-amqp开发生产者应用

最新推荐文章于 2024-02-29 18:00:00 发布
最新推荐文章于 2024-02-29 18:00:00 发布
阅读量1.3w 收藏 6
点赞数 2
分类专栏： RabbitMQ Spring Boot Spring AMQP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011126891/article/details/54376179
版权
本文详细介绍了如何使用Spring Boot的spring-boot-starter-amqp库开发RabbitMQ生产者应用，包括使用AsyncRabbitTemplate实现异步消息发送、BatchingRabbitTemplate批量发送消息、RabbitMQ注解简化应用代码以及对象类型消息的发送。通过实例展示了各种场景下的消息处理策略，帮助读者理解如何高效地使用Spring AMQP进行消息通信。
摘要由CSDN通过智能技术生成

上一篇我们介绍了如何使用Spring AMQP和RabbitMQ结合，开发消费者应用程序，使用的是Xml配置的Spring框架。

本篇我们仍然使用Spring AMQP开发生产者应用，不过我们使用零 XML配置的Spring Boot环境进行开发，使用的库是spring-boot-starter-amqp库。

使用Spring-boot-starter-amqp搭建框架

我们使用Spring Boot 1.4.3 RELEASE版本，pom.xml文件内容如下: 

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
 
    <groupId>com.example</groupId>
    <artifactId>SpringMQProducer</artifactId>
    <version>0.1.0</version>
    <packaging>jar</packaging>
 
    <name>SpringMQProducer</name>
    <description>The MQ producer in spring boot environment</description>
 
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.4.3.RELEASE</version>
        <relativePath/>
    </parent>
 
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>
 
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
 
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
 
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
 
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>
 
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>
需要注意的是,当使用spring-boot-configuration-processor库时会默认打开RabbitAutoConfiguration,它会自动创建一个 CachingConnectionFactory对象，一个RabbitTemplate对象，一个AmqpAdmin对象以及一个RabbitMessageTemplate对象。 

@Configuration
@ConditionalOnClass({ RabbitTemplate.class, Channel.class })
@EnableConfigurationProperties(RabbitProperties.class)
@Import(RabbitAnnotationDrivenConfiguration.class)
public class RabbitAutoConfiguration {
   	@Configuration
	@ConditionalOnMissingBean(ConnectionFactory.class)
	protected static class RabbitConnectionFactoryCreator {
		@Bean
		public CachingConnectionFactory rabbitConnectionFactory(RabbitProperties config)
                {
                 ........
 
        @Configuration
	@Import(RabbitConnectionFactoryCreator.class)
	protected static class RabbitTemplateConfiguration {
           @Bean
	   @ConditionalOnSingleCandidate(ConnectionFactory.class)
	   @ConditionalOnMissingBean(RabbitTemplate.class)
	   public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
           ........
 
        @Bean
	@ConditionalOnSingleCandidate(ConnectionFactory.class)
	@ConditionalOnProperty(prefix = "spring.rabbitmq", name = "dynamic", matchIfMissing = true)
	@ConditionalOnMissingBean(AmqpAdmin.class)
	public AmqpAdmin amqpAdmin(ConnectionFactory connectionFactory) {
		return new RabbitAdmin(connectionFactory);
	}
 
        .......
        @Configuration
	@ConditionalOnClass(RabbitMessagingTemplate.class)
	@ConditionalOnMissingBean(RabbitMessagingTemplate.class)
	@Import(RabbitTemplateConfiguration.class)
	protected static class MessagingTemplateConfiguration {
 
	@Bean
	@ConditionalOnSingleCandidate(RabbitTemplate.class)
	public RabbitMessagingTemplate rabbitMessagingTemplate(
			RabbitTemplate rabbitTemplate) {
		return new RabbitMessagingTemplate(rabbitTemplate);
	}



如果我们想定制自己的ConnectionFactory，RabbitTemplate等对象，建议在Configuration中将其禁用:











 

 

 
  
 
@Configuration
@ComponentScan("com.qf.rabbitmq")
@EnableAutoConfiguration(exclude = RabbitAutoConfiguration.class)
@SpringBootApplication
public class SpringMqProducerApplication {
 
	public static void main(String[] args) {
		SpringApplication.run(SpringMqProducerApplication.class, args);
	}
}
 
 
 
 在src/main/resources目录下创建application.properties文件，添加rabbitmq相关设置,以spring.rabbitmq为前缀，这样它会自动映射到RabbitProperties配置类 
 
 

 

 
  
 
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=rabbitmq_producer
spring.rabbitmq.password=123456
spring.rabbitmq.virtualHost=test_vhosts
 
 
 
 添加RabbitConfig类，用于创建自定义ConnectionFactory,RabbitAdmin,RabbitTemplate等。 这个类头部如下所示 
 
 

 

 
 
@Configuration
@EnableConfigurationProperties(RabbitProperties.class)
public class RabbitConfig
{
    @Autowired
    private RabbitProperties rabbitProperties;
 
 
 这里用到了org.springframework.boot.autoconfigure.amqp.RabbitProperties类，记录application.properties中的RabbitMQ连接设置。
 
 
 再创建ConnectionFactory:
 
 
 
 
 
@Bean("connectionFactory")
 public ConnectionFactory getConnectionFactory() {
        com.rabbitmq.client.ConnectionFactory rabbitConnectionFactory =
                new com.rabbitmq.client.ConnectionFactory();
        rabbitConnectionFactory.setHost(rabbitProperties.getHost());
        rabbitConnectionFactory.setPort(rabbitProperties.getPort());
        rabbitConnectionFactory.setUsername(rabbitProperties.getUsername());
        rabbitConnectionFactory.setPassword(rabbitProperties.getPassword());
        rabbitConnectionFactory.setVirtualHost(rabbitProperties.getVirtualHost());
 
        ConnectionFactory connectionFactory = new CachingConnectionFactory(rabbitConnectionFactory);
        return connectionFactory;
 }
 
 这里可以像消费者应用里提到的那样，设置CacheMode和最大缓存数，我们这里暂不设置。 再创建RabbitAdmin对象 
 
 
 
 
 
 
@Bean(name="rabbitAdmin")
public RabbitAdmin getRabbitAdmin()
{
    RabbitAdmin rabbitAdmin = new RabbitAdmin(getConnectionFactory());
    rabbitAdmin.setAutoStartup(true);
    return rabbitAdmin;
}
 
 定义MessageConverter和MessagePropertiesConverter对象 
 
 
 
 
 
 
@Bean(name="serializerMessageConverter")
public MessageConverter getMessageConverter(){
        return new SimpleMessageConverter();
}
 
@Bean(name="messagePropertiesConverter")
public MessagePropertiesConverter getMessagePropertiesConverter()
{
    return new DefaultMessagePropertiesConverter();
}
 
 定义发送消息所用的RabbitTemplate对象，由于我们的场景要求发送之后立即从消费者处获得返回消息，因此我们在RabbitTemplate对象中设置了ReplyAddress，而且在下面的MessageListenerContainer中将这个对象作为Listener设置到Container中。 
 
 
 
 
 
@Bean(name="rabbitTemplate")
public RabbitTemplate getRabbitTemplate()
{
   RabbitTemplate rabbitTemplate = new RabbitTemplate(getConnectionFactory());
   rabbitTemplate.setUseTemporaryReplyQueues(false);
   rabbitTemplate.setMessageConverter(getMessageConverter());
   rabbitTemplate.setMessagePropertiesConverter(getMessagePropertiesConverter());
   rabbitTemplate.setReplyAddress(AppConstants.REPLY_QUEUE_NAME);
   rabbitTemplate.setReceiveTimeout(60000);
   return rabbitTemplate;
}
 
 使用RabbitAdmin对象定义发送消息Exchange/Queue/Binding,返回消息Exchange/Queue/Binding对象，如果它们在RabbitMQ中已经存在，下面的定义代码可以省略.这里的Exchange/Queue名称和前面的消费者应用使用的相同。 
 
 
 
 
 
 
@Bean(name="springMessageQueue")    
public Queue createQueue(@Qualifier("rabbitAdmin")RabbitAdmin rabbitAdmin)
{
    Queue sendQueue = new Queue(AppConstants.SEND_QUEUE_NAME,true,false,false);
    rabbitAdmin.declareQueue(sendQueue);
    return sendQueue;
}
 
@Bean(name="springMessageExchange")
public Exchange createExchange(@Qualifier("rabbitAdmin")RabbitAdmin rabbitAdmin)
{
    DirectExchange sendExchange = new DirectExchange(AppConstants.SEND_EXCHANGE_NAME,true,false);
    rabbitAdmin.declareExchange(sendExchange);
    return sendExchange;
}
 
@Bean(name="springMessageBinding")
public Binding createMessageBinding(@Qualifier("rabbitAdmin")RabbitAdmin rabbitAdmin)
{
    Map<String,Object> arguments = new HashMap<String,Object>();
    Binding sendMessageBinding =
            new Binding(AppConstants.SEND_QUEUE_NAME, Binding.DestinationType.QUEUE,
                        AppConstants.SEND_EXCHANGE_NAME, AppConstants.SEND_MESSAGE_KEY, arguments);
    rabbitAdmin.declareBinding(sendMessageBinding);
    return sendMessageBinding;
}
 
@Bean(name="springReplyMessageQueue")
public Queue createReplyQueue(@Qualifier("rabbitAdmin")RabbitAdmin rabbitAdmin)
{
    Queue replyQueue = new Queue(AppConstants.REPLY_QUEUE_NAME,true,false,false);
    rabbitAdmin.declareQueue(replyQueue);
    return replyQueue;
}
 
@Bean(name="springReplyMessageExchange")
public Exchange createReplyExchange(@Qualifier("rabbitAdmin")RabbitAdmin rabbitAdmin)
{
    DirectExchange replyExchange = new DirectExchange(AppConstants.REPLY_EXCHANGE_NAME,true,false);
    rabbitAdmin.declareExchange(replyExchange);
    return replyExchange;
}
 
@Bean(name="springReplyMessageBinding")
public Binding createReplyMessageBinding(@Qualifier("rabbitAdmin")RabbitAdmin rabbitAdmin)
{
    Map<String,Object> arguments = new HashMap<String,Object>();
    Binding replyMessageBinding =
            new Binding(AppConstants.REPLY_QUEUE_NAME, Binding.DestinationType.QUEUE,
                        AppConstants.REPLY_EXCHANGE_NAME, AppConstants.REPLY_MESSAGE_KEY, arguments);
    rabbitAdmin.declareBinding(replyMessageBinding);
    return replyMessageBinding;
}
 
 最后定义接收返回消息的Message Listener Container,这里的Listener属性设置的是上面创建的RabbitTemplate对象。 
 
 
 
@Bean(name="replyMessageListenerContainer")
public SimpleMessageListenerContainer createReplyListenerContainer() {
     SimpleMessageListenerContainer listenerContainer = new SimpleMessageListenerContainer();
     listenerContainer.setConnectionFactory(getConnectionFactory());
     listenerContainer.setQueueNames(AppConstants.REPLY_QUEUE_NAME);
     listenerContainer.setMessageConverter(getMessageConverter());
     listenerContainer.setMessageListener(getRabbitTemplate());
     listenerContainer.setRabbitAdmin(getRabbitAdmin());
     listenerContainer.setAcknowledgeMode(AcknowledgeMode.AUTO);
     return listenerContainer;
}
 
 我们还定义了一个ThreadPoolExecutor对象，用于RabbitTemplate异步执行，发送和接收消息使用。 
 
 
 
@Bean(name="threadExecutor")
public ThreadPoolTaskExecutor createThreadPoolTaskExecutor()
{
    ThreadPoolTaskExecutor threadPoolTaskExecutor =
            new ThreadPoolTaskExecutor();
    threadPoolTaskExecutor.setCorePoolSize(5);
    threadPoolTaskExecutor.setMaxPoolSize(10);
    threadPoolTaskExecutor.setQueueCapacity(200);
    threadPoolTaskExecutor.setKeepAliveSeconds(20000);
    return threadPoolTaskExecutor;
}
 
 
 我们的生产者-消费者场景是系列1中提到的RPC方式计算阶乘，使用Rest接口调用生产者应用，生产者应用发送消息给消费者应用，计算出阶乘结果返回给生产者。  

 

 
 为了实现这个场景，我们先在生产者程序中定义用于发送请求消息和接收返回消息的服务接口SendMessageService和它的实现类SendMessageServiceImpl类。 
 
 

 

 
  
 
public interface SendMessageService
{
    String sendMessage(String message);
}
 
@Service("sendMessageService")
public class SendMessageServiceImpl implements SendMessageService
{
    @Autowired
    private ThreadPoolTaskExecutor executor;
 
    public String sendMessage(String message)
    {
        CompletableFuture<String> resultCompletableFuture =
                CompletableFuture.supplyAsync(new MQSenderSupplier(message), executor);
        try
        {
            String result = resultCompletableFuture.get();
            return result;
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        catch (ExecutionException e)
        {
            e.printStackTrace();
        }
        return null;
    }
}
 
 在实现类中，我们将发送请求消息和接收返回消息交给一个Supplier对象(JDK 1.8引入)在后台线程池中异步执行，我们自定义了MQSenderSupplier类，实现了发送请求和接收返回消息的操作。 

 

 
  
 
public class  MQSenderSupplier implements Supplier<String> {
 
    private String message;
 
    public MQSenderSupplier(String message)
    {
        this.message = message;
    }
 
    public String get()
    {
        Date sendTime = new Date();
        String correlationId = UUID.randomUUID().toString();
 
        MessagePropertiesConverter messagePropertiesConverter =
                (MessagePropertiesConverter) ApplicationContextUtil.getBean("messagePropertiesConverter");
 
        RabbitTemplate rabbitTemplate =
                 (RabbitTemplate)ApplicationContextUtil.getBean("rabbitTemplate");
 
        AMQP.Basic



                

        

        

    

  


        

            

                    
                      最低0.47元/天 解锁文章
                        
                    
            

        

    

      

        

            

              
                
                  丹奈
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
RabbitMQ：SpringAMQP研究

				
			

			

				

					流楚丶格念的博客
				

				

					07-13
					
					1476
					
				

			

		

		

			
				
SpringAMQP是基于RabbitMQ封装的一套模板，并且还利用SpringBoot对其实现了自动装配，使用起来非常方便。SpringAmqp的官方地址：https://spring.io/projects/spring-amqp
二话不说啊，翻译
AMQP（Advanced Message Queuing Protocol），是用于在应用程序之间传递业务消息的开放标准。该协议与语言和平台无关，更符合微服务中独立性的要求。

Spring AMQP是基于AMQP协议定义的一套API规范，提供了模板来发送

			
		

	



                

              
                



	

		

			

				
					
rocketmq-spring-boot-starter：rocketmq-spring-boot-starter

				
			

			

				

					01-30
				

			

		

		

			
				
rocketmq-spring-boot-starter
 阿里云RocketMQSpring图书版
支持功能：
 发送普通消息的三种模式：同步，异步和单向
 订阅消息群集，广播
 发送和接收顺序消息
 交易讯息
 延迟讯息
 接收和接收定时消息
定时消息和延迟消息：
 延迟消息和定时消息：在官方情况下，延迟新闻与常规新闻几乎相同，本质上是普通新闻。
 如果需要延迟消息和计时消息，建议使用计时任务（计时任务调度平台）
 以达到延迟或定时的目的。
交易留言：
 在框架中，对事务消息的操作越来越简单。 您只能通过注释来完成交易消息。
 无论是事务消息，分布式事务解决方案还是跨平台语言解决方案，事务解决方案的核心问题是确保可以发送消息，并且消费者可以使用它们。
 可靠性保证
1.添加@TransactionMessage批注，内核保证，本地事务错误，不发送消息，正确执行，发送消息，即默认提交。
 2.默认情况下采用可靠性保证，并核对默认提交。 原因来自先前的因素，该因素保证本地交易不会出错。
快速开始
<!-- Adding dependencies to pom. XML -->
    

			
		

	



                


  
              

                


	

		

			

				
					
使用spring-boot-starter-amqp开发生产者应用

				
			

			

				

					weixin_34259159的博客
				

				

					01-13
					
					484
					
				

			

		

		

			
				
上一篇我们介绍了如何使用spring AMQP和RabbitMQ结合，开发消费者应用程序，使用的是Xml配置的Spring框架。
本篇我们仍然使用Spring AMQP开发生产者应用，不过我们使用零 XML配置的Spring Boot环境进行开发，使用的库是spring-boot-starter-amqp库。
 
使用Spring-boot-starter-amqp搭建框架
我们使用Spr...

			
		

	





	

		

			

				
					
amqp协议java_RabbitMQ入门之spring-boot-starter-amqp<一>

				
			

			

				

					weixin_32809369的博客
				

				

					03-02
					
					759
					
				

			

		

		

			
				
在mac下可以使用brew install rabbitmq安装，其他系统大家可以查一下。由于RabbitMQ是采用Erlang编写的，所以我们是需要安装该语言库的。 使用默认用户guest登录，密码也为guest。 RabbitMQ是流行的开源消息队列系统，用erlang语言开发。RabbitMQ是AMQP(高级消息队列协议)的标准实现。在pom.xml中加入spring-boot-starte...

			
		

	



		

			
		



	

		

			

				
					
Springboot 集成 RabbitMQ (spring-boot-starter-amqp)

				
			

			

				

					一生一世一双人的博客
				

				

					06-29
					
					7721
					
				

			

		

		

			
				
Springboot 集成RabbitMQmaven依赖application.yml配置RabbitMQ配置一般队列配置死信队列配置消息发送消费者
maven依赖
 	<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version&

			
		

	





	

		

			

				
					
SpringAMQP

				
			

			

				

					Hello World
				

				

					09-11
					
					739
					
				

			

		

		

			
				
SpringAMQP

			
		

	





	

		

			

				
					
rabbitmq-priority-publisher:具有Spring Integration的示例Spring Boot应用程序可将消息发布到RabbitMQ

				
			

			

				

					05-07
				

			

		

		

			
				
标题中的“rabbitmq-priority-publisher”是一个基于Spring Boot的应用程序，它利用了Spring Integration框架来与RabbitMQ消息队列进行交互。这个项目的主要目的是展示如何在RabbitMQ中设置消息优先级，这对于处理...

			
		

	





	

		

			

				
					
spring-boot-mq-rabbitmq  一套打通rabbitmq  打开可用 有注释

				
			

			

				

					04-08
				

			

		

		

			
				
Spring Boot作为Java开发中的轻量级框架，简化了配置和集成各种技术，包括RabbitMQ。本套教程将详细介绍如何在Spring Boot项目中整合RabbitMQ，实现高效的消息传递。  首先，我们需要在Spring Boot项目中引入...

			
		

	





	

		

			

				
					
spring-boot-rabbitmqq.zip

				
			

			

				

					07-28
				

			

		

		

			
				
1. **Spring Boot的起步依赖（Starter Dependency）**：首先，你需要在Spring Boot项目的`pom.xml`或`build.gradle`文件中添加RabbitMQ的相关依赖，如`spring-boot-starter-amqp`，这将包含所有必要的RabbitMQ客户端...

			
		

	





	

		

			

				
					
SpringBoot-RabbitMQ：RabbitMQ为异步消息处理提出了一个很好的解决方案，它是一个非常好用的消息中间件，主要用于中间件的解压缩，同时，Spring Boot为RabbitMQ提供了支持，Spring Boot为兔子准备了spring-boot-starter-amqp，spring-rabbit支持AMQP（即高级消息队列协议，高级消息协议，是应用层协议的一个开放标准），并且为兔子模板和兔子MQ提供了自动配置选项

				
			

			

				

					01-29
				

			

		

		

			
				
SpringBoot-RabbitMQ消息层次
这个指南将引导你建立一个RabbitMQ AMQP服务器发布和订阅消息的过程。
声明
可以使用本人阿里云安装好的RabbitMQ服务器
host:http://120.27.114.229
username:root 
password:root
port:5672
web management: http://120.27.114.229:15672
建立
你会使用Spring AMQP的RabbitTemplate内置应用系统来发布消息和使用一个MessageListenerAdapter POJO来订阅消息
git克隆
 gradle bootRun
需要
大约几十分钟
一款文本编辑器或者IDE
你也可以从这个项目中入门代码或者可以在入门 （个人非常喜欢的一件eclipse的IDE）中查看
RabbitMQ服务器
如何完成
像许多的Spring 项目，你可以从头开始并完成每一步，或者你可以绕过你已经熟悉的一些步骤，无论是哪种步骤，你最终可以完成代码
从头开始的话，请去看内置
如果要绕过你熟悉的，按照以下合并：
并解压得到源代码或者从

			
		

	





	

		

			

				
					
自定义消息队列组件 mq-spring-boot-starter

				
			

			

				

					gzt19881123的专栏
				

				

					07-05
					
					1446
					
				

			

		

		

			
				
这里写自定义目录标题为什么要自定义消息队列组件 mq-spring-boot-starter准备工作架构构思消息对象抽取消息订阅和发布者抽取如何使用
为什么要自定义消息队列组件 mq-spring-boot-starter
考虑到公司同一套系统能支持阿里云上部署和客户内网部署，业务代码不修改的情况下，只修改yml文件配置属性即可迁移。
本文主要针对RocketMq 进行构建，后期增加 RabbitMq的支持。
本组件源码：
https://github.com/dwhgygzt/mq-spring-boot

			
		

	





	

		

			

				
					
SpringAMQP简介及简单使用

				
			

			

				

					yueyue763184的博客
				

				

					11-23
					
					1275
					
				

			

		

		

			
				
SpringAMQP是基于RabbitMQ封装的一套模板，并且还利用SpringBoot对其实现了自动装配，使用起来非常方便。

			
		

	





	

		

			

				
					
Java实战：Spring Boot集成AMQP协议的RabbitMQ实现消息队列

					
最新发布

				
			

			

				

					oandy0的博客
				

				

					02-29
					
					1082
					
				

			

		

		

			
				
本文将带领大家深入了解如何在Spring Boot项目中无缝集成RabbitMQ，实现高效的消息传递。

			
		

	





	

		

			

				
					
RabbitMQ之spring-boot-starter-amqp的应用

				
			

			

				

					zhj_1121的博客
				

				

					09-15
					
					7385
					
				

			

		

		

			
				
RabbitMQ—spring-boot-starter-amqp
前言

上一篇 RabbitMQ 已对RabbitMQ和AMQP的概念进行了学习
这一篇的目的主要是使用Spring Boot的spring-boot-starter-amqp整合RabbitMQ，以达到加深理解的目的。

时间线
2020.09.14-2020.09.15——完成初稿
参考链接
RabbitMQ系列
Springboot 整合RabbitMq ，用心看完这一篇就够了
流程
引入依赖->配置->编码
引入依赖
使

			
		

	





	

		

			

				
					
SpringBoot AMQP

				
			

			

				

					大漠知秋的加油站
				

				

					07-07
					
					7505
					
				

			

		

		

			
				
SpringBoot 已经提供了对 AMQP 协议完全支持的  依赖，引入此依赖即可快速方便的在 SpringBoot 中使用 RabbitMQ。参考：Spring AMQP。

声明式实现（推荐）

注意，以上配置再启动 SpringBoot 并不会立马创建交换机、队列、绑定，SpringBoot AMQP 有懒加载，需要等到使用  时才会创建。什么是使用  呢？

再比如监听了队列


死信队列机制
死信队列需要在创建 Queue 时指定对应属性：
RabbitTemplate
 是 SpringBoo

			
		

	





	

		

			

				
					
手把手带你 SpringBoot 2.X 整合 rocketmq-spring-boot-starter 2.2.0

				
			

			

				

					不会吉他的肌肉男不是好的挨踢男的专栏
				

				

					04-22
					
					2238
					
				

			

		

		

			
				
我的springboot的版本是2.1.3

1 安装RocketMq并启动
参考我之前的文章 Windows环境下单机安装RocketMQ
2 开始整合
先看一下大概的目录


2.1 引入maven库

      <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-spring-boot-starter</.

			
		

	





	

		

			

				
					
第二十四章 SpringBoot Starter POM

				
			

			

				

					死牛胖子的技术随笔
				

				

					02-23
					
					834
					
				

			

		

		

			
				
SpringBoot为我们提供了简化企业级开发绝大多数场景的Starter POM，只要使用应用场景所需要的Starter POM，相关的技术配置将会消除，就可以得到SpringBoot为我们提供的自动配置的Bean。
spring-boot-starter：SpringBoot核心starter，包含自动配置、日志、yaml配置文件的支持
spring-boot-starter-actuator：

			
		

	





	

		

			

				
					
2. 新建一个Spring Boot框架项目作为消息生产者，项目名为“rabbitmq_producer”，框架中需要集成Web开发。 （1）添加RabbitMQ依赖（spring-boot-starter-amqp）和Thymeleaf依赖(spring-boot-starter-thymeleaf) （2）在application.properties配置文件中添加RabbitMQ消息服务连接相关配置 （3）创建消息代理配置类，完成交换器（Exchange）、队列（sms_queue、email_qu

				
			

			

				

					06-02
				

			

		

		

			
				
eue）和绑定（Binding）的配置。以下是示例代码：

```
@Configuration
public class RabbitMQConfig {

    // 定义交换器名称
    public static final String EXCHANGE_NAME = "my_exchange";

    // 定义队列名称
    public static final String SMS_QUEUE_NAME = "sms_queue";
    public static final String EMAIL_QUEUE_NAME = "email_queue";

    // 定义路由键
    public static final String SMS_ROUTING_KEY = "sms";
    public static final String EMAIL_ROUTING_KEY = "email";

    // 配置交换器
    @Bean
    public DirectExchange directExchange() {
        return new DirectExchange(EXCHANGE_NAME);
    }

    // 配置短信队列
    @Bean
    public Queue smsQueue() {
        return new Queue(SMS_QUEUE_NAME);
    }

    // 配置邮件队列
    @Bean
    public Queue emailQueue() {
        return new Queue(EMAIL_QUEUE_NAME);
    }

    // 配置短信队列绑定
    @Bean
    public Binding smsBinding() {
        return BindingBuilder.bind(smsQueue()).to(directExchange()).with(SMS_ROUTING_KEY);
    }

    // 配置邮件队列绑定
    @Bean
    public Binding emailBinding() {
        return BindingBuilder.bind(emailQueue()).to(directExchange()).with(EMAIL_ROUTING_KEY);
    }

}
```

在上述代码中，我们使用了Direct交换器，定义了sms_queue和email_queue两个队列，以及sms和email两个路由键。我们还通过@Bean注解将它们配置到Spring容器中。

接下来，我们需要在application.properties中添加RabbitMQ连接配置：

```
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
```

最后，我们需要实现一个消息生产者Controller，示例代码如下：

```
@RestController
public class MessageController {

    @Autowired
    private AmqpTemplate amqpTemplate;

    @GetMapping("/sendSms")
    public String sendSms() {
        String message = "Hello, this is a SMS message!";
        amqpTemplate.convertAndSend(RabbitMQConfig.EXCHANGE_NAME, RabbitMQConfig.SMS_ROUTING_KEY, message);
        return "Send SMS message: " + message;
    }

    @GetMapping("/sendEmail")
    public String sendEmail() {
        String message = "Hello, this is an email message!";
        amqpTemplate.convertAndSend(RabbitMQConfig.EXCHANGE_NAME, RabbitMQConfig.EMAIL_ROUTING_KEY, message);
        return "Send email message: " + message;
    }

}
```

在上述代码中，我们使用了AmqpTemplate接口的convertAndSend方法将消息发送到RabbitMQ中。通过访问/sendSms和/sendEmail接口，我们可以向sms_queue和email_queue发送消息。

以上就是一个简单的Spring Boot + RabbitMQ消息生产者的实现。希望对你有所帮助！

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		
评论 8

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值