springboot simple （12） springboot RabbitMQ

怼烎@ 2024-03-30 13:12 86阅读 0赞

这里首先简单的介绍了RabbitMQ ，然后实现了springboot集成RabbitMQ ，包含两个工程：  
1 Producer 生产者  
2 Consumer 消费者

## 1 RabbitMQ 简介 ##

AMQP ：Advanced Message Queue，高级消息队列协议。  
RabbitMQ 是一个由 Erlang 语言开发的 AMQP 的开源实现。

RabbitMQ是一个生产者和消费者模型，用于实现消息的接收、存储、转发。  
模型如下图所示：  
![在这里插入图片描述][71c7a22a46f54ac0b063488465ea9de2.png]  
Producer 生产者  
Consumer 消费者  
Exchange 交换机  
Queue :队列,存储消息

常用的交换机Exchange  
1）fanout Exchange（扇形交换机）  
2）direct Exchange（直连交换机）  
3）topic Exchange（主题交换机）  
4）headers Exchange（头交换机）

## 2 springboot 集成RabbitMQ ##

第1步：pom中引入依赖的包：

<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-amqp</artifactId>
    			<version>3.0.1</version>
    		</dependency>

第2步：application.properties设置相关参数：

#rabbitmq相关配置
    spring.rabbitmq.host=127.0.0.1
    spring.rabbitmq.port=5672
    spring.rabbitmq.username=guest
    spring.rabbitmq.password=guest
    spring.rabbitmq.publisher-confirm-type=correlated
    spring.rabbitmq.publisher-returns=true
    spring.main.allow-bean-definition-overriding = true

### 2.1 fanout Exchange（扇形交换机） ###

特点：将消息路由到所有与该交换机绑定的队列中。  
![在这里插入图片描述][05350826a44241dfb6763ac3eb31c131.png]  
第1步：创建配置类FanoutConfig，创建了：  
交换机（exchange）：fanout\_exchange  
队列（Queue）：fanout\_queue\_A  
绑定（Binding）：fanoutBindA  
队列（Queue）：fanout\_queue\_B  
绑定（Binding）：fanoutBindB

@Configuration
    public class FanoutConfig {
        
        @Bean("fanout_exchange")
        public FanoutExchange fanoutExchange() {
        
            return ExchangeBuilder.fanoutExchange("fanout_exchange").durable(true).build();
        }
    
        @Bean("fanout_queue_A")
        public Queue fanoutQueueA(){
        
            return QueueBuilder.durable("fanout_queue_A").build();
        }
    
        @Bean
        public Binding fanoutBindA(){
        
            return BindingBuilder.bind(fanoutQueueA()).to(fanoutExchange());
        }
    
        @Bean("fanout_queue_B")
        public Queue fanoutQueueB(){
        
            return QueueBuilder.durable("fanout_queue_B").build();
        }
    
        @Bean
        public Binding fanoutBindB(){
        
            return BindingBuilder.bind(fanoutQueueB()).to(fanoutExchange());
        }
    }

第2步：Producer 项目创建发送消息的类FanoutService ：

@Slf4j
    @Service
    public class FanoutService {
        
        String exchange = "fanout_exchange";
    
        @Resource
        private RabbitTemplate rabbitTemplate;
    
        public void sendData(String data) {
        
            log.info("------------fanout producer begin------------");
            rabbitTemplate.convertAndSend(exchange, "", data);
            log.info("exchange:"+exchange);
            log.info("send data:"+data);
            log.info("------------fanout producer end------------");
        }
    }

第3步：Consumer 创建接收消息的类FanoutListener ：

@Component
    @Slf4j
    public class FanoutListener {
        
        /**
         * .接收队列fanout_queue_A的数据
         */
        @RabbitListener(queues = {
        "fanout_queue_A"})
        @RabbitHandler
        public void receiveDataFromQueueA(Message message, Channel channel) throws IOException {
        
            long tag = message.getMessageProperties().getDeliveryTag();
            channel.basicAck( tag, true);
            log.info("------------fanout consumer begin------------");
            log.info("queue: fanout_queue_A");
            log.info("receive Data: " + new String(message.getBody()));
            log.info("------------fanout consumer end------------");
        }
    
        /**
         * .接收队列fanout_queue_B的数据
         */
        @RabbitListener(queues = {
        "fanout_queue_B"})
        @RabbitHandler
        public void receiveDataFromQueueB(Message message, Channel channel) throws IOException {
        
            long tag = message.getMessageProperties().getDeliveryTag();
            channel.basicAck( tag, true);
            log.info("------------fanout consumer begin------------");
            log.info("queue: fanout_queue_B");
            log.info("receive Data: " + new String(message.getBody()));
            log.info("------------fanout consumer end------------");
        }
    }

### 2.2 direct Exchange（直连交换机） ###

特点：根据消息默认的路由键（队列名称）将消息投递到相应的队列中。  
![在这里插入图片描述][1e16d2017f9a401f9b4cbb402f6fe2c0.png]  
第1步：创建配置类DirectConfig，创建了：  
交换机（exchange）：direct\_exchange\_A  
队列（Queue）：direct\_queue\_A  
绑定（Binding）：directBindA

交换机（exchange）：direct\_exchange\_B  
队列（Queue）：direct\_queue\_B  
绑定（Binding）：directBindB

@Configuration
    public class DirectConfig {
        
        @Bean("direct_exchange_A")
        public DirectExchange directExchangeA() {
        
            return ExchangeBuilder.directExchange("direct_exchange_A").durable(true).build();
        }
    
        @Bean("direct_queue_A")
        public Queue directQueueA() {
        
            return QueueBuilder.durable("direct_queue_A").build();
        }
    
        @Bean
        public Binding directBindA(@Qualifier("direct_queue_A")Queue queue,
                                  @Qualifier("direct_exchange_A")DirectExchange directExchange){
        
            return BindingBuilder.bind(queue)
                    .to(directExchange).withQueueName();
        }
    
        @Bean("direct_exchange_B")
        public DirectExchange directExchangeB() {
        
            return ExchangeBuilder.directExchange("direct_exchange_B").durable(true).build();
        }
    
        @Bean("direct_queue_B")
        public Queue directQueueB() {
        
            return QueueBuilder.durable("direct_queue_B").build();
        }
    
        @Bean
        public Binding directBindB(@Qualifier("direct_queue_B")Queue queue,
                                   @Qualifier("direct_exchange_B")DirectExchange directExchange){
        
            return BindingBuilder.bind(queue)
                    .to(directExchange).withQueueName();
        }
    }

.withQueueName() 可见绑定key为queue名称。

第2步：Producer 项目创建发送消息的类DirectService ：

@Slf4j
    @Service
    public class DirectService {
        
        String routeKey = "direct_queue_A";
    
        @Autowired
        private RabbitTemplate rabbitTemplate;
    
        public void sendData(String data) {
        
            CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
            log.info("------------direct producer begin------------");
            rabbitTemplate.convertAndSend(routeKey, data);
            log.info("routeKey:"+routeKey);
            log.info("send data:"+data);
            log.info("------------direct producer end------------");
        }
    }

第3步：Consumer 创建接收消息的类DirectListener ：

@Component
    @Slf4j
    public class DirectListener {
        
    
        /**
         * .接收队列direct_queue_A的数据
         */
        @RabbitListener(queues = {
        "direct_queue_A"})
        public void receiveDataFromQueueA(Message message, Channel channel) throws IOException {
        
            long tag = message.getMessageProperties().getDeliveryTag();
            channel.basicAck(tag, true);
            log.info("------------direct consumer begin------------");
            log.info("queue: fanout_queue_A");
            log.info("receive Data: " + new String(message.getBody()));
            log.info("------------direct consumer end------------");
        }
    
        /**
         * .接收队列direct_queue_B的数据
         */
        @RabbitListener(queues = {
        "direct_queue_B"})
        public void receiveDataFromQueueB(Message message, Channel channel) throws IOException {
        
            long tag = message.getMessageProperties().getDeliveryTag();
            channel.basicAck(tag, true);
            log.info("------------direct consumer begin------------");
            log.info("queue: fanout_queue_B");
            log.info("receive Data: " + new String(message.getBody()));
            log.info("------------direct consumer end------------");
        }
    }

### 2.3 topic Exchange（主题交换机） ###

特点：将消息路由到路由键（RoutingKey）和绑定键（BindKey）相匹配的队列中。  
![在这里插入图片描述][3ed68983ea9c4c9cadf7293e3e63f77f.png]

第1步：创建配置类TopicConfig，创建了：  
交换机（exchange）：topic\_exchange  
队列（Queue）：topic\_queue\_A  
绑定（Binding）：topicBindA  
绑定key（BindKey）：project1.station1.\*  
交换机（exchange）：topic\_exchange  
队列（Queue）：topic\_queue\_B  
绑定（Binding）：topicBindB  
绑定key（BindKey）：project1.*.*"

@Configuration
    public class TopicConfig {
        
        String routeKeyA = "project1.station1.*";
        String routeKeyB = "project1.*.*";
    
        @Bean("topic_exchange")
        public TopicExchange topicExchange() {
        
            return ExchangeBuilder.topicExchange("topic_exchange").durable(true).build();
        }
    
        @Bean("topic_queue_A")
        public Queue topicQueueA(){
        
            return QueueBuilder.durable("topic_queue_A").build();
        }
    
        @Bean
        public Binding topicBindA(){
        
            return BindingBuilder.bind(topicQueueA()).to(topicExchange()).with(routeKeyA);
        }
    
        @Bean("topic_queue_B")
        public Queue topicQueueB(){
        
            return QueueBuilder.durable("topic_queue_B").build();
        }
    
        @Bean
        public Binding topicBindB(){
        
            return BindingBuilder.bind(topicQueueB()).to(topicExchange()).with(routeKeyB);
        }
    }

第2步：Producer 项目创建发送消息的类TopicService ：

@Slf4j
    @Service
    public class TopicService {
        
        String exchange = "topic_exchange";
        //String routeKey = "project1.station1.device1";
        String routeKey = "project1.station2.device1";
        @Resource
        private RabbitTemplate rabbitTemplate;
    
        public void sendData(String data) {
        
            CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
            log.info("------------topic producer begin------------");
            rabbitTemplate.convertAndSend(exchange, routeKey, data);
            log.info("routeKey:"+routeKey);
            log.info("send data:"+data);
            log.info("------------topic producer end------------");
        }
    }

第3步：Consumer 创建接收消息的类TopicListener ：

@Component
    @Slf4j
    public class TopicListener {
        
        /**
         * .接收队列topic_queue_A的数据
         */
        @RabbitListener(queues = {
        "topic_queue_A"})
        public void receiveDataFromQueueA(Message message, Channel channel) throws IOException {
        
            long tag = message.getMessageProperties().getDeliveryTag();
            channel.basicAck( tag, true);
            log.info("------------topic_ consumer begin------------");
            log.info("queue: topic_queue_A");
            log.info("receive Data: " + new String(message.getBody()));
            log.info("------------topic_ consumer end------------");
        }
    
        /**
         * .接收队列topic_queue_B的数据
         */
        @RabbitListener(queues = {
        "topic_queue_B"})
        public void receiveDataFromQueueB(Message message, Channel channel) throws IOException {
        
            long tag = message.getMessageProperties().getDeliveryTag();
            channel.basicAck( tag, true);
            log.info("------------topic_ consumer begin------------");
            log.info("queue: topic_queue_B");
            log.info("receive Data: " + new String(message.getBody()));
            log.info("------------topic_ consumer end------------");
        }
    }

### 2.4 headers Exchange（头交换机） ###

特点：路由规则是建立在头属性值之上，而不是路由键。  
![在这里插入图片描述][205120a8c2384a298f64352d4ee90a58.png]

第1步：创建配置类TopicConfig，创建了：  
交换机（exchange）：headers\_exchange  
队列（Queue）：headers\_queue\_A  
绑定（Binding）：headersBindA  
头（headers）：  
headerValues.put(“type”, “gass”);  
headerValues.put(“data”, “realTime”);  
匹配规则：whereAll

队列（Queue）：headers\_queue\_B  
绑定（Binding）：headersBindB  
头（headers）：  
headerValues.put(“type”, “gass”);  
headerValues.put(“data”, “realTime”);  
匹配规则：whereAny

@Configuration
    public class HeadersConfig {
        
    
        @Bean("headers_exchange")
        public HeadersExchange headersExchange() {
        
            return ExchangeBuilder.headersExchange("headers_exchange").durable(true).build();
        }
    
        @Bean("headers_queue_A")
        public Queue headerQueueA(){
        
            return QueueBuilder.durable("headers_queue_A").build();
        }
    
        @Bean
        public Binding headersBindA(){
        
            Map<String,Object> headerValues = new HashMap<>();
            headerValues.put("type", "gass");
            headerValues.put("data", "realTime");
            return BindingBuilder.bind(headerQueueA()).to(headersExchange()).whereAll(headerValues).match();
        }
    
        @Bean("headers_queue_B")
        public Queue headerQueueB(){
        
            return QueueBuilder.durable("headers_queue_B").build();
        }
    
        @Bean
        public Binding headersBindB(){
        
            Map<String,Object> headerValues = new HashMap<>();
            headerValues.put("type", "gass");
            headerValues.put("data", "realTime");
            return BindingBuilder.bind(headerQueueB()).to(headersExchange()).whereAny(headerValues).match();
        }
    }

第2步：Producer 项目创建发送消息的类HeadersService ：

@Slf4j
    @Service
    public class HeadersService {
        
        String exchange = "headers_exchange";
        String routeKey = "";
    
        @Resource
        private RabbitTemplate rabbitTemplate;
    
        public void sendData(String data) {
        
            log.info("------------headers producer begin------------");
            MessageProperties messageProperties = new MessageProperties();
            messageProperties.setHeader("type", "gass");
            messageProperties.setHeader("data", "realTime");
            //messageProperties.setHeader("data", "history");
            Message message = new Message(data.getBytes(), messageProperties);
            rabbitTemplate.convertAndSend(exchange, routeKey, message);
            log.info("send data:"+data);
            log.info("------------headers producer end------------");
        }
    }

第3步：Consumer 创建接收消息的类HeadersListener ：

@Component
    @Slf4j
    public class HeadersListener {
        
        /**
         * .接收队列headers_queue_A的数据
         */
        @RabbitListener(queues = {
        "headers_queue_A"})
        public void receiveDataFromQueueA(Message message, Channel channel) throws IOException {
        
            long tag = message.getMessageProperties().getDeliveryTag();
            channel.basicAck( tag, true);
            log.info("------------headers consumer begin------------");
            log.info("queue: headers_queue_A");
            log.info("receive Data: " + new String(message.getBody()));
            log.info("------------headers consumer begin------------");
        }
    
        /**
         * .接收队列headers_queue_B的数据
         */
        @RabbitListener(queues = {
        "headers_queue_B"})
        public void receiveDataFromQueueB(Message message, Channel channel) throws IOException {
        
            long tag = message.getMessageProperties().getDeliveryTag();
            channel.basicAck( tag, true);
            log.info("------------headers consumer begin------------");
            log.info("queue: headers_queue_B");
            log.info("receive Data: " + new String(message.getBody()));
            log.info("------------headers consumer begin------------");
        }
    }

## 3 测试验证 ##

### 3.1 fanout Exchange验证 ###

第1步：postman发送请求：  
http://127.0.0.1:8081/rabbitMq/sendMessageByFanout?msg=hello,fanout exchangge!  
![在这里插入图片描述][75967bffd01f409aa964f31581d63286.png]  
第2步：可以看到producer发送消息：  
![在这里插入图片描述][d3812a4081a94c2b8b562222ad65a838.png]  
第3步：可以看到consumer接收消息：  
![在这里插入图片描述][aa5d7b6e53e4405a85c447aa3db525c6.png]  
可见：与交换机fanout\_exchange绑定的两个队列fanout\_queue\_A、fanout\_queue\_B都收到了消息。

### 3.2 direct Exchange验证 ###

第1步：postman发送请求：  
http://127.0.0.1:8081/rabbitMq/sendMessageByDirect?msg=hello,direct exchangge!  
![在这里插入图片描述][6b23ec13ff054e39a37169369363054d.png]  
第2步：可以看到producer发送消息：  
![在这里插入图片描述][20ea327dd60d466587e021880e86d242.png]  
第3步：可以看到consumer接收消息：  
![在这里插入图片描述][5a5b70c74795410fb40f73b96fc395ec.png]  
可见：routeKey 和BindKey都为queue名称direct\_queue\_A，队列direct\_queue\_A收到了消息。

### 3.3 topic Exchange验证 ###

#### 3.3.1 topic\_queue\_A、topic\_queue\_B都匹配 ####

路由键（routeKey）：project1.station1.device1  
绑定key（BindKey）：project1.station1.\*  
绑定key（BindKey）：project1.*.*"

第1步：postman发送请求：  
http://127.0.0.1:8081/rabbitMq/sendMessageByTopic?msg=hello,topic exchangge!  
![在这里插入图片描述][52074dd79dd84fff8484bc74500b6331.png]  
第2步：可以看到producer发送消息：  
![在这里插入图片描述][6572027605bf42f4a4d91191a748de56.png]  
第3步：可以导刊consumer接收消息：  
![在这里插入图片描述][a91105c6327b4f129aa81eace111dc5a.png]  
可以看到两个队列 topic\_queue\_A、topic\_queue\_B都收到了消息。

#### 3.3.2 只有topic\_queue\_B匹配 ####

路由键（routeKey）：project1.station2.device1  
绑定key（BindKey）：project1.station1.\*  
绑定key（BindKey）：project1.*.*"

第1步：postman发送请求：  
http://127.0.0.1:8081/rabbitMq/sendMessageByTopic?msg=hello,topic exchangge!  
![在这里插入图片描述][6a1cebe2f8614cf9ad600dcd6f292078.png]  
第2步：可以看到producer发送消息：  
![在这里插入图片描述][423ccb0bff354c6b823eccd24f9a8a89.png]  
第3步：可以看到consumer接收消息：  
![在这里插入图片描述][657c48d691dc44a48f3fbcc699218d59.png]  
可以看到只有队列topic\_queue\_B收到了消息。

### 3.4 headers Exchange验证 ###

#### 3.4.1 headers\_queue\_A、headers\_queue\_B都匹配 ####

发送消息的header：

messageProperties.setHeader("type", "gass");
    messageProperties.setHeader("data", "realTime");

第1步：postman发送请求：  
http://127.0.0.1:8081/rabbitMq/sendMessageByHeaders?msg=hello,headers exchangge!  
![在这里插入图片描述][f8e8548786f248be9a6a34c212c3518c.png]  
第2步：可以看到producer发送消息：  
![在这里插入图片描述][5e2764e5d78145908af2adfb9ae9d45a.png]  
第3步：可以看到consumer接收消息：  
![在这里插入图片描述][e20568b4e1f64ed29760bf1576229b20.png]  
可见headers\_queue\_A、headers\_queue\_B都收到了消息。

#### 3.4.2 只有headers\_queue\_B匹配 ####

发送消息的header：

messageProperties.setHeader("type", "gass");
    messageProperties.setHeader("data", "history");

第1步：postman发送请求：  
http://127.0.0.1:8081/rabbitMq/sendMessageByHeaders?msg=hello,headers exchangge!  
![在这里插入图片描述][535cefd9fa5246c7924af017b1d22a3b.png]

第2步：可以看到producer发送消息：  
![在这里插入图片描述][cc907c9c420c4740b0345607259ab8d0.png]  
第3步：可以看到consumer接收消息：  
![在这里插入图片描述][3211fd4238114a24a81349b71054de7b.png]  
可见：只有headers\_queue\_B收到了消息。

代码详见：  
[https://gitee.com/linghufeixia/springboot-simple][https_gitee.com_linghufeixia_springboot-simple]  
chapter6-4 producer项目  
chapter6-5 consumer项目

--------------------

**教程列表**：  
[springboot simple（0） springboot简介][springboot simple_0_ springboot]  
[springboot simple（1） springboot Helloworld][springboot simple_1_ springboot Helloworld]  
[springboot simple（2） springboot Starter][springboot simple_2_ springboot Starter]  
[springboot simple（3 ）springboot Web开发][springboot simple_3 _springboot Web]  
[springboot simple（4）springboot 数据持久化][springboot simple_4_springboot]  
[springboot simple （5） springboot Nosql][springboot simple _5_ springboot Nosql]  
[springboot simple （6） springboot mqtt][springboot simple _6_ springboot mqtt]  
[springboot simple （7） springboot thrift][springboot simple _7_ springboot thrift]  
[springboot simple （8） springboot kafka][springboot simple _8_ springboot kafka]  
[springboot simple （9） springboot jpa（Hibernate）][springboot simple _9_ springboot jpa_Hibernate]  
[springboot simple （10） springboot protobuf][springboot simple _10_ springboot protobuf]  
[springboot simple （11） springboot protostuff][springboot simple _11_ springboot protostuff]  
[springboot simple （12） springboot RabbitMQ][springboot simple _12_ springboot RabbitMQ]

[71c7a22a46f54ac0b063488465ea9de2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/2dcc71a7229d43dd8bcb5755bc42de74.png
[05350826a44241dfb6763ac3eb31c131.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/ddb7b32f23db41b492e2fc4a4aa8e503.png
[1e16d2017f9a401f9b4cbb402f6fe2c0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/79cd47a05b2849d0ae319b2dc58f836d.png
[3ed68983ea9c4c9cadf7293e3e63f77f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/28c2269b828d4566bfe0178dba993cd2.png
[205120a8c2384a298f64352d4ee90a58.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/4926d92074e94c5cbaea08ce97215672.png
[75967bffd01f409aa964f31581d63286.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/3f73a8253aeb434ea852af2dd6b56183.png
[d3812a4081a94c2b8b562222ad65a838.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/1762d18e3f9f42f4ba52a6073874aa3f.png
[aa5d7b6e53e4405a85c447aa3db525c6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/47cb2b7490624658b5544f5cfc19d627.png
[6b23ec13ff054e39a37169369363054d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/8a570c8b639b46aca2945d60823d9594.png
[20ea327dd60d466587e021880e86d242.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/728a91e4aacf49ffa7fb9123b7d66e15.png
[5a5b70c74795410fb40f73b96fc395ec.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/65000cbef4e14f148c1266ed45879bbc.png
[52074dd79dd84fff8484bc74500b6331.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/2782cca5d35446ee9e323f84b8703824.png
[6572027605bf42f4a4d91191a748de56.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/5c6e24c0de8a4dc7af39a059fb6ec4e5.png
[a91105c6327b4f129aa81eace111dc5a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/8c151872ce6d436ba5b940056d274bc2.png
[6a1cebe2f8614cf9ad600dcd6f292078.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/d3f0130f474d41df89a56d4a77f12252.png
[423ccb0bff354c6b823eccd24f9a8a89.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/822f7878ac8c4722a7b9438040c9b2c4.png
[657c48d691dc44a48f3fbcc699218d59.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/877a4168a08c4500b09dc0be8c8aa4ce.png
[f8e8548786f248be9a6a34c212c3518c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/a69fa4204e1a43fe8c7befc970d4bfa0.png
[5e2764e5d78145908af2adfb9ae9d45a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/7e09c911db6040bba50f92f2f2539ea1.png
[e20568b4e1f64ed29760bf1576229b20.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/bdede0b4f8734d18b091106dff96f164.png
[535cefd9fa5246c7924af017b1d22a3b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/804fd3cb662b4b4a98d017b77c6a338f.png
[cc907c9c420c4740b0345607259ab8d0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/6971e9062628427099452ce1731c25ee.png
[3211fd4238114a24a81349b71054de7b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/d0118aa02ab94339958d30208d7b5945.png
[https_gitee.com_linghufeixia_springboot-simple]: https://gitee.com/linghufeixia/springboot-simple
[springboot simple_0_ springboot]: https://blog.csdn.net/afei8080/article/details/101297868
[springboot simple_1_ springboot Helloworld]: https://blog.csdn.net/afei8080/article/details/101345712
[springboot simple_2_ springboot Starter]: https://blog.csdn.net/afei8080/article/details/101346285
[springboot simple_3 _springboot Web]: https://blog.csdn.net/afei8080/article/details/101348597
[springboot simple_4_springboot]: https://blog.csdn.net/afei8080/article/details/101422030
[springboot simple _5_ springboot Nosql]: https://blog.csdn.net/afei8080/article/details/101422594
[springboot simple _6_ springboot mqtt]: https://blog.csdn.net/afei8080/article/details/121513387?spm=1001.2014.3001.5502
[springboot simple _7_ springboot thrift]: https://blog.csdn.net/afei8080/article/details/127687148
[springboot simple _8_ springboot kafka]: https://blog.csdn.net/afei8080/article/details/127749475
[springboot simple _9_ springboot jpa_Hibernate]: https://blog.csdn.net/afei8080/article/details/128001389
[springboot simple _10_ springboot protobuf]: https://blog.csdn.net/afei8080/article/details/128297408
[springboot simple _11_ springboot protostuff]: https://blog.csdn.net/afei8080/article/details/128342603
[springboot simple _12_ springboot RabbitMQ]: https://blog.csdn.net/afei8080/article/details/128493057