`

spring boot实战(第十二篇)整合RabbitMQ

spring bootrabbit mq 
阅读更多

前言

本篇主要讲述spring Boot与RabbitMQ的整合，内容非常简单，纯API的调用操作。 操作之间需要加入依赖Jar

 

[html]
  1. <dependency>  
  2. <groupId>org.springframework.boot</groupId>  
  3. <artifactId>spring-boot-starter-amqp</artifactId>  
  4. lt;/dependency>  
			<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-amqp</artifactId>
		</dependency>

 

消息生产者

不论是创建消息消费者或生产者都需要ConnectionFactory
 
 

ConnectionFactory配置

创建AmqpConfig文件AmqpConfig.java(后期的配置都在该文件中)
 
[html]
  1. @Configuration  
  2. public class AmqpConfig {  
  3.   
  4.     public static final String EXCHANGE   = "spring-boot-exchange";  
  5.     public static final String ROUTINGKEY = "spring-boot-routingKey";  
  6.   
  7.     @Bean  
  8.     public ConnectionFactory connectionFactory() {  
  9.         CachingConnectionFactory connectionFactory = new CachingConnectionFactory();  
  10.         connectionFactory.setAddresses("127.0.0.1:5672");  
  11.         connectionFactory.setUsername("guest");  
  12.         connectionFactory.setPassword("guest");  
  13.         connectionFactory.setVirtualHost("/");  
  14.         connectionFactory.setPublisherConfirms(true); //必须要设置  
  15.         return connectionFactory;  
  16.     }  
  17. }  
@Configuration
public class AmqpConfig {

    public static final String EXCHANGE   = "spring-boot-exchange";
    public static final String ROUTINGKEY = "spring-boot-routingKey";

    @Bean
    public ConnectionFactory connectionFactory() {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setAddresses("127.0.0.1:5672");
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        connectionFactory.setVirtualHost("/");
        connectionFactory.setPublisherConfirms(true); //必须要设置
        return connectionFactory;
    }
}

这里需要显示调用
[html]
  1. connectionFactory.setPublisherConfirms(true);  
 connectionFactory.setPublisherConfirms(true);
才能进行消息的回调。
 
 

RabbitTemplate

通过使用RabbitTemplate来对开发者提供API操作
[html]
  1. @Bean  
  2. @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)  
  3. //必须是prototype类型  
  4. public RabbitTemplate rabbitTemplate() {  
  5.     RabbitTemplate template = new RabbitTemplate(connectionFactory());  
  6.     return template;  
  7. }  
    @Bean
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    //必须是prototype类型
    public RabbitTemplate rabbitTemplate() {
        RabbitTemplate template = new RabbitTemplate(connectionFactory());
        return template;
    }
这里设置为原型，具体的原因在后面会讲到
  在发送消息时通过调用RabbitTemplate中的如下方法
[html]
  1. public void convertAndSend(String exchange, String routingKey, final Object object, CorrelationData correlationData)  
public void convertAndSend(String exchange, String routingKey, final Object object, CorrelationData correlationData)
  • exchange:交换机名称

  • routingKey:路由关键字

  • object:发送的消息内容

  • correlationData:消息ID

 
因此生产者代码详单简洁

Send.java

[html]
  1. @Component  
  2. public class Send  {  
  3.   
  4.     private RabbitTemplate rabbitTemplate;  
  5.   
  6.     /**  
  7.      * 构造方法注入  
  8.      */  
  9.     @Autowired  
  10.     public Send(RabbitTemplate rabbitTemplate) {  
  11.         this.rabbitTemplate = rabbitTemplate;  
  12.     }  
  13.   
  14.     public void sendMsg(String content) {  
  15.         CorrelationData correlationId = new CorrelationData(UUID.randomUUID().toString());  
  16.         rabbitTemplate.convertAndSend(AmqpConfig.EXCHANGE, AmqpConfig.ROUTINGKEY, content, correlationId);  
  17.     }  
  18.   
  19.        
  20. }  
@Component
public class Send  {

    private RabbitTemplate rabbitTemplate;

    /**
     * 构造方法注入
     */
    @Autowired
    public Send(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
    }

    public void sendMsg(String content) {
        CorrelationData correlationId = new CorrelationData(UUID.randomUUID().toString());
        rabbitTemplate.convertAndSend(AmqpConfig.EXCHANGE, AmqpConfig.ROUTINGKEY, content, correlationId);
    }

     
}

 

如果需要在生产者需要消息发送后的回调，需要对rabbitTemplate设置ConfirmCallback对象，由于不同的生产者需要对应不同的ConfirmCallback，如果rabbitTemplate设置为单例bean，则所有的rabbitTemplate

实际的ConfirmCallback为最后一次申明的ConfirmCallback。

下面给出完整的生产者代码：

 

[html]
  1. package com.u51.lkl.springboot.amqp;  
  2.   
  3. import java.util.UUID;  
  4.   
  5. import org.springframework.amqp.rabbit.core.RabbitTemplate;  
  6. import org.springframework.amqp.rabbit.support.CorrelationData;  
  7. import org.springframework.beans.factory.annotation.Autowired;  
  8. import org.springframework.stereotype.Component;  
  9.   
  10. /**  
  11.  * 消息生产者  
  12.  *   
  13.  * @author liaokailin  
  14.  * @version $Id: Send.java, v 0.1 2015年11月01日 下午4:22:25 liaokailin Exp $  
  15.  */  
  16. @Component  
  17. public class Send implements RabbitTemplate.ConfirmCallback {  
  18.   
  19.     private RabbitTemplate rabbitTemplate;  
  20.   
  21.     /**  
  22.      * 构造方法注入  
  23.      */  
  24.     @Autowired  
  25.     public Send(RabbitTemplate rabbitTemplate) {  
  26.         this.rabbitTemplate = rabbitTemplate;  
  27.         rabbitTemplate.setConfirmCallback(this); //rabbitTemplate如果为单例的话，那回调就是最后设置的内容  
  28.     }  
  29.   
  30.     public void sendMsg(String content) {  
  31.         CorrelationData correlationId = new CorrelationData(UUID.randomUUID().toString());  
  32.         rabbitTemplate.convertAndSend(AmqpConfig.EXCHANGE, AmqpConfig.ROUTINGKEY, content, correlationId);  
  33.     }  
  34.   
  35.     /**  
  36.      * 回调  
  37.      */  
  38.     @Override  
  39.     public void confirm(CorrelationData correlationData, boolean ack, String cause) {  
  40.         System.out.println(" 回调id:" + correlationData);  
  41.         if (ack) {  
  42.             System.out.println("消息成功消费");  
  43.         } else {  
  44.             System.out.println("消息消费失败:" + cause);  
  45.         }  
  46.     }  
  47.   
  48. }  
package com.u51.lkl.springboot.amqp;

import java.util.UUID;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.support.CorrelationData;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * 消息生产者
 * 
 * @author liaokailin
 * @version $Id: Send.java, v 0.1 2015年11月01日 下午4:22:25 liaokailin Exp $
 */
@Component
public class Send implements RabbitTemplate.ConfirmCallback {

    private RabbitTemplate rabbitTemplate;

    /**
     * 构造方法注入
     */
    @Autowired
    public Send(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
        rabbitTemplate.setConfirmCallback(this); //rabbitTemplate如果为单例的话，那回调就是最后设置的内容
    }

    public void sendMsg(String content) {
        CorrelationData correlationId = new CorrelationData(UUID.randomUUID().toString());
        rabbitTemplate.convertAndSend(AmqpConfig.EXCHANGE, AmqpConfig.ROUTINGKEY, content, correlationId);
    }

    /**
     * 回调
     */
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        System.out.println(" 回调id:" + correlationData);
        if (ack) {
            System.out.println("消息成功消费");
        } else {
            System.out.println("消息消费失败:" + cause);
        }
    }

}

 

消息消费者

消费者负责申明交换机(生产者也可以申明)、队列、两者的绑定操作。

交换机

[html]
  1. /**  
  2.      * 针对消费者配置  
  3.         FanoutExchange: 将消息分发到所有的绑定队列，无routingkey的概念  
  4.         HeadersExchange ：通过添加属性key-value匹配  
  5.         DirectExchange:按照routingkey分发到指定队列  
  6.         TopicExchange:多关键字匹配  
  7.      */  
  8.     @Bean  
  9.     public DirectExchange defaultExchange() {  
  10.         return new DirectExchange(EXCHANGE);  
  11.     }  
/**
     * 针对消费者配置
        FanoutExchange: 将消息分发到所有的绑定队列，无routingkey的概念
        HeadersExchange ：通过添加属性key-value匹配
        DirectExchange:按照routingkey分发到指定队列
        TopicExchange:多关键字匹配
     */
    @Bean
    public DirectExchange defaultExchange() {
        return new DirectExchange(EXCHANGE);
    }

在Spring Boot中交换机继承AbstractExchange类
 

 

队列

 
[html] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. @Bean  
  2.     public Queue queue() {  
  3.         return new Queue("spring-boot-queue", true); //队列持久  
  4.   
  5.     }  
@Bean
    public Queue queue() {
        return new Queue("spring-boot-queue", true); //队列持久

    }

绑定

[html] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. @Bean  
  2.   public Binding binding() {  
  3.       return BindingBuilder.bind(queue()).to(defaultExchange()).with(AmqpConfig.ROUTINGKEY);  
  4.   }  
  @Bean
    public Binding binding() {
        return BindingBuilder.bind(queue()).to(defaultExchange()).with(AmqpConfig.ROUTINGKEY);
    }
完成以上工作后，在spring boot中通过消息监听容器实现消息的监听，在消息到来时执行回调操作。
 

消息消费

[html]
  1. @Bean  
  2.   public SimpleMessageListenerContainer messageContainer() {  
  3.       SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory());  
  4.       container.setQueues(queue());  
  5.       container.setExposeListenerChannel(true);  
  6.       container.setMaxConcurrentConsumers(1);  
  7.       container.setConcurrentConsumers(1);  
  8.       container.setAcknowledgeMode(AcknowledgeMode.MANUAL); //设置确认模式手工确认  
  9.       container.setMessageListener(new ChannelAwareMessageListener() {  
  10.   
  11.           @Override  
  12.           public void onMessage(Message message, Channel channel) throws Exception {  
  13.               byte[] body = message.getBody();  
  14.               System.out.println("receive msg : " + new String(body));  
  15.               channel.basicAck(message.getMessageProperties().getDeliveryTag(), false); //确认消息成功消费  
  16.           }  
  17.       });  
  18.       return container;  
  19.   }  
  @Bean
    public SimpleMessageListenerContainer messageContainer() {
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory());
        container.setQueues(queue());
        container.setExposeListenerChannel(true);
        container.setMaxConcurrentConsumers(1);
        container.setConcurrentConsumers(1);
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL); //设置确认模式手工确认
        container.setMessageListener(new ChannelAwareMessageListener() {

            @Override
            public void onMessage(Message message, Channel channel) throws Exception {
                byte[] body = message.getBody();
                System.out.println("receive msg : " + new String(body));
                channel.basicAck(message.getMessageProperties().getDeliveryTag(), false); //确认消息成功消费
            }
        });
        return container;
    }

下面给出完整的配置文件：
 
[html] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. package com.u51.lkl.springboot.amqp;  
  2.   
  3. import org.springframework.amqp.core.AcknowledgeMode;  
  4. import org.springframework.amqp.core.Binding;  
  5. import org.springframework.amqp.core.BindingBuilder;  
  6. import org.springframework.amqp.core.DirectExchange;  
  7. import org.springframework.amqp.core.Message;  
  8. import org.springframework.amqp.core.Queue;  
  9. import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;  
  10. import org.springframework.amqp.rabbit.connection.ConnectionFactory;  
  11. import org.springframework.amqp.rabbit.core.ChannelAwareMessageListener;  
  12. import org.springframework.amqp.rabbit.core.RabbitTemplate;  
  13. import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;  
  14. import org.springframework.beans.factory.config.ConfigurableBeanFactory;  
  15. import org.springframework.context.annotation.Bean;  
  16. import org.springframework.context.annotation.Configuration;  
  17. import org.springframework.context.annotation.Scope;  
  18.   
  19. import com.rabbitmq.client.Channel;  
  20.   
  21. /**  
  22.  * Qmqp Rabbitmq  
  23.  *   
  24.  * http://docs.spring.io/spring-amqp/docs/1.4.5.RELEASE/reference/html/  
  25.  *   
  26.  * @author lkl  
  27.  * @version $Id: AmqpConfig.java, v 0.1 2015年11月01日 下午2:05:37 lkl Exp $  
  28.  */  
  29.   
  30. @Configuration  
  31. public class AmqpConfig {  
  32.   
  33.     public static final String EXCHANGE   = "spring-boot-exchange";  
  34.     public static final String ROUTINGKEY = "spring-boot-routingKey";  
  35.   
  36.     @Bean  
  37.     public ConnectionFactory connectionFactory() {  
  38.         CachingConnectionFactory connectionFactory = new CachingConnectionFactory();  
  39.         connectionFactory.setAddresses("127.0.0.1:5672");  
  40.         connectionFactory.setUsername("guest");  
  41.         connectionFactory.setPassword("guest");  
  42.         connectionFactory.setVirtualHost("/");  
  43.         connectionFactory.setPublisherConfirms(true); //必须要设置  
  44.         return connectionFactory;  
  45.     }  
  46.   
  47.     @Bean  
  48.     @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)  
  49.     //必须是prototype类型  
  50.     public RabbitTemplate rabbitTemplate() {  
  51.         RabbitTemplate template = new RabbitTemplate(connectionFactory());  
  52.         return template;  
  53.     }  
  54.   
  55.     /**  
  56.      * 针对消费者配置  
  57.      * 1. 设置交换机类型  
  58.      * 2. 将队列绑定到交换机  
  59.      *   
  60.      *   
  61.         FanoutExchange: 将消息分发到所有的绑定队列，无routingkey的概念  
  62.         HeadersExchange ：通过添加属性key-value匹配  
  63.         DirectExchange:按照routingkey分发到指定队列  
  64.         TopicExchange:多关键字匹配  
  65.      */  
  66.     @Bean  
  67.     public DirectExchange defaultExchange() {  
  68.         return new DirectExchange(EXCHANGE);  
  69.     }  
  70.   
  71.     @Bean  
  72.     public Queue queue() {  
  73.         return new Queue("spring-boot-queue", true); //队列持久  
  74.   
  75.     }  
  76.   
  77.     @Bean  
  78.     public Binding binding() {  
  79.         return BindingBuilder.bind(queue()).to(defaultExchange()).with(AmqpConfig.ROUTINGKEY);  
  80.     }  
  81.   
  82.     @Bean  
  83.     public SimpleMessageListenerContainer messageContainer() {  
  84.         SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory());  
  85.         container.setQueues(queue());  
  86.         container.setExposeListenerChannel(true);  
  87.         container.setMaxConcurrentConsumers(1);  
  88.         container.setConcurrentConsumers(1);  
  89.         container.setAcknowledgeMode(AcknowledgeMode.MANUAL); //设置确认模式手工确认  
  90.         container.setMessageListener(new ChannelAwareMessageListener() {  
  91.   
  92.             @Override  
  93.             public void onMessage(Message message, Channel channel) throws Exception {  
  94.                 byte[] body = message.getBody();  
  95.                 System.out.println("receive msg : " + new String(body));  
  96.                 channel.basicAck(message.getMessageProperties().getDeliveryTag(), false); //确认消息成功消费  
  97.             }  
  98.         });  
  99.         return container;  
  100.     }  
  101.   
  102. }  
package com.u51.lkl.springboot.amqp;

import org.springframework.amqp.core.AcknowledgeMode;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.ChannelAwareMessageListener;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
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;

import com.rabbitmq.client.Channel;

/**
 * Qmqp Rabbitmq
 * 
 * http://docs.spring.io/spring-amqp/docs/1.4.5.RELEASE/reference/html/
 * 
 * @author lkl
 * @version $Id: AmqpConfig.java, v 0.1 2015年11月01日 下午2:05:37 lkl Exp $
 */

@Configuration
public class AmqpConfig {

    public static final String EXCHANGE   = "spring-boot-exchange";
    public static final String ROUTINGKEY = "spring-boot-routingKey";

    @Bean
    public ConnectionFactory connectionFactory() {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setAddresses("127.0.0.1:5672");
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        connectionFactory.setVirtualHost("/");
        connectionFactory.setPublisherConfirms(true); //必须要设置
        return connectionFactory;
    }

    @Bean
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    //必须是prototype类型
    public RabbitTemplate rabbitTemplate() {
        RabbitTemplate template = new RabbitTemplate(connectionFactory());
        return template;
    }

    /**
     * 针对消费者配置
     * 1. 设置交换机类型
     * 2. 将队列绑定到交换机
     * 
     * 
        FanoutExchange: 将消息分发到所有的绑定队列，无routingkey的概念
        HeadersExchange ：通过添加属性key-value匹配
        DirectExchange:按照routingkey分发到指定队列
        TopicExchange:多关键字匹配
     */
    @Bean
    public DirectExchange defaultExchange() {
        return new DirectExchange(EXCHANGE);
    }

    @Bean
    public Queue queue() {
        return new Queue("spring-boot-queue", true); //队列持久

    }

    @Bean
    public Binding binding() {
        return BindingBuilder.bind(queue()).to(defaultExchange()).with(AmqpConfig.ROUTINGKEY);
    }

    @Bean
    public SimpleMessageListenerContainer messageContainer() {
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory());
        container.setQueues(queue());
        container.setExposeListenerChannel(true);
        container.setMaxConcurrentConsumers(1);
        container.setConcurrentConsumers(1);
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL); //设置确认模式手工确认
        container.setMessageListener(new ChannelAwareMessageListener() {

            @Override
            public void onMessage(Message message, Channel channel) throws Exception {
                byte[] body = message.getBody();
                System.out.println("receive msg : " + new String(body));
                channel.basicAck(message.getMessageProperties().getDeliveryTag(), false); //确认消息成功消费
            }
        });
        return container;
    }

}


以上完成 Spring Boot与RabbitMQ的整合 
动配置
在Spring Boot中实现了RabbitMQ的自动配置，在配置文件中添加如下配置信息
[html]
  1. spring.rabbitmq.host=localhost  
  2. spring.rabbitmq.port=5672  
  3. spring.rabbitmq.username=test  
  4. spring.rabbitmq.password=test  
  5. spring.rabbitmq.virtualHost=test  
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=test
spring.rabbitmq.password=test
spring.rabbitmq.virtualHost=test

后会自动创建ConnectionFactory以及RabbitTemplate对应Bean，为什么上面我们还需要手动什么呢?
 
自动创建的ConnectionFactory无法完成事件的回调，即没有设置下面的代码
[html]
  1. connectionFactory.setPublisherConfirms(true);  
connectionFactory.setPublisherConfirms(true);
具体分析见后续文章的源码解读.
转载：http://blog.csdn.net/liaokailin/article/details/49559571
 
分享到：
| 开涛博客分享
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Spring Boot实战派（源码）

    《Spring Boot实战派》源码提供了丰富的学习材料，旨在帮助开发者深入理解并熟练掌握Spring Boot这一流行的Java后端开发框架。Spring Boot简化了Spring应用程序的初始设置和配置，使得开发人员能够快速构建可运行的...

    spring-boot实战PDF 完整版和随书源码.7z

    《Spring Boot实战》是一本深度剖析Spring Boot框架的实践指南，旨在帮助开发者快速掌握Spring Boot的核心概念和技术。这本书深入浅出地介绍了如何使用Spring Boot构建高效、简洁的Java应用程序。随书源码提供了丰富...

    Spring Boot 整合 RabbitMQ 案例.zip

    Spring Boot 整合 RabbitMQ 案例.zipSpring Boot 整合 RabbitMQ 案例.zipSpring Boot 整合 RabbitMQ 案例.zipSpring Boot 整合 RabbitMQ 案例.zipSpring Boot 整合 RabbitMQ 案例.zipSpring Boot 整合 RabbitMQ 案例...

    JavaEE开发的颠覆者 Spring Boot实战 完整版.zip

    《Spring Boot实战》是针对JavaEE开发领域的一本权威指南，Spring Boot作为JavaEE开发的颠覆者，极大地简化了传统JavaEE应用的复杂性，提高了开发效率。这本书全面覆盖了Spring Boot的核心概念、配置以及实战应用，...

    RabbitMq与Spring整合实例

    将RabbitMQ与Spring整合，可以方便地在Spring应用中使用消息队列，实现异步通信和任务调度。 本实例主要介绍如何在Spring应用中集成RabbitMQ，构建一个完整的消息传递系统。首先，你需要确保已经安装了RabbitMQ...

    Spring Boot (5) 整合 RabbitMQ

    在本教程中，我们将深入探讨如何使用Spring Boot与RabbitMQ进行整合，以实现高效的消息队列通信。Spring Boot简化了Java应用的开发过程，而RabbitMQ则是一个流行的开源消息代理，它遵循AMQP（Advanced Message ...

    spring整合rabbitmq的实例

    在这里，我们使用`convertAndSend`方法发送消息，第一个参数是交换机名称，第二个是路由键，第三个是消息内容。 最后，创建消息消费者。定义一个带有`@RabbitListener`注解的方法来监听特定队列： ```java @...

    spring boot 完整版整合mybatis,rabbitmq,freemarker,redis等

    ### Spring Boot 整合 MyBatis、RabbitMQ、Freemarker、Redis 等技术栈详解 #### 一、Spring Boot 基础配置与动态属性解析 在 Spring Boot 应用中，配置文件（如 `application.properties` 或 `application.yml`）...

    Springboot整合RabbitMQ最简单demo

    Springboot整合RabbitMQ最简单demo,适用于springcloud项目,作为消息总线适用,需要安装RabbitMQ,Mac linux可以使用命令行一键安装,在项目配置文件配置好端口即可(已默认配置),启动项目访问8080端口,参数见controller.

    Spring Boot 教程、技术栈示例代码，快速简单上手教程。

    它集成了大量常用的第三方库配置，如 JDBC、MongoDB、RabbitMQ、Quartz 等，使得开发者可以“零配置”地启动项目，极大地提高了开发效率。 **1. Spring Boot 的核心特性** - **自动配置**：Spring Boot 通过扫描...

    Spring boot 示例 官方 Demo

    spring-boot-rabbitmq：spring boot和rabbitmq各种消息应用案例 spring-boot-scheduler：spring boot和定时任务案例 spring-boot-web：web开发综合使用案例 spring-boot-mail：spring boot和邮件服务 spring-boot-...

    SpringCloudStream整合RabbitMq

    **SpringCloudStream与RabbitMQ整合详解** SpringCloudStream是一个框架，它允许应用程序以声明式方式定义输入和输出绑定，从而简化与消息中间件的集成。在这个场景中，我们将讨论如何将SpringCloudStream与...

    springbootj集成canal+mysql+rabbitmq

    mysql需开启binlog 查看是否开启binlog ...3.3 rabbitmq配置 在virtualHost：/ 下新增Exchanges： canal.exchange 新增队列：test.queue, 绑定canal.queue， RoutingKey：canal.routing.key canal下载及配置 ...

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

    《Spring Boot整合RabbitMQ：实现消息队列与分布式通信》 在当今的微服务架构中，消息队列（Message Queue，MQ）扮演着至关重要的角色，它能够有效地解决系统间的异步通信、解耦以及扩展性问题。RabbitMQ作为一款...

    Spring Boot整合RabbitMQ开发实战详解

    Spring Boot 整合 RabbitMQ 开发实战详解 首先，需要了解 RabbitMQ 中的一些基本概念，包括交换器（Exchange）、队列（Queue）和绑定（Binding）。交换器就像路由器，把消息发到交换器，然后交换器再根据路由键...

    springBoot整合RabbitMQ案例

    在`pom.xml`文件中添加Spring AMQP和Spring Boot的RabbitMQ starter依赖： ```xml &lt;groupId&gt;org.springframework.boot &lt;artifactId&gt;spring-boot-starter-amqp ``` 接下来，配置RabbitMQ服务器的连接信息。在`...

    spring boot整合RabbitMQ（Direct模式）

    springboot集成RabbitMQ非常简单，如果只是简单的使用配置非常少，springboot提供了spring-boot-starter-amqp项目对消息各种...下面通过本文给大家介绍下spring boot整合RabbitMQ（Direct模式）,需要的朋友可以参考下

    基于Spring Boot + MySQL + Redis + RabbitMQ开发的秒杀系统.zip

    基于Spring Boot + MySQL + Redis + RabbitMQ开发的秒杀系统.zip

Magicbox
Global site tag (gtag.js) - Google Analytics