Pom依赖文件

1. Maven 父 POM（Project Object Model）配置

  <parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>3.2.3</version></parent>

主要作用：

1. 依赖管理

自动管理 Spring Boot 相关依赖的版本
无需手动指定版本号，例如：

<!-- 不需要写版本号 -->
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId>
</dependency>

2. 默认配置

• 预配置了常用的 Maven 插件
• 设置了合理的编译选项和编码（UTF-8）
• 定义了标准的目录结构

3.插件管理

• 自动配置了 Spring Boot Maven 插件：

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

2.确保 Maven 在读取源代码文件时使用 UTF-8 编码

  <properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding></properties>

• 防止中文等非ASCII字符出现乱码问题

3.Spring Boot 的核心启动器依赖

        <dependency><!-- 引入SpringBoot的核心启动器依赖 --><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId><!-- 排除 默认使用的logback  --><exclusions><exclusion>
<!--                    排除掉了SpringBoot默认绑定的日志框架--><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-logging</artifactId></exclusion></exclusions></dependency>

4. Spring Boot 的 AOP starter 依赖

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

什么是AOP:

AOP（Aspect-Oriented Programming）面向切面编程，是一种编程范式，用于将横切关注点（如日志、事务、安全等）与业务逻辑分离。

5. Spring Boot 的邮件发送 starter 依赖

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

6. Spring Boot 的 Web 开发核心依赖

主要作用：

1. 引入完整的 Web 开发栈

包含：

• spring-webmvc: Spring MVC 框架
• spring-web: Spring Web 核心
• tomcat: 内嵌 Tomcat 服务器
• jackson: JSON 处理库
• spring-boot-starter-json: JSON 支持
• spring-boot-starter-tomcat: Tomcat 容器
• validation-api: 参数校验

2. 自动配置 Web 环境

• 自动配置 DispatcherServlet

• 配置视图解析器

• 配置静态资源处理

• 配置消息转换器（JSON/XML）

核心功能：

1.RESTful API 支持

@RestController
@RequestMapping("/api/users")
public class UserController {@GetMapping("/{id}")public User getUser(@PathVariable Long id) {return userService.findById(id);}@PostMappingpublic User createUser(@RequestBody User user) {return userService.save(user);}@PutMapping("/{id}")public User updateUser(@PathVariable Long id, @RequestBody User user) {return userService.update(id, user);}@DeleteMapping("/{id}")public void deleteUser(@PathVariable Long id) {userService.delete(id);}
}

2. 静态资源服务

# 默认静态资源目录
- /static
- /public 
- /resources
- /META-INF/resources# 可以直接访问：
# http://localhost:8080/css/style.css
# http://localhost:8080/js/app.js

自动配置的特性：

1.内嵌服务器:

// 无需外部Tomcat，直接运行
@SpringBootApplication
public class Application {public static void main(String[] args) {SpringApplication.run(Application.class, args);}
}

2. 默认配置

端口：8080

上下文路径：/

错误页面：自动配置

文件上传：自动配置

3.JSON自动转换

// 自动将对象转换为JSON
@RestController
public class ApiController {@GetMapping("/data")public Map<String, Object> getData() {return Map.of("name", "张三", "age", 25);// 自动返回: {"name": "张三", "age": 25}}
}

完整项目结构示例：

src/main/java/└── com/example/├── Application.java          # 启动类├── controller/               # 控制器├── service/                  # 业务层├── repository/               # 数据层└── entity/                   # 实体类src/main/resources/├── static/                        # 静态资源├── templates/                     # 模板文件└── application.yml                # 配置文件

7. Spring Boot 的测试 starter 依赖，专门用于单元测试和集成测试。

        <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency>

在test文件夹下创建文件进行测试功能，
1.基础注解：

@SpringBootTest // 启动完整Spring容器
@WebMvcTest     // 只启动Web层，不启动完整容器
@DataJpaTest    // 只测试JPA组件
@JsonTest       // 只测试JSON序列化

例如对JWT进行测试：

package com.itheima;import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.Claim;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.auth0.jwt.interfaces.Verification;
import org.junit.jupiter.api.Test;import java.util.Date;
import java.util.HashMap;
import java.util.Map;public class JwtTest {@Testpublic void testGen(){Map<String,Object> claims = new HashMap<>();claims.put("id",1);claims.put("username","张三");//生成jwt代码String token = JWT.create().withClaim("user",claims)//添加载荷.withExpiresAt(new Date(System.currentTimeMillis()+1000*60*60*6))//设置过期时间.sign(Algorithm.HMAC256("itheima"));//设置签名算法和密钥System.out.println(token);}@Testpublic void testParse(){//定义字符串，模拟用户传递过来的tokenString token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyIjp7ImlkIjoxLCJ1c2VybmFtZSI6IuW8oOS4iSJ9LCJleHAiOjE3NTkzMzk1ODZ9.0wSQT5gVCEIxKfbkMv-Y4ZzUvuZx4dvRDEgp8madk1s";JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256("itheima")).build();DecodedJWT decodedJWT = jwtVerifier.verify(token);//验证token，生成一个解析后的JWT对象Map<String, Claim> claims = decodedJWT.getClaims();System.out.println(claims.get("user"));//如果纂改了头部和载荷部分的数据，那么验证失败//如果密钥改了 验证失败//如果token过期了 验证失败}
}

8. Spring Boot 的 Redis 数据访问 starter 依赖

<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

主要作用：

1. 引入完整的 Redis 客户端栈

包含：

• spring-data-redis: Spring Data Redis 核心
• lettuce-core: Lettuce Redis 客户端（默认）
• spring-boot-starter: 基础依赖

2.自动配置 Redis 连接

• 自动配置 RedisConnectionFactory
• 自动配置 RedisTemplate 和 StringRedisTemplate
• 支持连接池配置
• 支持哨兵和集群模式

核心组件详解：

1. RedisTemplate - 通用操作模板

@Autowired
private RedisTemplate<String, Object> redisTemplate;// 操作各种数据类型
redisTemplate.opsForValue().set("key", "value");      // String
redisTemplate.opsForList().leftPush("list", "item");  // List
redisTemplate.opsForSet().add("set", "item");         // Set
redisTemplate.opsForHash().put("hash", "field", "value"); // Hash

2.StringRedisTemplate - 字符串专用模板

@Autowired
private StringRedisTemplate stringRedisTemplate;// 专门处理字符串操作
stringRedisTemplate.opsForValue().set("name", "张三");
String name = stringRedisTemplate.opsForValue().get("name");

9. 阿里巴巴的 FastJSON 库依赖，它是 Java 中一个高性能的 JSON 处理库

<dependency><groupId>com.alibaba</groupId><artifactId>fastjson</artifactId><version>1.2.76</version>
</dependency>

主要作用

1. 提供 JSON 序列化和反序列化功能

核心功能：

• 将 Java 对象转换为 JSON 字符串（序列化）
• 将 JSON 字符串转换为 Java 对象（反序列化）
• 高性能的 JSON 处理能力

主要特性：

1. 极高的性能

• 号称最快的 Java JSON 处理器
• 比 Jackson、Gson 等库性能更好
• 特别适合大数据量和高并发场景

2.简单易用的API

// 序列化：对象 → JSON字符串
String jsonString = JSON.toJSONString(user);// 反序列化：JSON字符串 → 对象
User user = JSON.parseObject(jsonString, User.class);// 解析为JSONObject
JSONObject jsonObject = JSON.parseObject(jsonString);

10.MySQL 官方 JDBC 驱动程序依赖，用于 Java 应用程序连接和操作 MySQL 数据库

<dependency><groupId>com.mysql</groupId><artifactId>mysql-connector-j</artifactId><version>8.0.33</version> <!-- 版本号通常也会指定 -->
</dependency>

主要作用

1.提供 MySQL 数据库连接能力

核心功能：
- 建立 Java 应用与 MySQL 数据库的连接
- 执行 SQL 语句（查询、更新、存储过程等）
- 处理事务管理
- 数据库元数据操作

2.核心组件和功能：

1. JDBC 驱动类

// 驱动类名
com.mysql.cj.jdbc.Driver// JDBC URL 格式
jdbc:mysql://主机名:端口/数据库名?参数=值

2.主要接口实现

• Connection: 数据库连接
• Statement, PreparedStatement: SQL 语句执行
• ResultSet: 查询结果集
• DatabaseMetaData: 数据库元信息

application.yml:

spring:datasource:driver-class-name: com.mysql.cj.jdbc.Driverurl: jdbc:mysql://localhost:3306/big_eventusername: rootpassword: 1234data:redis:host: localhostport: 6379

11.Spring Boot 配置处理器依赖，用于在编译时生成配置元数据，提供更好的配置支持

<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-configuration-processor</artifactId><optional>true</optional>
</dependency>

主要作用：

主要功能：

• 自动生成 spring-configuration-metadata.json 文件
• 为自定义配置属性提供IDE智能提示
• 生成配置属性的文档信息

12.Apache Commons Lang 3 工具库依赖，提供了大量实用的 Java 工具类，弥补了 JDK 标准库的不足。

主要作用

1. 提供丰富的工具类和方法

核心功能：

• 字符串处理工具
• 对象操作工具
• 数组和集合工具
• 日期时间工具
• 系统相关工具

核心工具类详解：

1. StringUtils - 字符串工具类（最常用）

import org.apache.commons.lang3.StringUtils;// 1. 空值检查
String str = null;
StringUtils.isEmpty(str);        // true - null或空字符串
StringUtils.isBlank("   ");      // true - null/空字符串/纯空格
StringUtils.isNotEmpty("hello"); // true - 非null且非空
StringUtils.isNotBlank(" hello "); // true - 非null且非空白// 2. 字符串处理
StringUtils.trim("  hello  ");           // "hello" - 去空格
StringUtils.strip("**hello**", "*");     // "hello" - 去除指定字符
StringUtils.substring("hello world", 0, 5); // "hello" - 子字符串
StringUtils.left("hello", 3);            // "hel" - 取左边3个字符
StringUtils.right("hello", 2);           // "lo" - 取右边2个字符// 3. 字符串比较
StringUtils.equals(str1, str2);          // 安全的equals，处理null
StringUtils.equalsIgnoreCase("Hello", "hello"); // true// 4. 字符串拼接/拆分
StringUtils.join(new String[]{"a", "b", "c"}, ","); // "a,b,c"
String[] parts = StringUtils.split("a,b,c", ",");   // ["a","b","c"]
StringUtils.repeat("ab", 3);             // "ababab" - 重复字符串// 5. 字符串填充
StringUtils.leftPad("5", 3, '0');        // "005" - 左填充
StringUtils.rightPad("5", 3, '0');       // "500" - 右填充// 6. 字符串查找替换
StringUtils.contains("hello world", "world");    // true
StringUtils.countMatches("ababab", "ab");        // 3
StringUtils.replace("hello world", "world", "java"); // "hello java"

2.ObjectUtils - 对象工具类

import org.apache.commons.lang3.ObjectUtils;// 空值安全操作
ObjectUtils.defaultIfNull(null, "default"); // "default"
ObjectUtils.firstNonNull(null, null, "first", "second"); // "first"// 对象比较
ObjectUtils.compare(1, 2);                // -1
ObjectUtils.max(1, 2, 3);                 // 3
ObjectUtils.min(1, 2, 3);                 // 1// 对象信息
ObjectUtils.identityToString(obj);        // 对象标识字符串

3.ArrayUtils-数组工具类

import org.apache.commons.lang3.ArrayUtils;// 数组操作
String[] array = {"a", "b", "c"};
ArrayUtils.contains(array, "b");          // true
ArrayUtils.indexOf(array, "b");           // 1
ArrayUtils.reverse(array);                // 反转数组 ["c","b","a"]// 数组增删
ArrayUtils.add(array, "d");               // 添加元素
ArrayUtils.remove(array, 1);              // 删除指定位置元素
ArrayUtils.removeElement(array, "b");     // 删除指定元素// 数组合并
String[] array1 = {"a", "b"};
String[] array2 = {"c", "d"};
ArrayUtils.addAll(array1, array2);        // ["a","b","c","d"]// 空数组常量
String[] empty = ArrayUtils.EMPTY_STRING_ARRAY;

4. BooleanUtils - 布尔工具类

import org.apache.commons.lang3.BooleanUtils;// 布尔值转换
BooleanUtils.toBoolean("true");           // true
BooleanUtils.toBooleanObject("yes");      // Boolean.TRUE
BooleanUtils.toInteger(true);             // 1// 布尔值判断
BooleanUtils.isTrue(Boolean.TRUE);        // true
BooleanUtils.isNotFalse(Boolean.TRUE);    // true
BooleanUtils.and(new boolean[]{true, false}); // false
BooleanUtils.or(new boolean[]{true, false});  // true

13. MyBatis-Plus 的 Spring Boot Starter 依赖，是基于 MyBatis 的增强工具库，极大地简化了 MyBatis 的开发。

<dependency><groupId>com.baomidou</groupId><artifactId>mybatis-plus-boot-starter</artifactId><version>3.4.3</version>
</dependency>

主要作用

核心功能：

• 自动生成 CRUD 操作
• 强大的条件构造器
• 分页插件支持
• 代码生成器
• 性能分析插件

核心特性详解：

1. 自动 CRUD 操作

传统 MyBatis： 需要手动编写每个实体的 Mapper 和 XML
MyBatis-Plus： 继承 BaseMapper 即可获得完整 CRUD 功能

// 实体类
@Data
@TableName("user")  // 指定表名
public class User {@TableId(type = IdType.AUTO)  // 主键策略：自增private Long id;private String name;private Integer age;private String email;@TableField("create_time")  // 字段映射private LocalDateTime createTime;
}// Mapper接口 - 只需要继承BaseMapper，无需写SQL
public interface UserMapper extends BaseMapper<User> {// 已经自动拥有所有基础CRUD方法
}// 直接使用，无需实现
@Service
public class UserService {@Autowiredprivate UserMapper userMapper;public void testCRUD() {// 插入User user = new User();user.setName("张三");user.setAge(25);user.setEmail("[e-mail]");userMapper.insert(user);  // 自动回填ID// 查询User result = userMapper.selectById(1L);List<User> users = userMapper.selectList(null);  // 查询所有// 更新user.setAge(26);userMapper.updateById(user);// 删除userMapper.deleteById(1L);}
}

强大的条件构造器（QueryWrapper）

// 复杂查询无需写SQL
public List<User> complexQuery(String name, Integer minAge, Integer maxAge) {QueryWrapper<User> wrapper = new QueryWrapper<>();wrapper.like("name", name)                    // name like '%值%'.between("age", minAge, maxAge)        // age between min and max.isNotNull("email")                    // email is not null.orderByDesc("create_time")            // 按创建时间倒序.last("LIMIT 10");                     // 最后拼接SQLreturn userMapper.selectList(wrapper);
}// Lambda表达式写法（推荐，类型安全）
public List<User> lambdaQuery(String name, Integer minAge) {LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();wrapper.like(User::getName, name)             // 使用方法引用，编译期检查.ge(User::getAge, minAge)              // age >= minAge.select(User::getId, User::getName)    // 只查询指定字段.orderByAsc(User::getAge);return userMapper.selectList(wrapper);
}

3.分页插件

@Configuration
public class MybatisPlusConfig {@Beanpublic MybatisPlusInterceptor mybatisPlusInterceptor() {MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));return interceptor;}
}// 使用分页
@Service
public class UserService {public Page<User> getUserPage(int current, int size, String name) {Page<User> page = new Page<>(current, size);LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();wrapper.like(StringUtils.isNotBlank(name), User::getName, name);return userMapper.selectPage(page, wrapper);}
}// 控制器中使用
@RestController
@RequestMapping("/users")
public class UserController {@Autowiredprivate UserService userService;@GetMappingpublic Page<User> getUsers(@RequestParam(defaultValue = "1") int current,@RequestParam(defaultValue = "10") int size,@RequestParam(required = false) String name) {return userService.getUserPage(current, size, name);}
}

性能优化：

1.分页优化：

// 使用优化分页（不会查询总记录数，性能更好）
public Page<User> optimizePage(int current, int size) {Page<User> page = new Page<>(current, size);page.setSearchCount(false);  // 不查询总记录数return userMapper.selectPage(page, null);
}

2. 查询字段优化

// 只查询需要的字段
public List<User> selectSpecificFields() {LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();wrapper.select(User::getId, User::getName, User::getEmail);  // 只查询这三个字段return userMapper.selectList(wrapper);
}

14.Lombok 依赖

<dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId></dependency>

主要功能：

1. @Data万能注解（最常用）

// 使用Lombok后
@Data
public class User {private Long id;private String name;private Integer age;private String email;
}
// 自动生成：所有字段的getter/setter、equals()、hashCode()、toString()

2. @NoArgsConstructor / @AllArgsConstructor @RequiredArgsConstructor - 构造函数

import lombok.*;@NoArgsConstructor                      // 无参构造函数
@AllArgsConstructor                     // 全参构造函数
@RequiredArgsConstructor                // 必需参数构造函数（final字段或@NonNull字段）
public class User {private Long id;@NonNull                            // 该字段不能为nullprivate String name;private Integer age;
}// 相当于自动生成：
// public User() {}
// public User(Long id, String name, Integer age) {}
// public User(String name) { this.name = name; }

最常用的组合：

import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.AllArgsConstructor;@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {private String name;private int age;private String email;
}

4.@Slf4j / @Log4j - 自动生成日志对象

import lombok.extern.slf4j.Slf4j;@Slf4j
@Service
public class UserService {public void processUser(User user) {// 直接使用log对象，无需手动创建log.info("开始处理用户: {}", user.getName());try {// 业务逻辑log.debug("用户处理详情: {}", user);} catch (Exception e) {log.error("处理用户失败: {}", user.getId(), e);}}
}// 相当于自动生成：
// private static final Logger log = LoggerFactory.getLogger(UserService.class);

15. Auth0 Java JWT 库依赖

是另一个非常流行的 JWT 处理库，由 Auth0 公司维护。相比 JJWT，它提供了更现代的 API 设计和更多高级特性。

主要作用：

1. 提供完整的 JWT 创建、验证和解析功能

核心功能：

• 创建、验证、解析 JWT 令牌
• 支持所有标准算法（HS256, RS256, ES256等）
• 自动验证过期时间、生效时间等声明
• 支持 JWT 令牌刷新
• 更好的错误处理和异常信息

JWTUtils包：

package com.itheima.utils;import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;import java.util.Date;
import java.util.Map;public class JwtUtil {private static final String KEY = "itheima";//接收业务数据,生成token并返回public static String genToken(Map<String, Object> claims) {return JWT.create().withClaim("claims", claims).withExpiresAt(new Date(System.currentTimeMillis() + 1000 * 60 * 60 * 12)).sign(Algorithm.HMAC256(KEY));}//接收token,验证token,并返回业务数据public static Map<String, Object> parseToken(String token) {return JWT.require(Algorithm.HMAC256(KEY)).build().verify(token).getClaim("claims").asMap();}}