AI 助理
备案控制台
开发者社区 微服务 文章 正文

RabbitMQ：第三章：Springboot集成RabbitMQ（直连模式，工作队列模式，发布订阅模式，路由模式，通配符模式）

2023-01-16 380
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： RabbitMQ：第三章：Springboot集成RabbitMQ（直连模式，工作队列模式，发布订阅模式，路由模式，通配符模式）

系列文章目录

RabbitMQ：第一章：6 种工作模式以及消息确认机制（理论与代码相结合）

RabbitMQ：第二章：Spring整合RabbitMQ（简单模式，广播模式，路由模式，通配符模式，消息可靠性投递，防止消息丢失，TTL，死信队列，延迟队列，消息积压，消息幂等性）

RabbitMQ：第三章：Springboot集成RabbitMQ（直连模式，工作队列模式，发布订阅模式，路由模式，通配符模式

RabbitMQ：第四章：RabbitMQ集群搭建

前言

提示：Springboot集成Rabbitmq实战案例，通过接口调用的方式演示。

提示：以下是本篇文章正文内容，下面案例可供参考

一、集成步骤

一、生产者：

  1. 创建生产者SpringBoot工程
  2. 引入pom依赖
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
  1. 编写rabbitmq配置消息
  2. 定义交换机，队列以及绑定关系的配置类
  3. 注入RabbitTemplate，调用方法，完成消息发送

二、消费者：

  1. 创建生产者SpringBoot工程
  2. 引入pom依赖
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
  1. 编写rabbitmq配置消息
  2. 定义监听类，使用@RabbitListener注解完成队列监听。

二、实现步骤

1.项目架构图

2.创建项目

代码如下（示例）：

1.pom依赖

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.sky</groupId>
    <artifactId>springboot-rabbitmq-module</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-rabbitmq-module</name>
    <description>springboot-rabbitmq-module</description>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</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-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <finalName>springboot_rabbitmq</finalName>
        <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
            <plugins>
                <plugin>
                    <artifactId>maven-clean-plugin</artifactId>
                    <version>3.1.0</version>
                </plugin>
                <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
                <plugin>
                    <artifactId>maven-resources-plugin</artifactId>
                    <version>3.0.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.8.0</version>
                </plugin>
                <plugin>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>2.22.1</version>
                </plugin>
                <plugin>
                    <artifactId>maven-war-plugin</artifactId>
                    <version>3.2.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-install-plugin</artifactId>
                    <version>2.5.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-deploy-plugin</artifactId>
                    <version>2.8.2</version>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>

2.application.properties配置

server.port=8080
#spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
spring.rabbitmq.addresses=110.42.239.246
spring.rabbitmq.virtual-host=springboot
#spring.rabbitmq.addresses=110.42.239.246:5672,110.42.239.247:5672,110.42.239.248:5672

说明：这里免费提供rabbitmq连接方式给大家使用学习

3.config配置

HelloWorldConfig

package com.sky.springbootrabbitmqmodule.config;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
 * HelloWorld rabbitmq课上讲解的第一个工作模式
 * 直连模式只需要声明队列，所有消息都通过队列转发。
 * 无需设置交换机
 */
@Configuration
public class HelloWorldConfig {
  @Bean
  public Queue setQueue() {
    return new Queue("helloWorldqueue");
  }
}

FanoutConfig

package com.sky.springbootrabbitmqmodule.config;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
 * Fanout模式需要声明exchange，并绑定queue，由exchange负责转发到queue上。
 * 广播模式 交换机类型设置为：fanout
 */
@Configuration
public class FanoutConfig {
  //声明队列
  @Bean
  public Queue fanoutQ1() {
    return new Queue("fanout.q1");
  }
  @Bean
  public Queue fanoutQ2() {
    return new Queue("fanout.q2");
  }
  //声明exchange
  @Bean
  public FanoutExchange setFanoutExchange() {
    return new FanoutExchange("fanoutExchange");
  }
  //声明Binding,exchange与queue的绑定关系
  @Bean
  public Binding bindQ1() {
    return BindingBuilder.bind(fanoutQ1()).to(setFanoutExchange());
  }
  @Bean
  public Binding bindQ2() {
    return BindingBuilder.bind(fanoutQ2()).to(setFanoutExchange());
  }
}

WorkConfig

package com.sky.springbootrabbitmqmodule.config;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class WorkConfig {
    //声明队列
    @Bean
    public Queue workQ1() {
        return new Queue("work_sb_mq_q");
    }
}

DirectConfig

package com.sky.springbootrabbitmqmodule.config;
import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/*
   路由模式|Routing模式   交换机类型：direct
*/
@Configuration
public class DirectConfig {
  //声明队列
  @Bean
  public Queue directQ1() {
    return new Queue("direct_sb_mq_q1");
  }
  @Bean
  public Queue directQ2() {
    return new Queue("direct_sb_mq_q2");
  }
  //声明exchange
  @Bean
  public DirectExchange setDirectExchange() {
    return new DirectExchange("directExchange");
  }
  //声明binding，需要声明一个routingKey
  @Bean
  public Binding bindDirectBind1() {
    return BindingBuilder.bind(directQ1()).to(setDirectExchange()).with("directBind.one");
  }
  @Bean
  public Binding bindDirectBind2() {
      return BindingBuilder.bind(directQ2()).to(setDirectExchange()).with("directBind.two");
  }
}

TopicConfig

package com.sky.springbootrabbitmqmodule.config;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/*
Topics模式  交换机类型 topic
* */
@Configuration
public class TopicConfig {
  //声明队列
  @Bean
  public Queue topicQ1() {
    return new Queue("topic_sb_mq_q1");
  }
  @Bean
  public Queue topicQ2() {
    return new Queue("topic_sb_mq_q2");
  }
  //声明exchange
  @Bean
  public TopicExchange setTopicExchange() {
    return new TopicExchange("topicExchange");
  }
  //声明binding，需要声明一个roytingKey
  @Bean
  public Binding bindTopicHebei1() {
    return BindingBuilder.bind(topicQ1()).to(setTopicExchange()).with("directBind.*");
  }
  @Bean
  public Binding bindTopicHebei2() {
    return BindingBuilder.bind(topicQ2()).to(setTopicExchange()).with("#.two");
  }
}

4.消费端component

package com.sky.springbootrabbitmqmodule.component;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
@Component
public class ConcumerReceiver {
  //直连模式的多个消费者，会分到其中一个消费者进行消费。类似task模式
  //通过注入RabbitContainerFactory对象，来设置一些属性，相当于task里的channel.basicQos
  @RabbitListener(queues="helloWorldqueue")
  public void helloWorldReceive(String message) {
       System.out.println("helloWorld模式 received message : " +message);
  }
  //工作队列模式
    @RabbitListener(queues="work_sb_mq_q")
    public void wordQueueReceiveq1(String message) {
    System.out.println("工作队列模式1 received message : " +message);
    }
    @RabbitListener(queues="work_sb_mq_q")
    public void wordQueueReceiveq2(String message) {
    System.out.println("工作队列模式2 received message : " +message);
    }
  //pub/sub模式进行消息监听
  @RabbitListener(queues="fanout.q1")
  public void fanoutReceiveq1(String message) {
      System.out.println("发布订阅模式1received message : " +message);
  }
  @RabbitListener(queues="fanout.q2")
  public void fanoutReceiveq2(String message) {
      System.out.println("发布订阅模式2 received message : " +message);
  }
    //Routing路由模式
    @RabbitListener(queues="direct_sb_mq_q1")
    public void routingReceiveq1(String message) {
      System.out.println("Routing路由模式routingReceiveqOne received message : " +message);
    }
    @RabbitListener(queues="direct_sb_mq_q2")
    public void routingReceiveq2(String message) {
      System.out.println("Routing路由模式routingReceiveqTwo received message : " +message);
    }
    //topic 模式
  //注意这个模式会有优先匹配原则。例如发送routingKey=hunan.IT,那匹配到hunan.*(hunan.IT,hunan.eco),之后就不会再去匹配*.ITd
  @RabbitListener(queues="topic_sb_mq_q1")
  public void topicReceiveq1(String message) {
    System.out.println("Topic模式 topic_sb_mq_q1 received message : " +message);
  }
  @RabbitListener(queues="topic_sb_mq_q2")
  public void topicReceiveq2(String message) {
    System.out.println("Topic模式 topic_sb_mq_q2 received  message : " +message);
  }
}

5.生产者controller

package com.sky.springbootrabbitmqmodule.controller;
import org.springframework.amqp.AmqpException;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.io.UnsupportedEncodingException;
@RestController
public class ProducerController {
  @Autowired
  private RabbitTemplate rabbitTemplate;
  //helloWorld 直连模式
  @GetMapping(value="/helloWorldSend")
  public Object helloWorldSend(String message) throws AmqpException, UnsupportedEncodingException {
    //设置部分请求参数
    MessageProperties messageProperties = new MessageProperties();
    messageProperties.setContentType(MessageProperties.CONTENT_TYPE_TEXT_PLAIN);
    //发消息
    rabbitTemplate.send("helloWorldqueue",new Message(message.getBytes("UTF-8"),messageProperties));
    return "message sended : "+message;
  }
  //工作队列模式
  @GetMapping(value="/workqueueSend")
  public Object workqueueSend(String message) throws AmqpException, UnsupportedEncodingException {
    MessageProperties messageProperties = new MessageProperties();
    messageProperties.setContentType(MessageProperties.CONTENT_TYPE_TEXT_PLAIN);
    //制造多个消息进行发送操作
    for (int i = 0; i <10 ; i++) {
      rabbitTemplate.send("work_sb_mq_q",  new Message(message.getBytes("UTF-8"),messageProperties));
    }
    return "message sended : "+message;
  }
  // pub/sub 发布订阅模式   交换机类型 fanout
  @GetMapping(value="/fanoutSend")
  public Object fanoutSend(String message) throws AmqpException, UnsupportedEncodingException {
    MessageProperties messageProperties = new MessageProperties();
    messageProperties.setContentType(MessageProperties.CONTENT_TYPE_TEXT_PLAIN);
    //fanout模式只往exchange里发送消息。分发到exchange下的所有queue
    rabbitTemplate.send("fanoutExchange", "", new Message(message.getBytes("UTF-8"),messageProperties));
    return "message sended : "+message;
  }
  //routing路由工作模式  交换机类型 direct
  @GetMapping(value="/directSend")
  public Object routingSend(String routingKey,String message) throws AmqpException, UnsupportedEncodingException {
    if(null == routingKey) {
      routingKey="directBind.one";
    }
    MessageProperties messageProperties = new MessageProperties();
    messageProperties.setContentType(MessageProperties.CONTENT_TYPE_TEXT_PLAIN);
    //fanout模式只往exchange里发送消息。分发到exchange下的所有queue
    rabbitTemplate.send("directExchange", routingKey, new Message(message.getBytes("UTF-8"),messageProperties));
    return "message sended : routingKey >"+routingKey+";message > "+message;
  }
  //topic 工作模式   交换机类型 topic
  @GetMapping(value="/topicSend")
  public Object topicSend(String routingKey,String message) throws AmqpException, UnsupportedEncodingException {
    if(null == routingKey) {
      routingKey="directBind.one";
    }
    MessageProperties messageProperties = new MessageProperties();
    messageProperties.setContentType(MessageProperties.CONTENT_TYPE_TEXT_PLAIN);
    //fanout模式只往exchange里发送消息。分发到exchange下的所有queue
    rabbitTemplate.send("topicExchange", routingKey, new Message(message.getBytes("UTF-8"),messageProperties));
    return "message sended : routingKey >"+routingKey+";message > "+message;
  }
}

上面就是这个项目的所有代码了，下面就是Demo演示内容。


三、演示步骤

1.启动项目

2.调用接口演示

1.直连模式

1.接口调用


2.控制台打印

2.工作队列模式

1.接口调用



2.控制台打印


3.发布订阅模式（交换机类型：fanout）

1.接口调用

2.控制台打印

4.路由工作模式（交换机类型：direct）

1.接口调用


2.控制台打印

5.通配符模式（交换机类型：topic）

1.接口调用

2.控制台打印


除此之外，我还提供了项目地址提供给大家clone，地址链接：https://gitee.com/java_wxid/liao

总结

提示：以上就是今天要讲的内容，本文介绍了Springboot如何快速集成Rabbitmq，提供了五种模式的Demo案例演示给大家参考，希望对大家有所帮助。


文章标签：
云消息队列 MQ
Java
消息中间件
Spring
关键词：
Spring Boot路由
云消息队列 MQ队列
云消息队列 MQ模式
Spring Boot队列
云消息队列 MQ集成
相关实践学习
消息队列RocketMQ版：基础消息收发功能体验
本实验场景介绍消息队列RocketMQ版的基础消息收发功能，涵盖实例创建、Topic、Group资源创建以及消息收发体验等基础功能模块。
消息队列 MNS 入门课程
1、消息队列MNS简介 本节课介绍消息队列的MNS的基础概念 2、消息队列MNS特性 本节课介绍消息队列的MNS的主要特性 3、MNS的最佳实践及场景应用 本节课介绍消息队列的MNS的最佳实践及场景应用案例 4、手把手系列：消息队列MNS实操讲 本节课介绍消息队列的MNS的实际操作演示 5、动手实验：基于MNS，0基础轻松构建 Web Client 本节课带您一起基于MNS，0基础轻松构建 Web Client
我是廖志伟
目录
相关文章
众所周知
|
1月前
|
JavaScript 安全 Java
如何使用 Spring Boot 和 Ant Design Pro Vue 实现动态路由和菜单功能，快速搭建前后端分离的应用框架
本文介绍了如何使用 Spring Boot 和 Ant Design Pro Vue 实现动态路由和菜单功能，快速搭建前后端分离的应用框架。首先，确保开发环境已安装必要的工具，然后创建并配置 Spring Boot 项目，包括添加依赖和配置 Spring Security。接着，创建后端 API 和前端项目，配置动态路由和菜单。最后，运行项目并分享实践心得，包括版本兼容性、安全性、性能调优等方面。
众所周知
145 1
小王老师呀
|
2月前
|
消息中间件
RabbitMQ的 RPC 消息模式你会了吗？
【9月更文挑战第11天】RabbitMQ 的 RPC（远程过程调用）消息模式允许客户端向服务器发送请求并接收响应。其基本原理包括：1) 客户端发送请求，创建回调队列并设置关联标识符；2) 服务器接收请求并发送响应至回调队列；3) 客户端根据关联标识符接收并匹配响应。实现步骤涵盖客户端和服务器的连接、信道创建及请求处理。注意事项包括关联标识符唯一性、回调队列管理、错误处理及性能考虑。RPC 模式适用于构建可靠的分布式应用程序，但需根据需求调整优化。
小王老师呀
55 2
最好zzz
|
3月前
|
编解码 NoSQL Java
使用Spring Boot + Redis 队列实现视频文件上传及FFmpeg转码的技术分享
【8月更文挑战第30天】在当前的互联网应用中，视频内容的处理与分发已成为不可或缺的一部分。对于视频平台而言，高效、稳定地处理用户上传的视频文件，并对其进行转码以适应不同设备的播放需求，是提升用户体验的关键。本文将围绕使用Spring Boot结合Redis队列技术来实现视频文件上传及FFmpeg转码的过程，分享一系列技术干货。
最好zzz
200 3
众所周知
|
19天前
|
JavaScript 安全 Java
如何使用 Spring Boot 和 Ant Design Pro Vue 构建一个具有动态路由和菜单功能的前后端分离应用。
本文介绍了如何使用 Spring Boot 和 Ant Design Pro Vue 构建一个具有动态路由和菜单功能的前后端分离应用。首先，创建并配置 Spring Boot 项目，实现后端 API；然后，使用 Ant Design Pro Vue 创建前端项目，配置动态路由和菜单。通过具体案例，展示了如何快速搭建高效、易维护的项目框架。
众所周知
95 62
如夜了我衣衫太薄便归家靠路灯
|
3月前
|
消息中间件 Java 网络架构
springboot 整合rabbitmq，实现发送提醒消息
springboot 整合rabbitmq，实现发送提醒消息
如夜了我衣衫太薄便归家靠路灯
236 4
东方睿赢
|
17天前
|
JavaScript 安全 Java
如何使用 Spring Boot 和 Ant Design Pro Vue 构建一个前后端分离的应用框架，实现动态路由和菜单功能
本文介绍了如何使用 Spring Boot 和 Ant Design Pro Vue 构建一个前后端分离的应用框架，实现动态路由和菜单功能。首先，确保开发环境已安装必要的工具，然后创建并配置 Spring Boot 项目，包括添加依赖和配置 Spring Security。接着，创建后端 API 和前端项目，配置动态路由和菜单。最后，运行项目并分享实践心得，帮助开发者提高开发效率和应用的可维护性。
东方睿赢
34 2
东方睿赢
|
1月前
|
JavaScript 安全 Java
如何使用 Spring Boot 和 Ant Design Pro Vue 构建一个具有动态路由和菜单功能的前后端分离应用
【10月更文挑战第8天】本文介绍了如何使用 Spring Boot 和 Ant Design Pro Vue 构建一个具有动态路由和菜单功能的前后端分离应用。首先，通过 Spring Initializr 创建并配置 Spring Boot 项目，实现后端 API 和安全配置。接着，使用 Ant Design Pro Vue 脚手架创建前端项目，配置动态路由和菜单，并创建相应的页面组件。最后，通过具体实践心得，分享了版本兼容性、安全性、性能调优等注意事项，帮助读者快速搭建高效且易维护的应用框架。
东方睿赢
41 3
东方睿赢
|
1月前
|
JavaScript 安全 Java
如何使用 Spring Boot 和 Ant Design Pro Vue 构建一个具有动态路由和菜单功能的前后端分离应用
【10月更文挑战第7天】本文介绍了如何使用 Spring Boot 和 Ant Design Pro Vue 构建一个具有动态路由和菜单功能的前后端分离应用。首先，通过 Spring Initializr 创建 Spring Boot 项目并配置 Spring Security。接着，实现后端 API 以提供菜单数据。在前端部分，使用 Ant Design Pro Vue 脚手架创建项目，并配置动态路由和菜单。最后，启动前后端服务，实现高效、美观且功能强大的应用框架。
东方睿赢
41 2
热爱技术的小郑
|
3月前
|
消息中间件 Java 测试技术
消息中间件RabbitMQ---SpringBoot整合RabbitMQ【三】
这篇文章是关于如何在SpringBoot应用中整合RabbitMQ的消息中间件。内容包括了在SpringBoot项目中添加RabbitMQ的依赖、配置文件设置、启动类注解，以及如何通过单元测试来创建交换器、队列、绑定，并发送和接收消息。文章还介绍了如何配置消息转换器以支持对象的序列化和反序列化，以及如何使用注解`@RabbitListener`来接收消息。
热爱技术的小郑
52 2
消息中间件RabbitMQ---SpringBoot整合RabbitMQ【三】
土木林森
|
3月前
|
消息中间件 开发者
【RabbitMQ深度解析】Topic交换器与模式匹配：掌握消息路由的艺术！
【8月更文挑战第24天】在消息队列（MQ）体系中，交换器作为核心组件之一负责消息路由。特别是`topic`类型的交换器，它通过模式匹配实现消息的精准分发，适用于发布-订阅模式。不同于直接交换器和扇形交换器，`topic`交换器支持更复杂的路由策略，通过带有通配符（如 * 和 #）的模式字符串来定义队列与交换器间的绑定关系。
土木林森
70 2

热门文章

最新文章

  • 1
    Spring-boot+Dubbo应用启停源码分析
  • 2
    SpringMvc+Spring+MyBatis 基于注解整合
  • 3
    Spring Cloud实战小贴士：Zuul统一异常处理（一）
  • 4
    转：spring配置文件中xsd引用问题
  • 5
    Spring装配Bean---使用xml配置
  • 6
    Spring Boot Controller
  • 7
    面向切面的Spring
  • 8
    Ehcache 整合Spring 使用页面、对象缓存
  • 9
    在Spring中使用JDK定时器实现调度任务
  • 10
    Spring(二)之入门示例
  • 1
    Springboot 使用自定义注解结合AOP方式校验接口参数
    79
  • 2
    企业级智能制造MES系统源码，技术架构：springboot + vue-element-plus-admin
    181
  • 3
    SpringBoot项目的用maven插件打包报Test错误
    120
  • 4
    SpringBoot使用@Scheduled定时任务录入将要过期任务数据
    133
  • 5
    springboot配合Freemark模板生成word,前台vue接收并下载【步骤详解并奉上源码】
    213
  • 6
    springboot @RequiredArgsConstructor @Lazy解决循环依赖的原理
    826
  • 7
    基于springboot+vue+Mysql的交流互动系统
    61
  • 8
    SpringBoot-----从前端更新数据到MySql数据库
    55
  • 9
    springboot DDD的概念以及实战
    533
  • 10
    Spring Boot项目打war包（idea:多种方式）
    195

    • 相关课程

    更多
  • 消息队列 RocketMQ 消息集成
  • 微服务+全栈在线教育实战项目演练（SpringCloud Alibaba+SpringBoot）
  • SpringBoot实战教程
  • SpringBoot快速掌握 - 核心技术
  • SpringBoot快速掌握 - 高级应用
  • Springboot项目云开发快速迁移

    • 相关电子书

    更多
  • 阿里邮箱—安全高效集成
  • 集成智能接入网关APP：优化企业级移动办公网络
  • 云效助力企业集成安全到DevOps中

    • 相关实验场景

    更多
  • 通过轻量消息队列（原MNS）主题HTTP订阅+ARMS实现自定义数据多渠道告警
  • 消息队列RocketMQ版：基础消息收发功能体验
  • 快速学会使用云消息队列RabbitMQ版
  • 消息队列RocketMQ版：定时消息通知功能体验
  • 基于ROS的消息发布与订阅
  • 部署RabbitMQ
    • 下一篇
    阿里云OSS设置跨域访问