SpringBoot学习指南，超级全，真的细！挑战全篇无图教会你Java Springboot的使用。
考虑到大家学习的时间都比较碎片前面的9万字的文档确实阅读时间相对比较苛刻，故此将文档做一个分割，如果时间比较充足的小伙伴，建议还是直接阅读长篇这样学习会比较连贯
juejin.cn/post/730931...
9.SpringBoot综合使用
本章内容将包含MyBatis，Redis，以及项目中常用的基础组件等！！！
1.项目准备
1.1 数据库环境搭建
sql
CREATE DATABASE springboot CHARACTER SET utf8;
USE springboot;
CREATE TABLE `springboot_user` (
`id` INT(11) NOT NULL AUTO_INCREMENT,
`name` VARCHAR(20) NOT NULL,
`gender` VARCHAR(5) DEFAULT NULL,
`age` INT(11) DEFAULT NULL,
`address` VARCHAR(32) DEFAULT NULL,
`qq` VARCHAR(20) DEFAULT NULL,
`email` VARCHAR(50) NOT NULL,
`username` VARCHAR(20) NOT NULL,
`phone` VARCHAR(11) DEFAULT NULL,
`password` VARCHAR(255) NOT NULL, -- Assuming a VARCHAR length of 255 for the password
PRIMARY KEY (`id`),
UNIQUE KEY `user_username_uindex` (`username`)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8;
INSERT INTO springboot_user (id, name, gender, age, address, phone, email, username, password)
VALUES
(1, '马1蓉', '女', 38, '绿岛', '11111111111', 'marong222@qq.com', 'marong', 'marong121233'),
(2, '马斯克2', '男', 58, '湖北省武汉市', '22222222222', 'elmasike@qq.com', 'masike', 'masike121233'),
(3, '雷纳兹托瓦斯3', '男', 18, '湖北省荆门市', '33333333333', 'lnztws@qq.com', 'lnztws', 'lnztws121233'),
(4, '黄仁勋4', '男', 30, '扬州', '44444444444', 'huanrenxun@qq.com', 'huangrenxun', 'huangrenxun23123');
1.2项目初始化
com.practice
springboot_practice(maven 创建)
当前的目录结构
Linux
├── pom.xml
├── springboot_practice.iml
└── src
├── main
│ ├── java
│ └── resources
└── test
└── java
1.3修改pom文件添加我们需要的依赖
pom.xml
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.practice</groupId>
<artifactId>springboot_practice</artifactId>
<version>1.0-SNAPSHOT</version>
<!-- Parent -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.7.8</version>
</parent>
<!-- Dependencies -->
<dependencies>
<!-- Unit Testing Starter -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!-- Common Mapper Starter -->
<dependency>
<groupId>tk.mybatis</groupId>
<artifactId>mapper-spring-boot-starter</artifactId>
<version>2.1.5</version> <!-- Use the latest version -->
</dependency>
<!-- JDBC Starter -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<!-- MySQL Driver -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.23</version> <!-- Use the latest version -->
</dependency>
<!-- Druid Starter -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.1.17</version> <!-- Use the latest version -->
</dependency>
<!-- Web Starter -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- Spring Boot Actuator -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<!-- Apache Commons Lang3 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.12.0</version> <!-- Use the latest version -->
</dependency>
<!--Lombok的主要作用是通过简化常见的Java代码模式，减少样板代码的编写，提高开发效率，
减少代码错误，增加代码的可读性和可维护性。它已经成为许多Java开发人员的常用工具之一，
并在许多开源项目和企业应用中广泛使用。-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.22</version> <!-- 请检查并使用最新的版本 -->
<scope>provided</scope>
</dependency>
<!-- Spring Boot DevTools -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<optional>true</optional>
</dependency>
</dependencies>
</project>
1.4依赖说明
-
Springboot父工程
-
单元测试启动器
-
通用mapper启动器
mapper-spring-boot-starter是通用 Mapper 项目提供的 Spring Boot 启动器，用于简化 MyBatis 与通用 Mapper 的集成。通用 Mapper 是一个用于简化 MyBatis 开发的开源项目，它可以通过简单的配置来实现通用的 CRUD（Create, Read, Update, Delete）操作，避免手动编写重复的 SQL 语句。以下是
mapper-spring-boot-starter的主要作用：- 简化 MyBatis 配置： 通过引入
mapper-spring-boot-starter，你可以更简单地配置 MyBatis，不再需要手动配置 MyBatis 的 Mapper 接口和 XML 映射文件。 - 集成通用 Mapper： 通用 Mapper 提供了通用的 CRUD 操作，可以通过简单的继承和注解配置来实现对数据库表的增、删、改、查等操作，无需手动编写 SQL。
- 提供通用的查询方法： 通用 Mapper 提供了一系列通用的查询方法，如根据主键查询、条件查询、分页查询等，简化了数据访问的操作。
- 支持动态 SQL： 通用 Mapper 支持使用动态 SQL 进行查询，可以根据不同的条件生成不同的 SQL 语句，提高了灵活性。
为了使用
mapper-spring-boot-starter，你需要在项目的pom.xml文件中添加相应的依赖：xml<dependency> <groupId>tk.mybatis</groupId> <artifactId>mapper-spring-boot-starter</artifactId> <version>2.1.5</version> <!-- 使用最新版本 --> </dependency>然后，在你的实体类上使用通用 Mapper 提供的注解，例如
@Id、@Table，并创建继承自通用 Mapper 的接口，即可完成对数据库表的 CRUD 操作，无需手动编写 SQL 语句。javaimport javax.persistence.Id; import javax.persistence.Table; @Table(name = "your_table") public class YourEntity { @Id private Long id; // other fields, getters, setters... }javaimport tk.mybatis.mapper.common.Mapper; public interface YourEntityMapper extends Mapper<YourEntity> { // additional methods if needed }通过引入
mapper-spring-boot-starter，你可以更加方便地使用通用 Mapper 进行数据库操作，提高了开发效率，并减少了对 MyBatis 的配置工作。 - 简化 MyBatis 配置： 通过引入
-
JDBC启动器
spring-boot-starter-jdbc是 Spring Boot 中用于简化 JDBC 开发的启动器。它提供了 JDBC 相关的基础配置，让开发者能够更轻松地使用 Spring JDBC 访问数据库。以下是
spring-boot-starter-jdbc的主要作用：- 数据源的自动配置： 该启动器自动配置了 Spring 的数据源（
DataSource），使得开发者不需要手动配置数据源，减少了繁琐的配置工作。 - Spring JDBC 的核心功能：
spring-boot-starter-jdbc集成了 Spring JDBC 模块，使得你能够方便地使用 Spring 提供的 JdbcTemplate 等核心功能，简化了 JDBC 操作。 - 事务管理： 该启动器还自动配置了 Spring 的事务管理，使得在使用 Spring JDBC 进行数据库操作时，可以方便地开启、提交、回滚事务。
- 支持嵌入式数据库： 如果你的应用是基于嵌入式数据库（如 H2、HSQLDB）的，该启动器也会自动配置相应的数据源，让开发者能够无缝切换不同的数据库。
以下是一个简单的
spring-boot-starter-jdbc的使用示例：xml<!-- 在 pom.xml 中添加依赖 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artifactId> </dependency>然后，你可以在 Spring Boot 的配置文件（
application.properties或application.yml）中添加数据库相关的配置，例如：YAMLspring: datasource: url: jdbc:mysql://localhost:3306/mydatabase username: root password: password driver-class-name: com.mysql.cj.jdbc.Driver在代码中，你可以使用
JdbcTemplate进行数据库操作，而不必手动配置数据源和处理数据库连接的开启和关闭。Spring Boot 会根据你的配置自动完成这些工作，让你的代码更简洁、更易于维护。 - 数据源的自动配置： 该启动器自动配置了 Spring 的数据源（
-
mysql驱动
mysql-connector-java是 MySQL 官方提供的 MySQL 数据库连接器的 Java 实现，也就是 MySQL 驱动。在使用 Java 进行与 MySQL 数据库的交互时，你需要引入这个驱动，以便能够在 Java 应用程序中连接和操作 MySQL 数据库。以下是
mysql-connector-java的主要作用：- 数据库连接： 提供了与 MySQL 数据库建立连接的能力。通过这个驱动，Java 应用程序可以与 MySQL 数据库建立连接，并进行数据的读写操作。
- JDBC 接口实现：
mysql-connector-java实现了 JDBC（Java Database Connectivity）接口，这是 Java 标准库提供的用于与关系型数据库进行交互的 API。通过 JDBC，Java 应用程序可以使用标准的 SQL 语句执行查询、更新等数据库操作。 - 支持连接池：
mysql-connector-java本身不包含连接池功能，但可以与连接池整合使用，例如与Druid连接池结合，以提高数据库连接的效率和性能。
为了在 Maven 项目中使用
mysql-connector-java，你需要在项目的pom.xml文件中添加相应的依赖：xml<dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.23</version> <!-- 使用最新版本 --> </dependency>在引入这个依赖之后，你就可以在 Java 代码中使用 JDBC 连接 MySQL 数据库。通常，你需要提供数据库的连接信息，包括数据库 URL、用户名和密码。以下是一个简单的连接示例：
javaimport java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; public class MySqlConnectionExample { public static void main(String[] args) { String url = "jdbc:mysql://localhost:3306/your_database"; String username = "your_username"; String password = "your_password"; try (Connection connection = DriverManager.getConnection(url, username, password)) { // 连接成功，可以进行数据库操作 System.out.println("Connected to the database!"); } catch (SQLException e) { e.printStackTrace(); } } }这里，
jdbc:mysql://localhost:3306/your_database是数据库连接 URL，your_username和your_password是数据库的用户名和密码。连接成功后，你可以在try块中执行你的数据库操作。 -
druid启动器
druid-spring-boot-starter是阿里巴巴开源的连接池项目 Druid 集成到 Spring Boot 中的启动器。Druid 是一个高效、功能强大且可扩展的数据库连接池，它提供了许多有用的特性，包括连接池监控、SQL防火墙、性能监控等。使用
druid-spring-boot-starter的主要作用有以下几点：- 数据库连接池： Druid 提供了高效的数据库连接池，能够有效地管理数据库连接，提高数据库访问性能。
- 监控和统计： Druid 集成了强大的监控和统计功能，可以方便地监控数据库连接池的状态，包括活动连接数、空闲连接数、执行 SQL 的次数等，通过监控数据，可以更好地了解数据库的使用情况和性能状况。
- SQL 防火墙： Druid 提供了 SQL 防火墙功能，可以防止恶意 SQL 注入攻击，保障数据库的安全性。
- 配置灵活： 通过在 Spring Boot 项目中引入
druid-spring-boot-starter，可以使用 Spring Boot 的自动配置功能，减少了繁琐的配置，让配置更为简单。 - 性能监控： Druid 提供了 Web 界面，可以直观地查看数据库连接池的运行情况和 SQL 的执行情况，有助于识别潜在的性能问题。
要使用
druid-spring-boot-starter，只需在你的 Spring Boot 项目中添加相应的依赖，并在配置文件中配置数据源相关信息。以下是一个简单的示例：xml<!-- 在 pom.xml 中添加依赖 --> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid-spring-boot-starter</artifactId> <version>1.1.17</version> <!-- 使用最新版本 --> </dependency>然后，在
application.properties或application.yml中配置 Druid 数据源的相关信息，例如：yamlspring: datasource: url: jdbc:mysql://localhost:3306/mydatabase username: root password: password driver-class-name: com.mysql.cj.jdbc.Driver type: com.alibaba.druid.pool.DruidDataSource # 其他 Druid 配置可以在这里添加 druid: initial-size: 5 min-idle: 5 max-active: 20 max-wait: 60000 time-between-eviction-runs-millis: 60000 validation-query: SELECT 1 FROM DUAL test-while-idle: true test-on-borrow: false test-on-return: false pool-prepared-statements: true max-pool-prepared-statement-per-connection-size: 20以上是一个简单的配置示例，你可以根据实际需求进行更详细的配置。希望这些信息能够帮助你理解
druid-spring-boot-starter的作用。 -
Web启动器
-
spring boot Actuator依赖
spring-boot-starter-actuator是 Spring Boot 提供的一个用于生产环境监控和管理的模块。它为 Spring Boot 应用程序提供了一组内置的、用于监视和管理应用程序的端点（endpoints）。这些端点包括健康检查、信息展示、环境属性、配置信息、日志等，允许你监控应用程序的运行状况、收集信息和进行一些管理操作。以下是
spring-boot-starter-actuator的一些主要功能和作用：- 健康检查（Health Endpoint）： 提供
/actuator/health端点，用于检查应用程序的健康状况。这对于在生产环境中监控应用程序的运行状态非常有用。 - 信息展示（Info Endpoint）： 提供
/actuator/info端点，用于展示应用程序的信息，例如版本信息、自定义属性等。 - 环境属性（Environment Endpoint）： 提供
/actuator/env端点，用于查看应用程序的环境属性，包括配置属性、系统属性等。 - 配置信息（Config Props Endpoint）： 提供
/actuator/configprops端点，用于查看应用程序中所有的配置属性。 - 日志管理（Loggers Endpoint）： 提供
/actuator/loggers端点，允许动态更改应用程序的日志级别，方便在运行时调整日志输出。 - 线程信息（Thread Dump Endpoint）： 提供
/actuator/threaddump端点，用于获取线程的堆栈跟踪，方便定位应用程序中的线程问题。 - 性能监控（Metrics Endpoint）： 提供
/actuator/metrics端点，用于查看应用程序的性能指标，例如内存使用、线程池状态等。 - 应用程序状态（Application Endpoint）： 提供
/actuator/application端点，用于查看应用程序的运行时信息，例如应用程序的名称、管理端口等。
通过引入
spring-boot-starter-actuator，你可以在运行时更方便地监控和管理你的 Spring Boot 应用程序。这对于生产环境中的运维工作、故障排查以及性能优化都是非常有帮助的。在生产环境中，你可以选择开启或关闭特定的端点，以保障安全性。 - 健康检查（Health Endpoint）： 提供
-
编码工具包 common3-lang3
commons-lang3是 Apache Commons Lang 库的第三个版本，是一个为 Java 提供通用工具类和基础库的开源项目。它包含了一系列实用的工具方法，用于简化 Java 编程中的一些常见任务，例如字符串处理、数组操作、日期和时间处理、异常处理等。以下是
commons-lang3的一些主要功能和作用：-
字符串处理： 提供了一系列用于处理字符串的工具方法，包括字符串截取、拼接、替换、大小写转换等。
javaString result = StringUtils.substring("Hello, World!", 0, 5); // 截取字符串 -
数组操作： 提供了一些方便的数组操作方法，包括数组的比较、查找、复制等。
javaboolean isEqual = ArrayUtils.isEquals(array1, array2); // 比较数组是否相等 -
日期和时间处理： 提供了一些用于日期和时间操作的工具方法，如格式化日期、计算日期差等。
javaString formattedDate = DateUtils.formatDate(new Date(), "yyyy-MM-dd"); // 格式化日期 -
异常处理： 提供了一些关于异常的工具方法，如获取异常堆栈信息、判断异常类型等。
javaString stackTrace = ExceptionUtils.getStackTrace(exception); // 获取异常堆栈信息 -
其他实用工具方法： 还包括其他一些实用的工具方法，如随机数生成、系统属性获取、反射操作等。
javaString javaVersion = SystemUtils.JAVA_VERSION; // 获取Java版本信息
通过引入
commons-lang3依赖，你可以在项目中直接使用这些实用的工具方法，避免了重复实现一些常见的功能，提高了代码的可读性和可维护性。此外，这个库经过广泛使用和测试，是 Java 开发中常用的工具库之一。在开发中，如果遇到需要处理字符串、数组、日期等常见操作的场景，使用commons-lang3可以帮助你更高效地完成任务。 -
-
热部署 spring-boot-devtools
spring-boot-devtools是 Spring Boot 提供的一个用于开发环境的工具，旨在提高开发者的开发体验。它为开发者提供了一些功能，使得在开发阶段进行代码修改后能够更快速地进行应用程序重启，以便查看修改的效果，从而加速开发周期。以下是
spring-boot-devtools的一些主要功能和作用：- 自动重启应用程序：
spring-boot-devtools允许在开发阶段对应用程序进行热部署。当你修改了项目的源代码、类路径资源或静态资源文件时，应用程序将会自动进行重启，而无需手动停止和启动。 - 禁用模板缓存： 对于使用模板引擎的项目（如 Thymeleaf、FreeMarker 等），
spring-boot-devtools会自动禁用模板缓存，以确保每次修改模板文件后都能立即生效。 - 开发者工具页面： 在应用程序启动后，
spring-boot-devtools还提供了一个开发者工具页面，你可以通过访问http://localhost:8080/actuator查看应用程序的热部署状态，包括热部署类的触发、重启次数等信息。 - 远程调试支持：
spring-boot-devtools允许你在开发模式下远程连接到应用程序，进行调试和查看应用程序的内部状态。
为了使用
spring-boot-devtools，你需要在项目的pom.xml文件中添加相应的依赖：xml<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId> <optional>true</optional> </dependency>需要注意的是，
<optional>true</optional>的配置表示这个依赖是可选的，它只在开发环境下起作用。在生产环境中，这个依赖不会被引入，以避免潜在的性能问题。总的来说，
spring-boot-devtools是一个在开发阶段提高效率的工具，能够减少代码修改后的重启时间，帮助开发者更快速地迭代和调试应用程序。 - 自动重启应用程序：
-
Lombok 依赖
Lombok 是一个 Java 库，旨在通过简化常见的 Java 代码模式，减少样板代码的编写，提高开发效率，减少代码错误，增加代码的可读性和可维护性。它通过自动为 Java 类生成一些常见的方法（如 Getter、Setter、toString 等），以及通过注解简化一些常见的设计模式，来达到这个目的。
具体而言，以下是 Lombok 的一些主要作用：
0. 自动生成 Getter 和 Setter 方法： 使用@Getter和@Setter注解，可以自动生成字段的 Getter 和 Setter 方法，减少冗余的样板代码。java@Getter @Setter private String name;-
自动生成构造方法： 使用
@AllArgsConstructor和@NoArgsConstructor注解，可以自动生成全参和无参构造方法。java@AllArgsConstructor public class Example { private String field1; private int field2; } -
自动生成
toString方法： 使用@ToString注解，可以自动生成toString方法。java@ToString public class Example { private String field1; private int field2; } -
自动生成
hashCode和equals方法： 使用@EqualsAndHashCode注解，可以自动生成hashCode和equals方法。java@EqualsAndHashCode public class Example { private String field1; private int field2; } -
简化日志记录： 使用
@Slf4j注解，可以自动生成一个 SLF4J 的日志变量，避免手动创建private static final Logger字段。java@Slf4j public class Example { public void exampleMethod() { log.info("Logging with Lombok!"); } -
其他注解： Lombok 还提供了其他一些注解，如
@Data（相当于@Getter @Setter @ToString @EqualsAndHashCode的组合）、@Builder（用于构建者模式）等，可以根据需要选择使用。
总体而言，Lombok 的目标是简化 Java 代码，提高开发效率，并且它已经在许多 Java 项目中广泛应用。
-
-
build Maven打包
这 Maven 配置片段是用于配置 Spring Boot 项目的 Maven 插件，主要作用是将项目打包成可执行的 JAR 文件。具体来说，这段配置使用了 Spring Boot 提供的
spring-boot-maven-plugin插件，它提供了一些特定于 Spring Boot 项目的功能，例如创建可执行 JAR 文件、自动重新加载等。以下是这个配置片段的主要作用：
0. 打包成可执行的 JAR 文件： 通过配置spring-boot-maven-plugin插件，Maven 在构建项目时将会执行插件的repackage目标。这个目标会重新打包项目，将所有依赖和项目的类文件打包到一个可执行的 JAR 文件中。xml<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build>使用 Maven 命令进行项目构建，生成可执行 JAR 文件：
linuxmvn clean package-
支持自动重新加载（可选）： 这个配置片段并未显式启用自动重新加载，但默认情况下，
spring-boot-maven-plugin插件会在开发模式下启用自动重新加载。在开发阶段，你可以使用mvn spring-boot:run命令启动应用程序，并在代码变更时自动重新启动应用。xml<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <fork>true</fork> </configuration> </plugin> </plugins> </build>使用 Maven 命令启动应用程序，支持自动重新加载：
linuxmvn spring-boot:run
总之，这段 Maven 配置的主要目的是使用
spring-boot-maven-plugin插件将 Spring Boot 项目打包成可执行的 JAR 文件，方便部署和运行。 -
2.项目主文件入口定义
/src/main/java/com/practice/App.class
java
package com.practice;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import tk.mybatis.spring.annotation.MapperScan;
@SpringBootApplication
@MapperScan(basePackages = "com.practice.com.practice.dao")// @MapperScan 注解告诉 MyBatis 在指定的包中查找 Mapper 接口。Mapper 接口是用于与数据库交互的接口，其中定义了数据库操作的方法。
@EnableTransactionManagement//开启声明式事务，默认开启
public class App {
public static void main(String[] args){
SpringApplication.run(App.class,args);
}
}3.定义application.yml配置文件
/src/main/resource/application.yml
yaml
# 服务器端口配置
server:
port: 9090
# Spring 数据源配置
spring:
datasource:
# 数据库连接 URL
url: jdbc:mysql://127.0.0.1:3306/springboot
# MySQL 驱动类
driver-class-name: com.mysql.cj.jdbc.Driver
# 数据库用户名
username: root
# 数据库密码
password:
# 数据源类型（这里使用了 Druid 数据源）
type: com.alibaba.druid.pool.DruidDataSource
# MyBatis 配置
mybatis:
# MyBatis 类型别名包扫描路径，用于扫描指定包下的类作为 MyBatis 实体类
type-aliases-package: com.practice.pojo
4.创建pojo包
src/main/java/com/practice/pojo(存放实体类)
5.创建User 实体类
src/main/java/com/practice/pojo/User.java
java
package com.practice.pojo;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import javax.persistence.*;
import java.io.Serializable;
/**
* @Entity 注解声明这是一个 JPA 实体类。
* @Table 注解用于映射表名。
* @Id 和 @GeneratedValue 注解标识主键，并指定主键的生成策略。
* @Column 注解用于映射数据库表字段，包括字段名、是否可为空、长度等属性。
* @Getter 和 @Setter 注解由 Lombok 自动生成 Getter 和 Setter 方法。
* @ToString 自动生成 toString 方法
* Serializable 接口是一个标记接口，表示该类的对象可以被序列化。
* 根据实际需要，你还可以添加构造方法、toString 方法，以及重写 equals 和 hashCode 方法。这取决于你是否需要在比较对象时使用这些方法。
* 在这个示例中除了主键之外可指定也可不指定@Column
*/
@ToString
@Getter
@Setter
@Entity
@Table(name = "springboot_user")
public class User implements Serializable {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "name", nullable = false, length = 20)
private String name;
@Column(name = "gender", length = 5)
private String gender;
@Column(name = "age")
private Integer age;
@Column(name = "address", length = 32)
private String address;
@Column(name = "qq", length = 20)
private String qq;
@Column(name = "email", nullable = false, length = 50)
private String email;
@Column(name = "username", nullable = false, unique = true, length = 20)
private String username;
@Column(name = "phone", length = 11)
private String phone;
@Column(name = "password", nullable = false, length = 255)
private String password;
}
6.创建dao包
src/main/java/com/practice/dao
7.Mapper接口的映射和配置
src/main/java/com/practice/dao/UserMapper.java
java
package com.practice.dao;
import com.practice.pojo.User;
import tk.mybatis.mapper.common.Mapper;
/**
* 用户数据访问层接口
* 通过 Mapper 框架，在 MyBatis 基础上进行封装，可以动态生成 SQL 语句，提供基本 CRUD 操作
* 通过继承 Mapper 框架提供的 Mapper 接口，实现了对 User 实体的基本数据库操作
* @Mapper 接口是 MyBatis 提供的用于实现数据库操作的接口。
* UserMapper 继承了 tk.mybatis.mapper.common.Mapper 接口，它是通用 Mapper 的基础接口，提供了一些常见的数据库操作方法。
* 注释中强调了通过继承 Mapper 接口，可以动态生成 SQL 语句，并实现了基本的 CRUD（Create, Read, Update, Delete）操作，减少了手动编写 SQL 语句的工作。
* UserMapper 接口主要用于定义对 User 实体的数据库操作方法，而具体的实现由 MyBatis 的通用 Mapper 框架负责。
*/
public interface UserMapper extends Mapper<User> {
}
8.创建Test,查看是否成功继承通用Mapper的方法
/src/test/java/com/practice/UserMapperTest.java
java
package com.practice;
import com.practice.dao.UserMapper;
import com.practice.pojo.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.List;
/**
* @RunWith(SpringRunner.class) 和 @SpringBootTest 注解用于在测试环境中启动 Spring Boot 应用上下文。
* @Autowired 注解用于将 UserMapper bean 注入到测试类中。
* @Test 注解标记了测试方法，测试方法调用了 userMapper.selectAll() 查询所有用户，并打印了查询结果。
* 请确保 UserMapper 接口定义了正确的查询方法，且 MyBatis 的配置正确。此外，检查测试类所在的包路径是否能够正确扫描到 UserMapper 接口。运行该测试类时，你应该能够看到查询结果输出到控制台。
*/
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
@Autowired
UserMapper userMapper;//如果 Error 提示："Could not autowire. No beans of"UserMapper' type found. more... (SB F1) "无需搭理直接运行即可
@Test
public void testFindAll(){
List<User> list =userMapper.selectAll();
for (User user:list
) {System.out.println("user"+user.getId()+"="+user);
}
}
}
执行上面文件后Terminal输出：
linux
. ____ _ __ _ _
/\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )___ | '_ | '_| | '_ / _` | \ \ \ \
\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |___, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v2.7.8)
2023-11-15 16:05:19.833 INFO 82708 --- [ main] com.practice.UserMapperTest : Starting UserMapperTest using Java 1.8.0_121 on wujiahao with PID 82708 (started by wujiahao in /Users/wujiahao/studydemo/JAVA/springboot_03_practice)
2023-11-15 16:05:19.835 INFO 82708 --- [ main] com.practice.UserMapperTest : No active profile set, falling back to 1 default profile: "default"
2023-11-15 16:05:21.229 INFO 82708 --- [ main] c.a.d.s.b.a.DruidDataSourceAutoConfigure : Init DruidDataSource
2023-11-15 16:05:21.428 INFO 82708 --- [ main] com.alibaba.druid.pool.DruidDataSource : {dataSource-1} inited
2023-11-15 16:05:23.021 INFO 82708 --- [ main] t.m.m.autoconfigure.MapperCacheDisabler : Clear tk.mybatis.mapper.util.MsUtil CLASS_CACHE cache.
2023-11-15 16:05:23.022 INFO 82708 --- [ main] t.m.m.autoconfigure.MapperCacheDisabler : Clear tk.mybatis.mapper.genid.GenIdUtil CACHE cache.
2023-11-15 16:05:23.023 INFO 82708 --- [ main] t.m.m.autoconfigure.MapperCacheDisabler : Clear tk.mybatis.mapper.version.VersionUtil CACHE cache.
2023-11-15 16:05:23.024 INFO 82708 --- [ main] t.m.m.autoconfigure.MapperCacheDisabler : Clear EntityHelper entityTableMap cache.
2023-11-15 16:05:23.040 INFO 82708 --- [ main] o.s.b.a.e.web.EndpointLinksResolver : Exposing 1 endpoint(s) beneath base path '/actuator'
2023-11-15 16:05:23.120 INFO 82708 --- [ main] com.practice.UserMapperTest : Started UserMapperTest in 3.654 seconds (JVM running for 4.585)
user1=User(id=1, name=马1蓉, gender=女, age=38, address=绿岛, qq=null, email=marong222@qq.com, username=marong, phone=11111111111, password=marong121233)
user2=User(id=2, name=马斯克2, gender=男, age=58, address=湖北省武汉市, qq=null, email=elmasike@qq.com, username=masike, phone=22222222222, password=masike121233)
user3=User(id=3, name=雷纳兹托瓦斯3, gender=男, age=18, address=湖北省荆门市, qq=null, email=lnztws@qq.com, username=lnztws, phone=33333333333, password=lnztws121233)
user4=User(id=4, name=黄仁勋4, gender=男, age=30, address=扬州, qq=null, email=huanrenxun@qq.com, username=huangrenxun, phone=44444444444, password=huangrenxun23123)
2023-11-15 16:05:23.862 INFO 82708 --- [ionShutdownHook] com.alibaba.druid.pool.DruidDataSource : {dataSource-1} closing ...
2023-11-15 16:05:23.866 INFO 82708 --- [ionShutdownHook] com.alibaba.druid.pool.DruidDataSource : {dataSource-1} closed
Process finished with exit code 09.接下来我们来创建service包
/src/main/java/com/practice/service/（用户服务逻辑）
10.创建UserService.java
/src/main/java/com/practice/service/UserService.java(用户服务逻辑的接口定义)
java
package com.practice.service;
import com.practice.pojo.User;
import java.util.List;
public interface UserService {
/**
* 获取所有用户信息。
*
* @return 包含所有用户信息的列表
*/
List<User> findUser();
/**
* 根据用户ID查找特定用户。
*
* @param id 用户ID
* @return 包含用户信息的User对象，如果未找到则返回null
*/
User findUserById(long id);
/**
* 保存新用户信息。
*
* @param user 包含新用户信息的User对象
*/
void saveUser(User user);
/**
* 更新现有用户信息。
*
* @param user 包含更新后用户信息的User对象
*/
void updateUser(User user);
/**
* 根据用户ID删除特定用户。
*
* @param id 要删除的用户ID
*/
void deleteUerById(Long id);}11.UserService的实现UserServiceimpl.java
implement目录创建
/src/main/java/com/practice/service/impl
Service的接口实现
/src/main/java/com/practice/service/impl/UserServiceimpl.java
java
package com.practice.service.impl;
import com.practice.dao.UserMapper;
import com.practice.pojo.User;
import com.practice.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
/**
* 这是一个用户服务的实现类。
* 该类使用@Service注解将其标记为Spring的服务组件，
* 并使用@Transactional注解指定了事务的范围。
*
* 类中的方法完成了对用户的增删改查操作，
* 通过@Override注解表明这些方法是接口UserService中定义的方法的实现。
* 方法中使用UserMapper来执行对数据库的操作，比如插入、更新、查询等。
*/
@Service
@Transactional
public class UserServiceimpl implements UserService {
@Autowired
UserMapper userMapper;//Could not autowire. No beans of"UserMapper' type found. more... (SB F1)不用去管
/**
* 查询所有用户
*
* @return 用户列表
*/
@Override
public List<User> findUser() {
return userMapper.selectAll();
}
/**
* 根据ID查询用户
*
* @param id 用户ID
* @return 用户对象
*/
@Override
public User findUserById(long id) {
return userMapper.selectByPrimaryKey(id);
}
/**
* 保存用户
*
* @param user 用户对象
*/
@Override
public void saveUser(User user) {
userMapper.insert(user);
}
/**
* 更新用户
*
* @param user 用户对象
*/
@Override
public void updateUser(User user) {
userMapper.updateByPrimaryKey(user);
}
/**
* 根据ID删除用户
*
* @param id 用户ID
*/
@Override
public void deleteUerById(Long id) {
userMapper.deleteByPrimaryKey(id);
}
}说明：
这是一个用户服务的实现类。
@Transactional 是一个注解，用于在 Spring 应用程序中定义事务的行为。它可以应用于类、方法或接口上。
@Transactional 注解的作用是将带有注解的方法或类标记为事务性操作。当方法被调用时，Spring 将创建一个事务，并在方法执行结束后根据方法的结果来决定是提交事务还是回滚事务。如果方法执行成功，事务将被提交，如果方法抛出异常，事务将会回滚。
@Transactional 注解可以具有不同的属性和选项，以控制事务的行为，例如：
- 事务传播行为（Propagation）： 定义事务方法与现有事务之间的相互关系。例如，如果方法在一个现有事务中被调用，它可以选择加入该事务或创建一个新的事务。
- 事务隔离级别（Isolation）： 定义事务在并发环境下的隔离程度。不同的隔离级别提供了不同的数据一致性和并发控制机制。
- 超时时间（Timeout）： 定义事务的最大执行时间。如果事务在指定的时间内没有完成，将被强制回滚。
- 只读（Read-only）： 指示事务是否只读取数据而不做修改。只读事务可以提供额外的性能优势。
- 回滚规则（Rollback）： 定义哪些异常会触发事务回滚。可以指定特定的异常类型或通过通配符匹配。
通过使用 @Transactional 注解，您可以轻松管理事务边界，确保一组操作要么全部成功提交，要么全部回滚，从而保持数据的一致性和完整性。这样可以简化事务管理的代码，并提供更好的可读性和可维护性。
11.1 .UserServiceTest测试我们的UserService
/src/test/java/com/practice/UserServiceTest.java
java
package com.practice;
import com.practice.pojo.User;
import com.practice.service.UserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.List;
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserControllerTest {
@Autowired
UserService userService;
@Test
public void finAllUser(){
List<User> users =userService.findUser();
System.out.println(users);
}
}
12.通用的Result处理
我们将通用的Result处理暂时放在vo包下处理
12.1新建vo包
src/main/java/com/practice/vo/
12.2新建Result.java
src/main/java/com/practice/vo/Result.java
java
package com.practice.vo;
import lombok.Getter;
import lombok.Setter;
import java.io.Serializable;
@Setter
@Getter
public class Result implements Serializable {
private boolean status; // 响应状态，true表示成功，false表示失败
private String message; // 响应消息
private Object data; // 响应数据
/**
* 创建一个表示成功操作的Result对象
*
* @param data 响应数据
* @return Result对象
*/
public static Result ok(Object data) {
Result result = new Result();
result.setStatus(true);
result.setMessage("Response is successful");
result.setData(data);
return result;
}
/**
* 创建一个表示失败操作的Result对象
*
* @param data 响应数据
* @return Result对象
*/
public static Result error(Object data) {
Result result = new Result();
result.setStatus(false);
result.setMessage("Response is unsuccessful");
result.setData(data);
return result;
}
}
说明：
上述代码是一个名为 Result 的类，用于封装响应结果。该类实现了 Serializable 接口，表示对象可以进行序列化和反序列化。
@Getter 和 @Setter 是 Lombok 库提供的注解，用于自动生成属性的 getter 和 setter 方法，以简化 Java 类的编写。使用这些注解可以避免手动编写繁琐的 getter 和 setter 方法。
@Getter：该注解应用于类级别或属性级别。当应用于类级别时，它会为该类的所有非静态字段生成相应的 getter 方法。当应用于属性级别时，它只会为该属性生成 getter 方法。@Setter：该注解应用于类级别或属性级别。当应用于类级别时，它会为该类的所有非静态字段生成相应的 setter 方法。当应用于属性级别时，它只会为该属性生成 setter 方法。
在 Result 类中使用 @Getter 和 @Setter 注解，将为每个类成员变量自动生成对应的 getter 和 setter 方法。这样可以通过调用这些方法来访问和修改类的私有成员变量，而无需手动编写这些方法。
例如，status 字段具有 @Getter 和 @Setter 注解，那么将自动生成以下方法：
java
public boolean isStatus() {
return status;
}
public void setStatus(boolean status) {
this.status = status;
}通过使用 @Getter 和 @Setter 注解，可以简化代码，并提高代码的可读性和可维护性。需要注意的是，在使用 Lombok 注解时，确保已正确配置和集成 Lombok 插件，以使注解生效。
该类包含以下成员变量：
status：响应状态，用于表示操作的成功或失败。true表示成功，false表示失败。message：响应消息，用于描述操作的结果信息。data：响应数据，用于存储返回的数据对象。
在类中定义了两个静态方法：
ok方法：创建一个表示成功操作的Result对象。它接收一个data参数，将传递的数据对象存储到data成员变量中，并设置status为true，message为 "Response is successful"。error方法：创建一个表示失败操作的Result对象。它也接收一个data参数，将传递的数据对象存储到data成员变量中，并设置status为false，message为 "Response is unsuccessful"。
通过这种方式，可以方便地创建一个包含响应状态、消息和数据的 Result 对象，以便在应用程序中进行统一的响应处理。
Serializable 是 Java 中的一个接口，用于标识一个类的对象可以被序列化和反序列化。当一个类实现了 Serializable 接口时，它的对象可以被转换为字节序列，以便在网络上传输或持久化到磁盘中，同时也可以将字节序列重新转换为对象。
Serializable接口的作用主要有以下几个方面：
- 对象的持久化： 通过实现
Serializable接口，可以将对象转换为字节序列并将其写入到磁盘文件或数据库等持久化存储介质中。这样，在程序终止后，对象的状态可以被保存下来，下次程序启动时可以重新加载对象。 - 对象的网络传输： 在分布式系统中，对象需要在不同的计算节点之间进行传输。通过实现
Serializable接口，可以将对象序列化为字节序列，然后通过网络传输到其他节点，在目标节点上反序列化为对象。这样可以方便地在分布式系统中进行远程调用或消息传递。 - 对象的深拷贝： 通过对象的序列化和反序列化，可以实现对象的深拷贝。深拷贝是指创建一个新的对象，该对象的所有字段都与原始对象相同，但是在内存中占据不同的位置。这对于需要复制对象并对其进行独立修改的情况非常有用。
需要注意的是，实现 Serializable 接口并不是默认安全的。在某些情况下，对敏感数据的序列化可能会导致安全问题。因此，在将类声明为可序列化之前，需要仔细考虑该类的安全性和敏感数据的保护。
要实现 Serializable 接口，只需在类声明中添加 implements Serializable，并确保类的所有字段都是可序列化的（即它们的类型也是可序列化的）或标记为 transient（将不会被序列化）。
13.controller包的创建
/src/main/java/com/practice/controller
说明：
在软件开发中，Controller（控制器）是一种模式或组件，用于处理用户请求并协调其他组件的行为。在Web应用程序中，Controller通常是MVC（Model-View-Controller）架构中的一部分，负责接收用户的请求，处理请求参数，调用适当的业务逻辑，并返回响应给用户。
主要作用如下：
- 处理用户请求：Controller负责接收来自用户的请求，可以是通过URL、表单提交、AJAX等方式发送的请求。
- 解析请求参数：Controller从请求中获取参数，这些参数可以是URL路径参数、查询参数、表单参数、请求头信息等。
- 调用业务逻辑：Controller根据请求的内容，调用相应的业务逻辑组件（Service）来处理请求。它将解析的参数传递给业务逻辑组件，并根据业务需求执行相应的操作。
- 数据准备与转换：Controller负责准备和处理数据，将从业务逻辑组件获取的数据转换为适合呈现给用户的格式，如JSON、HTML等。
- 调用视图层：在MVC架构中，Controller将处理完请求后，将数据传递给视图层（View）进行展示。视图层负责将处理后的数据以用户可读的形式呈现出来。
- 处理异常和错误：Controller负责捕获和处理业务逻辑中的异常和错误情况。它可以根据具体情况返回适当的错误信息或跳转到错误页面。
- 路由和URL映射：Controller负责根据请求的URL路径，将请求路由到适当的处理方法。它通常使用路由配置来定义URL与处理方法之间的映射关系。
总体而言，Controller在应用程序中扮演着请求处理和业务逻辑协调的角色。它帮助将用户的请求转化为具体的操作，并将相应的结果返回给用户。同时，Controller也负责处理异常和错误情况，确保应用程序的稳定性和可靠性。
14.UserController.java创建
/src/main/java/com/practice/controller/UserController.java
java
package com.practice.controller;
import com.practice.pojo.User;
import com.practice.service.UserService;
import com.practice.vo.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
@RestController
@RequestMapping("/user") //分配请求组前缀相于二级路径
public class UserController {
@Autowired
UserService userService;
/**
* function name findAll
* explain
* find all user from the service -> dao
* @return all user information
*/
@RequestMapping("/findAllUser")
public Result findAll(){
List<User> list = userService.findUser();
return Result.ok(list);
}
}
说明：
@RestController: 这是一个Spring注解，表示该类是一个RESTful控制器，用于处理HTTP请求并返回RESTful风格的响应。@RequestMapping("/user"): 这是一个类级别的注解，指定了处理该控制器中所有请求的基础路径。所有以"/user"开头的请求都将由该控制器处理。@Autowired: 这是一个Spring注解，用于自动注入UserService的实例。@RequestMapping("/findAllUser"): 这是一个方法级别的注解，指定了处理"/user/findAllUser"请求的路径。Result: 这是一个自定义的响应结果类，用于封装请求的返回结果。findAll(): 这是一个处理"/user/findAllUser"请求的方法。它通过调用userService.findUser()方法获取所有用户的信息，并将结果封装到Result对象中返回。
该控制器类的作用是处理与用户相关的请求，其中findAll()方法用于获取所有用户的信息。
15.Redis集成
1.redis安装
要在Docker中安装和启动Redis，你可以按照以下步骤进行操作：
安装Docker：首先，确保你已经在你的系统上安装了Docker。你可以根据你的操作系统在Docker官方网站上找到适合你的安装方法和文档。
拉取Redis镜像：使用以下命令从Docker Hub上拉取Redis镜像。
linux
docker pull redis启动Redis容器：使用以下命令启动Redis容器。
linux
docker run --name my-redis -p 6379:6379 -d redis上述命令将创建一个名为"my-redis"的容器，并将Redis的默认端口6379映射到主机的6379端口。你可以根据需要修改端口映射。
验证Redis启动：可以使用以下命令来验证Redis容器是否成功启动。
linux
docker ps上述命令将列出正在运行的Docker容器，你应该能够看到名为"my-redis"的容器。
至此，你已经成功安装和启动了Redis容器。你可以使用任何支持Redis的客户端工具（如Redis CLI或Redis Desktop Manager）连接到Redis服务器，并进行操作。
如果你希望在容器启动时保留Redis数据，你可以使用数据卷或映射主机目录来持久化Redis数据。这样，在容器重新启动时，数据将得以保留。
2.新增Redis 启动器依赖
pom.xml
xml
<!-- Redis 启动器依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>3.编写配置文件向application文件追加配置
yaml
spring:
redis:
host: localhost # Redis服务器主机名
port: 6379 # Redis服务器端口
password: # Redis服务器密码（如果有的话）说明 :
host: Redis服务器的主机名或IP地址。如果Redis服务器运行在本地，可以使用默认的"localhost"。port: Redis服务器的端口号。默认的Redis端口是6379。password: Redis服务器的密码。如果你的Redis服务器需要密码验证，可以在这里填写密码。如果不需要密码验证，可以将此属性留空或删除。
根据你的实际配置需求，可以添加其他的Redis配置项。例如，你可以配置连接池相关的属性，如最大连接数、最大空闲连接数等。
以下是一个包含连接池配置的示例：
yaml
spring:
redis:
host: localhost
port: 6379
password:
jedis:
pool:
max-active: 10 # 最大活动连接数
max-idle: 5 # 最大空闲连接数
min-idle: 1 # 最小空闲连接数
timeout: 3000 # 连接超时时间（毫秒）在上述示例中，我们添加了jedis.pool下的属性来配置连接池的相关设置。
请根据你的实际需求进行Redis的YAML配置，并确保将配置文件命名为application.yml并放置在正确的位置，以便Spring Boot应用程序能够正确加载和使用Redis配置。
4.在我们的项目中测试使用redis
修改/src/main/java/com/practice/service/impl/UserServiceimpl.java中的逻辑来测试，我们随便找个findUser方法来修改
java
package com.practice.service.impl;
import com.practice.dao.UserMapper;
import com.practice.pojo.User;
import com.practice.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
/**
* 这是一个用户服务的实现类。
* 该类使用@Service注解将其标记为Spring的服务组件，
* 并使用@Transactional注解指定了事务的范围。
*
* 类中的方法完成了对用户的增删改查操作，
* 通过@Override注解表明这些方法是接口UserService中定义的方法的实现。
* 方法中使用UserMapper来执行对数据库的操作，比如插入、更新、查询等。
*/
@Service
@Transactional
public class UserServiceimpl implements UserService {
@Autowired
UserMapper userMapper;//Could not autowire. No beans of"UserMapper' type found. more... (SB F1)不用去管
@Autowired
private RedisTemplate redisTemplate;//Could not autowire. No beans of"RedisTemplate' type found. more... (SB F1)不用去管
/**
* 查询所有用户，先从缓存中获取，如果缓存中没有，则从数据库中获取，并将结果存入缓存。
*
* @return 用户列表
*/
@Override
public List<User> findUser() {
// 尝试从缓存中获取用户列表
List<User> userList = (List<User>) redisTemplate.boundValueOps("UserList").get();
// 如果缓存中存在数据，直接返回缓存中的数据
if (userList != null && !userList.isEmpty()) {
System.out.println("Read the data from the cache. List: " + userList);
return userList;
}
// 缓存中没有数据，从数据库中获取用户列表
userList = userMapper.selectAll();
// 将从数据库中获取的用户列表存入缓存
redisTemplate.boundValueOps("UserList").set(userList);
System.out.println("Read the data from the database. List: " + userList);
return userList;
}
/**
* 根据ID查询用户
*
* @param id 用户ID
* @return 用户对象
*/
@Override
public User findUserById(long id) {
return userMapper.selectByPrimaryKey(id);
}
/**
* 保存用户
*
* @param user 用户对象
*/
@Override
public void saveUser(User user) {
userMapper.insert(user);
}
/**
* 更新用户
*
* @param user 用户对象
*/
@Override
public void updateUser(User user) {
userMapper.updateByPrimaryKey(user);
}
/**
* 根据ID删除用户
*
* @param id 用户ID
*/
@Override
public void deleteUerById(Long id) {
userMapper.deleteByPrimaryKey(id);
}
}
说明：
@Autowired private RedisTemplate redisTemplate; 是Spring框架的依赖注入注解，用于将一个名为 redisTemplate 的 RedisTemplate 类型的 Bean 注入到当前类中。
在这里，RedisTemplate 是Spring Data Redis提供的一个模板类，用于简化对Redis的操作。它提供了一组操作方法，允许你以更高层次的抽象方式与Redis进行交互，而不必直接使用底层的Redis命令。
redisTemplate 的作用可以包括但不限于：
- 简化Redis操作： 通过
redisTemplate，你可以使用一种更高级别的API（例如opsForValue()，opsForHash()等）来执行常见的Redis操作，而不必直接调用底层的Redis命令。 - 提供类型转换：
RedisTemplate提供了对对象的序列化和反序列化支持，因此你可以直接存储和检索Java对象，而不必手动进行序列化和反序列化。 - 统一管理连接：
RedisTemplate管理着与Redis的连接，确保连接的合理使用，避免了手动管理连接的复杂性。 - 集成Spring特性： 由于使用了
@Autowired注解，这个RedisTemplate可能受益于Spring的其他功能，如事务管理、AOP等。
在你的代码中，这个注入的 RedisTemplate 实例可以用于执行与Redis相关的操作，例如在 findUser() 方法中，你使用了它来从Redis缓存中获取用户列表并将其存入缓存。
5.查看docker 中的redis服务是否存入
首先，让我们看看如何使用Redis的命令行工具来查询键的值：
-
打开终端，并连接到Redis容器。使用以下命令连接到Redis容器：
linuxdocker exec -it <redis_container_id_or_name> redis-cli将
<redis_container_id_or_name>替换为你的Redis容器的ID或名称。 -
在Redis命令行中，使用以下命令查询键"UserList"的值：
linuxGET UserList如果键存在，将返回存储在该键下的值。如果键不存在，将返回空值(nil)。
6.【扩展-可自行研究】工欲善其事必先利其器 封装一个redis的通用class
新建一个utils的包/src/main/java/com/practice/utils
在utils的包下新建一个RedisUtil.java
/src/main/java/com/practice/utils/RedisUtil.java(通用的Redis分装)
java
package com.practice.utils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundValueOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import java.util.concurrent.TimeUnit;
/**
* RedisUtil is a utility class for interacting with Redis.
* It provides common operations for storing, retrieving, and managing data in Redis.
*
* @param <T> the type of the value stored in Redis
* @Author Wujiahao
*/
/**
* RedisUtil是一个用于与Redis进行交互的工具类。
* 它提供了在Redis中存储、检索和管理数据的常见操作。
*
* @param <T> 存储在Redis中的值的类型
* @Author Wujiahao
*/
@Component
public class RedisUtil<T> {
// 通过自动配置生成 `RedisHealthContributorAutoConfiguration.class`和`RedisAutoConfiguration.java`是Spring Boot中与Redis相关的自动配置类。
// Redis template for storing key-value pairs
// 用于存储键值对到Redis的Redis模板
@Autowired
private RedisTemplate<String, T> redisTemplate; // 存储键值对到 Redis 中
/**
* Set a key-value pair in Redis.
*
* @param key the key
* @param value the value
*/
/**
* 在Redis中设置键值对。
*
* @param key 键
* @param value 值
*/
public void set(String key, T value) {
redisTemplate.opsForValue().set(key, value);
}
/**
* Set a key-value pair in Redis with an expiration time (in seconds).
*
* @param key the key
* @param value the value
* @param timeout the expiration time in seconds
*/
/**
* 在Redis中设置键值对，并设置过期时间（单位：秒）。
*
* @param key 键
* @param value 值
* @param timeout 过期时间（秒）
*/
// 存储键值对到 Redis 中并设置过期时间（单位：秒）
public void set(String key, T value, long timeout) {
redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
}
/**
* Get the value associated with a key from Redis.
*
* @param key the key
* @return the value associated with the key
*/
/**
* 根据键从Redis中获取关联的值。
*
* @param key 键
* @return 与键关联的值
*/
// 根据键获取存储在 Redis 中的值
public T get(String key) {
return redisTemplate.opsForValue().get(key);
}
/**
* Delete the value associated with a key from Redis.
*
* @param key the key
*/
/**
* 根据键从Redis中删除关联的值。
*
* @param key 键
*/
// 根据键删除存储在 Redis 中的值
public void delete(String key) {
redisTemplate.delete(key);
}
/**
* Returns the BoundValueOperations associated with the given key.
*
* @param key the key
* @return the BoundValueOperations associated with the key
*/
/**
* 返回与给定键关联的BoundValueOperations对象。
*
* @param key 键
* @return 与键关联的BoundValueOperations对象
*/
// 返回与给定键关联的 BoundValueOperations 对象
public BoundValueOperations<String, T> boundValueOps(String key) {
return redisTemplate.boundValueOps(key);
}
/**
* Check if a key exists in Redis.
*
* @param key the key
* @return true if the key exists, false otherwise
*/
/**
* 检查键是否存在于Redis中。
*
* @param key 键
* @return 如果键存在，则返回true；否则返回false
*/
// 检查键是否存在于 Redis 中
public boolean exists(String key) {
return redisTemplate.hasKey(key);
}
/**
* Set the expiration time (in seconds) for a key.
*
* @param key the key
* @param timeout the expiration time in seconds
*/
/**
* 设置键的过期时间（单位：秒）。
*
* @param key 键
* @param timeout 过期时间（秒）
*/
// 设置键的过期时间（单位：秒）
public void expire(String key, long timeout) {
redisTemplate.expire(key, timeout, TimeUnit.SECONDS);
}
/**
* Get the expiration time (in seconds) for a key.
*
* @param key the key
* @return the expiration time in seconds, or -1 if the key does not exist or does not have an expiration time
*/
/**
* 获取键的过期时间（单位：秒）。
*
* @param key 键
* @return 键的过期时间（秒），如果键不存在或没有设置过期时间，则返回-1
*/
// 获取键的过期时间（单位：秒）
public long getExpiration(String key) {
return redisTemplate.getExpire(key, TimeUnit.SECONDS);
}
}说明：
上面这段代码紧紧代表一个封装的示例，有需要的各人请自己在细化封装的内容
RedisHealthContributorAutoConfiguration.class和RedisAutoConfiguration.java是Spring Boot中与Redis相关的自动配置类。
RedisHealthContributorAutoConfiguration.class是用于配置Redis的健康检查相关的自动配置。它提供了一个RedisHealthIndicator，用于检查Redis连接的健康状态，并将该指标添加到应用程序的健康检查中。
RedisAutoConfiguration.java是用于配置Redis的自动配置类。它提供了RedisTemplate、StringRedisTemplate和其他与Redis相关的Bean的自动配置。
在你的示例中，通过使用@Autowired注解将RedisTemplate注入到一个组件中，该组件可以使用Redis功能。
自动配置的原理如下：
- 当你引入了
spring-boot-starter-data-redis依赖时，Spring Boot会自动扫描并加载RedisAutoConfiguration.java，该类包含了与Redis相关的自动配置逻辑。 RedisAutoConfiguration.java中的自动配置类会根据应用程序的配置文件（如application.properties或application.yml）中的属性，创建一个RedisConnectionFactory对象，用于与Redis服务器建立连接。- 接着，自动配置类会根据
RedisConnectionFactory创建一个RedisTemplate对象，用于执行Redis操作。RedisTemplate是Spring Data Redis提供的一个核心类，它封装了对Redis的各种操作，如存储、检索、删除等。 - 当你在其他组件中使用
@Autowired注解将RedisTemplate注入时，Spring会检测到RedisTemplate的存在，并自动将其注入到对应的组件中。
因此，通过@Autowired注解将RedisTemplate注入到组件中，利用了Spring Boot的自动配置机制，使得你可以方便地在应用程序中使用Redis功能，而无需手动创建和配置RedisTemplate实例。
需要注意的是，自动配置是根据一系列默认规则和条件进行的，如果你想要自定义Redis的配置，可以在配置文件中指定相应的属性，或者通过编写自定义的配置类来覆盖默认的自动配置行为
7.【扩展-可自行研究】redis通用工具类的使用测试（TEST）
在你的 Spring Boot 项目中，确保已经配置了 Redis 相关的依赖和连接信息。你可以在 application.properties 或 application.yml 文件中配置 Redis 的连接信息。 在需要使用 Redis 的地方，引入 RedisUtil 类，可以通过 @Autowired 或构造函数注入。 使用 RedisUtil 对象调用相应的方法进行 Redis 操作。 下面是一个使用示例：
typescript
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class YourClass {
@Autowired
private RedisUtil<String> redisUtil;
public void yourMethod() {
// 存储值到 Redis
redisUtil.set("myKey", "myValue");
// 获取 Redis 中的值
String value = redisUtil.get("myKey");
// 判断键是否存在
boolean exists = redisUtil.exists("myKey");
// 设置键的过期时间
redisUtil.expire("myKey", 60);
// 获取键的过期时间
long expiration = redisUtil.getExpiration("myKey");
// 删除键
redisUtil.delete("myKey");
}
}