Spring Boot 企业级应用开发框架技术R-CSDN博客

本文链接：https://blog.csdn.net/m0_74390545/article/details/148079050

简介

太原理工大学软件工程 2025级软件开发方向课程 Spring Boot 期末复习指南

题主复习Spring Boot顺便记录一下，对于Spring Boot快速入门也有一定的帮助

提到的一些复习重点和题型分布

单选20分课后练习不多
判断10
填空20
简答10（5*2）
程序阅读20
编程20
细节包括一部分git命令本地拖拽下载选择2分判断2分
第九章的任务调度 9.1 选择2 填空2 其他的上课讲过
简答重点是安全管理第一章第二章
程序阅读刚学过的消息服务第三章第四章 springweb
程序题好好看
主要考访问数据库部分第五章第六章取数据 JPA redis Mybatis

思维导图
整体课程框架

chapter 1:

1.1 概述

1. Spring Boot简介
  Spring Boot框架本身并不提供Spring框架的核心特性以及扩展功能，它只是使构建Spring应用变得简单。也就是说，Spring Boot并不是替代Spring框架的解决方案，而是和Spring框架紧密结合用于提升Spring开发者体验的工具。
1. Spring Boot的特性
  1 可快速构建独立的Spring应用。
  2 直接嵌入Tomcat、Jetty和Undertow等Web容器，无须部署WAR文件。
  3 提供固化的“starter”依赖，简化构建配置。
  4 提供了大量的自动化配置类。
  5 提供生产就绪功能。
  6 无须生成配置代码和XML配置文件。

1.2 案例

环境准备
1. JDK11(24)：
  https://www.oracle.com/java/technologies/javase/jdk11-archive- downloads.html
2. IDEA 2022.2(2024.8)：
  https://www.jetbrains.com.cn/idea/download/other.html
构建Spring Boot项目
使用Spring Initializr方式
Spring Initializr是一个快速生成Spring Boot项目的在线工具。通过Spring Initializr，可以轻松选择所需的依赖项并生成项目结构。
使用Maven方式（引入起步依赖，创建启动类，创建控制器类）

1.引入起步依赖
在pom.xml文件中，添加Spring Boot的起步依赖。以下是一个基本的pom.xml配置示例：

<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>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

2.在src/main/java目录下，创建一个启动类。启动类通常包含main方法，用于启动Spring Boot应用。以下是一个简单的启动类示例：

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

3.在src/main/java目录下，创建一个控制器类。控制器类用于处理HTTP请求并返回响应。以下是一个简单的控制器类示例：

package com.example.demo.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String sayHello() {
        return "Hello, World!";
    }
}

完成以上步骤后，运行启动类中的main方法，Spring Boot应用将启动。访问http://localhost:8080/hello(默认是这个端口），将会看到返回的“Hello, World!”。

1.3 原理

起步依赖
spring-boot-starter-parent：定义了很多个常见组件或框架的依赖版本号，组合成一套最优搭配的技术版本。
spring-boot-starter-web：使用Spring MVC构建Web应用程序的启动器，包含了多个具体依赖。
代码见上一节
自动配置用的一些注解
@SpringBootApplication
@SpringBootConfiguration //使项目启动类被扫描到Spring的IoC容器中
@EnableAutoConfiguration
@AutoConfigurationPackage //获取项目启动类所在根目录，作为组件扫描器扫描的包位置
@Import({AutoConfigurationImportSelector.class}) //筛选出当前项目环境需要启动的自动配置类
@ComponentScan //扫描筛选出的自动配置类到Spring的IoC容器中
执行流程
SpringApplication.run(Chapter01MavenApplication.class, args); //1.创建SpringApplication实例；2.调用run()方法

1.4 单元测试和热部署

单元测试
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.MOCK)
//使用Mock环境进行测试，不会启动实际的Web服务器。Spring Boot会模拟一个Servlet环境，适合单元测试或不需要实际HTTP请求的集成测试
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
//使用application.properties或application.yml中定义的端口启动嵌入式Web服务器。适合需要测试实际HTTP请求的场景，且端口固定
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
//使用随机端口启动嵌入式Web服务器。适合需要测试实际HTTP请求的场景，且避免端口冲突。
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.NONE)
//不启动任何Web服务器，也不模拟Servlet环境。适合不需要Web环境的测试场景，如纯业务逻辑测试。
热部署
1. 添加热部署依赖 spring-boot-devtools
2. 选中2个配置项

1.5 打包运行

JAR包
1. 添加Maven打包插件
2. 执行package命令
WAR包
1. 声明项目打包方式为war
2. 在Web起步依赖中排除内置的Tomcat依赖
3. 手动添加Tomcat的依赖
4. 添加Maven打包插件
5. 修改启动类
6. 执行package命令

chapter 2:

2.1 全局配置文件

application.properties (key=value)
1. 字面量
2. 数组
3. 集合（List，Set，Map）
YAML文件规则（4点）
application.yml/application.yaml (key: value)
1. 字面量
2. 数组和单列集合
3. Map集合
配置文件优先级规则（4点）

2.2 配置绑定（将配置文件中的属性绑定到Bean对象对应的属性上）

@Value注解
标注在bean的属性上，通过参数绑定配置文件中的对应属性
Enviroment对象
项目启动时将配置文件中的所有数据都封装到该对象中，通过getProperty()方法获取配置文件中的属性
@ConfigurationProperties注解
标注在bean类上，通过prefix参数绑定配置文件中的一组属性
@Value和@ConfigurationProperties对比（7点）

2.3 引入自定义配置文件和定义配置类

引入自定义配置文件
1. @PropertySource 用于加载YAML或properties的配置文件
  标注在类上，通过参数指定引入的配置文件的位置和名称。
2. @ImportResource 用于加载XML的配置文件
  标注在配置类上，通过参数指定引入的配置文件的位置和名称。
定义配置类
@Configuration 添加@Configuration注解的类称之为配置类
@Bean 添加@Bean注解的方法用于将方法的返回对象注入到Spring容器中

2.4 Profile 用于针对不同的环境提供不同的配置

单文件配置Profile
spring.config.activate.on-profile指定Profile的名称
spring.profiles.active指定激活哪个Profile
多文件配置Profile
application-{profile}.yml
application-{profile}.properties
@Profile 指定某个Bean只在特定的配置环境下生效，参数是Profile的名字
标注在类上时，通常类的上方需要被@Component标注
标注在方法上时；通常为配置类中被@Bean标注的方法

chapter 3:

3.1 注册Java Web三大组件

考虑到实际开发业务非常复杂和兼容问题，SpringBoot支持将Servlet、 Filter、Listener注入spring容器中，成为Spring的Bean。也就是说，SpringBoot开放了和原生WEB组件（Servlet、Filter、 Listener）的兼容。

使用Spring Bean注册
注册Servlet时，需要自定义两个及以上的Servlet，Servlet对应的映射地址为“Bean名称+/”
Filter的映射地址默认为“/*”。
使用RegistrationBean注册
将三大组件进一步封装成RegistrationBean。
Servlet - ServletRegistrationBean（可指定路径）
Filter - FilterRegistrationBean（可指定路径）
Listener - ServletListenerRegistrationBean
使用@ServletComponentScan注解
使Spring Boot能够识别标注@WebServlet、@WebFilter和@WebListener的类，并将扫描到的类自动注册到 Spring容器。

3.2 管理Spring MVC

Spring MVC自动配置的特性
配置静态资源映射
1. Spring Boot默认的静态资源路径（4个）
  classpath:/META-INF/resources/ classpath:/resources/ classpath:/static/ classpath:/public/
2. 通过配置文件配置
  spring.mvc.static-path-pattern: /backend/**
  spring.web.resources.static-locations:
3. 通过配置类配置
  实现WebMvcConfigurer接口，重写addResourceHandlers(ResourceHandlerRegistry registry) 方法。
配置视图控制器
实现WebMvcConfigurer接口，重写addViewControllers(ViewControllerRegistry registry)方法。
配置拦截器
实现WebMvcConfigurer接口，重写addInterceptors(InterceptorRegistry registry)方法。

3.3 文件上传

配置上传文件大小限制
创建上传表单页面
创建控制器类处理上传表单并返回结果
创建结果类

3.4 异常处理

异常处理的自动配置原理
Spring Boot通过配置类ErrorMvcAutoConfiguration为异常处理提供了自动配置，该配置类向容器中注入了以下4个组件：
1. ErrorPageCustomizer
  当系统发生异常后，将请求转发到Spring Boot的异常处理地址，默认为“/error”。
2. BasicErrorController
  处理异常，提供了errorHtml()和error()2个方法。
3. DefaultErrorViewResolver
  定位错误视图（4个步骤）。
4. DefaultErrorAttributes
  封装异常或错误消息（包含的属性）。
自定义异常处理
1. @ControllerAdvice
2. @ExceptionHandler

chapter 4:

4.1 Spring Boot支持的模板引擎

Spring Boot支持的模板引擎（5种）

4.2 Thymeleaf基础入门

Thymeleaf支持的模板类型（6种）
Thymeleaf常用属性
th:href
th:src
th:action
th:onclick
th:text
th:if
th:each
th:block 元素
Thymeleaf标准表达式
1. ${ } 内置对象
2. *{ } 选择
3. #{ } 消息
4. @{ } 链接
5. ~{ } 片段

4.3 案例：图书管理（代码见书上）

引入thymeleaf依赖
创建实体类
创建控制器
创建模板文件

chapter 5:

5.1 Spring Data概述

Spring Data的作用
为开发者提供了一套统一的API，操作不同存储系统中的数据。
Repository接口
提供了包括基本的增删改查操作、条件查询、排序查询、分页查询等。开发者仅需要按照一定的规范声明接口即可，不需要实现具体的查询方法。

5.2 Spring Boot整合Spring Data JPA

Spring Data JPA概述

Spring Data
JPA是Spring基于ORM框架和JPA规范封装的一套JPA应用框架，在JPA基础上提供更高层次的抽象，可以减少很多模板代码，可以使开发者使用极简的代码实现对数据的访问和操作。Spring
Data JPA默认使用Hibernate实现JPA。

Spring Data JPA访问数据库方法
1. 父接口的方法
  JpaRepository接口
2. 根据方法命名规则定义方法
  1. 以find、read、get、query、count开头
  2. 涉及查询条件时，条件的属性使用条件关键字连接，并且条件属性的首字母大写。
3. JPQL
  JPQL语句的写法和SQL语句的写法十分类似，但是要把查询的表名换成实体类名称，把表中的字段名换成实体类的属性名称。
  在方法前使用@Query注解，结合JPQL作为value属性的值来完成查询。
  JPQL支持命名参数和位置参数两种查询参数。
  1. 命名参数：使用“:参数名称”匹配参数。在方法的参数列表中，使用@Param注解标注参数的名称。
  2. 位置参数：使用“?位置编号”匹配参数。在方法的参数列表中，位置顺序从1开始。
4. 原生SQL
  在方法前使用@Query注解，并使用属性nativeQuery=true指定执行的查询语句为原生SQL。
使用@Query注解注意事项
1. @Query注解可以执行JPQL和原生SQL查询。
2. @Query注解无法进行DML数据操纵语言，主要有INSERT、DELETE和UPDATE操作。
3. 如果需要更新数据库中的数据，需要在对应的方法上标注@Modifying注解。
4. JPQL只支持DELETE和UPDATE操作，不支持INSERT操作。
整合 Spring Data JPA
1. 引入依赖
2. 填写配置文件
3. 创建实体类
4. 创建数据库表
5. 自定义Repository接口
6. 创建测试类

5.3 Spring Boot整合MyBatis-Plus

MyBatis-Plus概述

MyBatis-Plus是MyBatis
的增强工具，在MyBatis的基础上只做增强不做改变，支持MyBatis所有原生的特性，旨在简化开发、提高效率。

MyBatis-Plus快速入门
1. 通用Mapper，指BaseMapper接口，提供了基本的增删改查方法。

        //插入方法
		int insert(T entity);
		//更新方法
		int update(T updateEntity, Wrapper<T> whereWrapper);
		int updateById(T entity);
		//删除方法
		int delete(Wrapper<T> wrapper);
		int deleteById(Serializable id);
		int deleteBatchIds(Collection idList);
		//查询方法
		T selectById(Serializable id);
		List<T> selectBatchIds(Collection idList);
		T selectOne(Wrapper<T> queryWrapper);
		List<T> selectList(Wrapper<T> queryWrapper);

通用Service，指IService接口，提供了基本的增删改查方法。

	//插入方法
		boolean save(T entity);
		boolean saveBatch(Collection<T> entityList);
		//更新方法
		boolean update(Wrapper<T> updateWrapper);
		boolean updateById(T entity);
		boolean updateBatchById(Collection<T> entityList);
		//删除方法
		boolean remove(Wrapper<T> queryWrapper);
		boolean removeById(Serializable id);
		boolean removeByIds(Collection<? extends Serializable> idList);
		//查询方法
		T getById(Serializable id);
		T getOne(Wrapper<T> queryWrapper);
		List<T> list();
		List<T> list(Wrapper<T> queryWrapper);
		Collection<T> listByIds(Collection<? extends Serializable> idList);

条件构造器，指Wrapper接口，用于封装指定的条件，提供了各种封装条件的方法。

	eq(R column, Object val)
		ne(R column, Object val)
		gt(R column, Object val)
		ge(R column, Object val)
		lt(R column, Object val)
		le(R column, Object val)
		between(R column, Object val1, Object val2)
		like(R column, Object val)
		in(R column, Collection<?> value)
		groupBy(R... columns)

整合 MyBatis-Plus
1. 引入依赖
2. 填写配置文件
3. 创建实体类
4. 创建Mapper接口
5. 创建Service接口和实现类
6. 创建测试类

5.4 Spring Boot整合Redis

Redis快速入门
1. Redis概述
  是一个基于内存的键值型非关系型数据库，以Key-Value的形式存储数据。
2. Redis安装和启动
  1. 安装Redis
  2. 安装RESP.app
  3. 启动Redis服务
  4. 通过RESP.app连接Redis
3. Redis的数据类型
  1. String
  2. List
  3. Set
  4. SortedSet
  5. Hash
Spring Data Redis快速入门
1. Spring Data Redis概述
  是Spring Data在Spring管理的项目中对Redis操作的具体实现。对底层Lettuce和Jedis进行了封装，并为Lettuce和Jedis提供了自动配置。
2. Spring Data Redis常见操作
  (1) RedisTemplate
  (2) 常用注解和序列化策略
整合Spring Data Redis
1. 引入依赖
2. 填写配置文件
3. 创建数据类
4. 自定义Repository接口
5. 创建测试类

chapter 6:

6.1 Spring Boot默认缓存管理

概述
Spring的缓存机制将提供的缓存作用于Java 方法上，基于缓存中的可用信息，可以减少方法的执行次数。
Spring的默认的缓存方案通过Cache接口和CacheManager接口来统一不同的缓存技术。Cache接口包含了缓存的各种操作集合，CacheManager接口基于缓存名称对缓存进行管理，并制定了管理Cache的规则。
声明式缓存注解（6个）
@EnableCaching：标注在配置类上，用于开启基于注解的缓存支持。

@Cacheable：标注在数据查询方法上。方法在执行时，会先查询缓存，如果查询到的缓存为空，则执行该方法，并将方法的执行结果添加到缓存；如果查询到缓存数据，则不执行该方法，而是直接使用缓存数据。
1. value/cacheNames属性：用于指定缓存的名称，且可以指定多个缓存的名称。必备属性，等价属性，是唯一属性时，属性名可以省略。
2. key属性：用于指定缓存数据的键，如果没有指定key属性，可自动生成，通常手动指定，可使用SpEL表达式选择所需参数。
3. keyGenerator属性：也用于指定缓存数据的键，但不指定具体的key值，而是key值的生成器规则。使用时，与key属性二选一。
4. cacheManager/cacheResolver属性：用于指定缓存管理器和缓存解析器，这两个属性也是二选一使用，默认情况不需要配置。
5. condition属性：用于对数据进行有条件的选择性存储，当指定条件为true时才会对查询结果进行缓存，可以使用SpEL表达式选择所需参数。
6. unless属性：作用与condition属性相反，当指定的条件为true时，方法的返回值不会被缓存，可以使用SpEL表达式选择所需参数。
7. sync属性：用于多线程程序，表示数据缓存过程中是否使用同步模式，默认值为false。

@CachePut：标注在数据更新方法上。方法在执行时，先进行方法调用，然后将方法结果更新到缓存中。

@CacheEvict：标注在数据删除方法上。方法在执行时，先进行方法调用，然后将缓存清除。
1. allEntries属性：表示是否清除指定缓存空间中的所有缓存数据，默认值为false，即默认只删除指定key对应的缓存数据。
2. beforeInvocation属性：表示是否在方法执行之前进行缓存清除，默认值为false，即默认在执行方法后再进行缓存清除。

@Caching：标注在方法上，用于针对复杂规则的数据缓存管理。包含有cacheable、put和evict三个属性，分别对应于@Cacheable、@CachePut和@CacheEvict三个注解。在属性中可以使用多个嵌套的 @Cacheable、@CachePut 或 @CacheEvict。

@CacheConfig：标注在类上，用于统筹管理类中所有使用@Cacheable、@CachePut和@CacheEvict注解标注方法中的公共属性。
声明式缓存注解的应用
1. 引入依赖
2. 填写配置文件
3. 创建实体类
4. 创建Repository接口
5. 创建Service接口和实现类
6. 创建控制器类

6.2 Spring Boot整合Ehcache缓存

Ehcache概述
Ehcache是一种开源的的缓存框架，是当前使用最广泛的基于Java语言的缓存之一。
Ehcache支持分层缓存，所有分层缓存都可以单独使用，Ehcache支持的分层选项有堆、堆外、磁盘、集群。
Ehcache使用多个层时，必须遵守如下要求。（1）在多层设置中必须始终存在堆层。（2）不能将磁盘层和集群层组合在一起。（3）层的大小应该按照金字塔的方式调整。
整合Ehcache
1. 引入依赖
2. 填写配置文件
3. 创建Ehcache配置文件
4. 修改实体类

6.3 SpringBoot整合Redis缓存
1. 引入依赖
2. 填写配置文件

chapter 7:

7.1 安全框架概述

1. 常用安全框架（Spring Security、Shiro）
2. 两个重要概念（Authentication（认证）、Authorization（授权））
3. 三个对象（用户user、角色role、权限authority）

7.2 Spring Security入门案例

入门案例（代码在书上）
1. 引入依赖
2. 导入页面资源
3. 创建控制器类
4. 添加配置类
2. Spring Security结构总览
1. FilterChainProxy（外部请求系统资源时会经过此过滤器。）
2. 过滤器链中一系列过滤器（相互配合完成安全管理）
3. AuthenticationManager（实现认证管理）
4. AccessDecisionManager（实现授权管理）

7.3 Spring Security认证管理

Spring Security认证流程
1. 用户信息被“UsernamePasswordAuthenticationFilter”拦截。
2. 将用户信息封装到“Authentication”对象。
3. 将“Authentication”对象提交至“AuthenticationManager”。
4. “AuthenticationManager”返回“UserDetails”对象，如果为空，则认真失败。
5. 如果不为空，填充“Authentication”对象，包括权限信息，身份信息等，但会移除密码。
6. 将“Authentication”对象存放至“SecurityContext”。
“AuthenticationManager”认证过程
1. “AuthenticationManager”维护了一个”List“，存放有多种认证方式，最终认证工作由”AuthenticationProvider“完成。
2. Web表单的认证由”DaoAuthenticationProvider“完成。
3. ”DaoAuthenticationProvider“又维护了一个”UserDetailsService“对象，负责”UserDetails“对象的获取。
4. ”UserDetailsService“又有两个具体实现，”InMemoryUserDetailsManager“和”JdbcUserDetailsManager“，分别实现内存身份认证和JDBC身份认证。
Spring Security自定义身份认证
1. 内存身份认证
创建配置类WebSecurityConfig，创建InMemoryUserDetailsManager实例对象交由Spring管理。
2. JDBC身份认证。
修改配置类WebSecurityConfig，创建JdbcUserDetailsManager实例对象交由Spring管理。
3. 自定义UserDetailsService身份认证。
自定义一个UserDetailsService的实现类，重写loadUserByUsername()方法，在该方法中查询用户信息，将查询到的用户信息填充到UserDetails对象中返回。

7.4 Spring Security授权管理

Spring Security授权流程
1. 已认证用户访问受保护的Web资源被“FilterSecurityInterceptor”拦截。
2. 通过“SecurityMetadataSource”获取要访问当前资源所需的权限，以Collection类型返回。
3. 通过“AccessDecisionManager”进行授权决策，若决策通过，则允许访问资源，否则将禁止访问。
Spring Security自定义授权
1. Web授权：通过HttpSecurity对象设置安全拦截规则，并通过该对象构建过滤器链。
1. HttpSecurity的常用方法（一级方法）
2. 添加用户请求控制的常用方法（二级方法）
3. 基于表单的身份验证的常用方法（二级方法）
2. Web授权案例
1. 导入登录页面
2. 编辑WebSecurityConfig配置类
3. 编辑WebMvcConfig配置类
方法授权：通过注解标注控制类中的方法
1. @Secured注解：Spring Security提供
2. @RolesAllowed注解：JSR 250规范提供
3. @PreAuthorize注解：支持SpEL表达式
4. @EnableGlobalMethodSecurity注解：开启基于方法的安全认证机制
方法授权案例
1. 编辑WebSecurityConfig配置类
2. 编辑BookController控制器类
1. 动态展示菜单
  1. 添加Thymeleaf与Spring Security 5的集成包依赖。
  2. 修改后台首页main.html。

7.5 Spring Security会话管理和用户退出

会话管理：
1. 四种Session创建策略：always，ifRequired（默认），never，stateless。
2. 修改Session创建策略：HttpSecurity类提供了相关方法。
用户退出：Spring security默认实现了用户退出的功能。HttpSecurity类提供了logout()方法开启退出登录的支持，默认触发用户退出操作的URL为“/logout”，用户退出时同时也会清除Session等默认用户配置。

chapter 8:

8.1 消息服务概述

消息队列（Message Queue，MQ）是一种能实现消息生产者到消息消费者单向通信的通信模型，通常将实现了这个模型的组件称为消息队列中间件（简称消息中间件）。
常用消息中间件
1. ActiveMQ
2. RabbitMQ
3. Kafka
4. RocketMQ
使用消息服务的好处
1. 应用解耦
2. 异步提速
3. 流量削峰
4. 分布式事务管理

8.2 RabbitMQ快速入门

RabbitMQ结构
1. Connection
2. Channel
3. Broker
4. Virtual Host
5. Exchange
6. Queue
7. Binding
RabbitMQ工作模式
1. 简单模式
2. 工作队列模式
3. 发布/订阅模式
4. 路由模式
5. 通配符模式
6. RPC模式
7. 发布者确认模式
RabbitMQ的下载、安装和配置
1. 下载并安装Erlang语言包
2. 下载并安装RabbitMQ
3. 配置Path系统环境变量
4. 启动RabbitMQ插件
5. 启动RabbitMQ服务
6. 登录RabbitMQ可视化界面
RabbitMQ入门案例
1. 引入依赖
2. 编写消息生产类
3. 编写消息消费类

8.3 Spring Boot与RabbitMQ整合实现

准备工作
1. 引入依赖
2. 编写全局配置文件
使用发布/订阅模式实现消息服务
1. 基于API实现
1. 定制消息组件
1. 编写MessageProducerService类的构造方法
2. 实现消息生产
1. 编写实体类User
2. 编写MessageProducerService类生产消息的方法
3. 编写UserController控制器类
4. 编写RabbitMQConfig类指定消息转换器
3. 实现消息消费
1. 编写MessageConsumerService类消费消息的方法
1. 基于配置类实现
  1. 修改RabbitMQConfig类，增加配置组件的方法
  2. 修改MessageProducerService类，注释构造方法
2. 基于注解实现
  1. 修改RabbitMQConfig类，注释配置组件的方法
  2. 修改MessageConsumerService类，添加@RabbitListener注解