AA. 我的开发环境配置与核心工具链解析

一、开发环境全览

C:\Users\Again>java -version
java version "21.0.1" 2023-10-17 LTS
Java(TM) SE Runtime Environment (build 21.0.1+12-LTS-29)
Java HotSpot(TM) 64-Bit Server VM (build 21.0.1+12-LTS-29, mixed mode, sharing)

C:\Users\Again>javac -version
javac 21.0.1

C:\Users\Again>node -v
v20.18.1

C:\Users\Again>npm -v
10.8.2

C:\Users\Again>git --version
git version 2.47.1.windows.2

C:\Users\Again>python --version
Python 3.11.5

C:\Users\Again>mysql --version
mysql  Ver 8.0.28 for Win64 on x86_64 (MySQL Community Server - GPL)

C:\Users\Again>mvn -v
Apache Maven 3.9.9 (8e8579a9e76f7d015ee5ec7bfcdc97d260186937)
Maven home: D:\apache-maven-3.9.9-bin\apache-maven-3.9.9
Java version: 21.0.1, vendor: Oracle Corporation, runtime: C:\Program Files\Java\jdk-21
Default locale: zh_CN, platform encoding: UTF-8
OS name: "windows 11", version: "10.0", arch: "amd64", family: "windows"

通过网盘分享的文件：Java基础常用软件 链接:
https://pan.baidu.com/s/1I2w-dFsGkqfdjMAOFi-QOA
提取码: aet4

二、核心开发工具链深度解析

（一）Java生态系统基建

1. JDK 21.0.1 LTS（Oracle HotSpot）

• 版本特性：
  ◼ 作为LTS版本提供至2030年的长期支持
  ◼ 引入结构化并发（JEP 453）、记录模式（JEP 449）等生产级特性
  ◼ G1 GC优化实现更低延迟与更高吞吐量
• 环境关联：
  终端显示javac 21.0.1与运行时路径C:\Program Files\Java\jdk-21，已配置系统环境变量JAVA_HOME指向该路径

2. Apache Maven 3.9.9

• 工程化能力：
  ▶ 基于D:\apache-maven-3.9.9-bin的标准安装
  ▶ 自定义本地仓库配置：

  <!-- settings.xml 关键配置 -->
  <localRepository>D:\dev_repo\maven_local_repository</localRepository>
  

  ▶ 支持Maven Enforcer插件强制版本约束，集成SpotBugs实现静态代码分析

通过网盘分享的文件：apache-maven-3.9.9-bin.zip 链接:
https://pan.baidu.com/s/17hJ20ZZz1raIWB41G75Hqw
提取码: 8wdh

（二）JavaScript全栈工具链

1. Node.js v20.18.1（Current）

• 运行时特性：
  ● 内置fetch API原生支持，告别node-fetch第三方库
  ● 实验性WebAssembly垃圾回收（JEP 8305852）提升性能
  ● 终端显示版本与npm 10.8.2配套，符合node -v输出
• 典型应用：

  # 前端构建示例（Vite + React）
  npx create-vite@latest my-app --template react
  cd my-app && npm install && npm run dev
  

2. npm 10.8.2

• 依赖管理升级：
  ✅ 扁平化依赖树默认启用（package-lock.json自动生成）
  ✅ 支持npm install --workspace多包并行安装
  ✅ 终端输出版本与Node.js 20.x完美兼容，无版本冲突风险

（三）关系型数据库中枢

MySQL 8.0.28 Community Edition

• 企业级特性落地：
  ☑ 窗口函数实战：

  SELECT order_date, amount,
         SUM(amount) OVER (ORDER BY order_date ROWS BETWEEN 2 PRECEDING AND CURRENT ROW) AS moving_avg
  FROM sales;
  

  ☑ 原子DDL支持（如CREATE TABLE ... IF NOT EXISTS）
  ☑ JSON数据类型优化，支持JSON_TABLE() relationalization查询
• 环境适配：
  终端显示Win64原生支持，基于MySQL Installer完成图形化安装，配置文件位于C:\ProgramData\MySQL\MySQL Server 8.0\my.ini

三、高效开发IDE矩阵

1. IntelliJ IDEA 2024.1（Ultimate Edition）

• Java开发深度集成：
  ➤ 内置Maven/Gradle控制面板，同步终端mvn -v的本地仓库配置
  ➤ AI辅助编码（Code With Me）支持自然语言生成代码
  ➤ 可视化JVM监控工具，实时追踪G1 GC状态（对应JDK 21特性）
• 效率插件推荐：
  ▶ Lombok Plugin（简化POJO开发）
  ▶ Docker Integration（一键部署Spring Boot容器）

通过网盘分享的文件：02、Java开发工具-IDEA 链接:
https://pan.baidu.com/s/1C8CFC7Q-jlqIlmUKwcIDtA
提取码: 3ah5

2. Navicat Premium 17

• 多数据库管理中枢：
  ◼ 同时连接MySQL 8.0.28与其他数据库（如PostgreSQL 16）
  ◼ 可视化查询生成器支持窗口函数图形化配置
  ◼ 数据传输功能实现跨数据库结构同步
• 性能优化工具：
  ✦ SQL Explain执行计划分析
  ✦ 慢查询日志实时监控（需配合MySQL开启slow_query_log）

通过网盘分享的文件：Navicat Premium 17.0.8 (x64).7z 链接:
https://pan.baidu.com/s/1CT50564aJ8vJIHAKNXtw9A
提取码: wdhu

四、工具链协同工作流

五、环境扩展建议

1. 版本管理：通过asdf工具实现JDK/Node.js多版本切换
2. 容器化：基于Docker Desktop构建java:21-alpine+node:20-bullseye开发容器
3. 自动化：配置GitHub Actions实现Maven构建与MySQL数据迁移自动化

这套开发环境以长期支持版本为核心，结合标准化工具链与现代IDE特性，既能满足企业级项目的稳定性需求，又可快速响应新技术栈的探索需求。终端输出的版本信息形成完整的工具链闭环，为开发、测试、部署全流程提供可追溯的环境基准。

BB.如何在IntelliJ IDEA中新建Spring Boot项目（基于JDK 21 + Maven）

一、环境准备

确保已安装：

• JDK 21.0.1（终端验证：java -version显示21.x）
• Apache Maven 3.9.9（终端验证：mvn -v显示3.9.9）
• IntelliJ IDEA 2024.1（支持Spring Boot 3.x+与JDK 21）

二、新建项目步骤

1. 启动项目创建向导

• 打开IDEA，点击 新建项目（或快捷键 Ctrl+Shift+N），进入项目配置界面。

2. 选择Spring Boot模板

• 左侧列表：找到并选中 Spring Boot（红色框标记，如图所示）。
• 右侧配置：
  • 名称：输入项目名（如 springboot）。
  • 位置：选择本地存储路径（如 F:\springboot_CSND\springboot）。
  • 语言：默认 Java（适配JDK 21）。
  • 构建工具：选择 Maven（红色框标记，与终端mvn -v配置一致）。
  • 组/工件：默认 com.example（可自定义包名）。
  • JDK：下拉选择 21 java version ‘21.0.1’（匹配终端java -version）。
  • Java版本：选择 21（与JDK版本同步）。

3. 配置Spring Boot依赖（下一步）

• 点击 下一步(N)，进入Spring Initializr依赖选择界面：
  • 必选：Spring Web（构建RESTful API）。
  • 可选：根据需求添加（如 Spring Data JPA、MySQL Driver 等，对应数据库工具链）。
  • 版本：默认Spring Boot最新稳定版（与JDK 21兼容）。
    
    

4. 完成项目创建

• 点击 创建，IDEA自动生成项目结构：
  • pom.xml：Maven依赖配置（包含Spring Boot Parent POM）。
  • src/main/java/com/example/springboot：主应用类（SpringbootApplication.java）。
  • src/main/resources：配置文件（application.properties 或 application.yml）。

三、项目验证

1. 启动应用：
   右键主应用类，选择 运行 ‘SpringbootApplication’，控制台输出：

"C:\Program Files\Java\jdk-21\bin\java.exe"
  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/

 :: Spring Boot ::                (v3.5.0)

2025-06-03T15:53:30.374+08:00  INFO 26000 --- [springboot] [           main] com.example.SpringbootApplication        : Starting SpringbootApplication using Java 21.0.1 with PID 26000 (F:\springboot_CSND\springboot\target\classes started by Again in F:\springboot_CSND\springboot)
2025-06-03T15:53:30.376+08:00  INFO 26000 --- [springboot] [           main] com.example.SpringbootApplication        : No active profile set, falling back to 1 default profile: "default"
2025-06-03T15:53:31.122+08:00  INFO 26000 --- [springboot] [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port 8080 (http)
2025-06-03T15:53:31.137+08:00  INFO 26000 --- [springboot] [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
2025-06-03T15:53:31.138+08:00  INFO 26000 --- [springboot] [           main] o.apache.catalina.core.StandardEngine    : Starting Servlet engine: [Apache Tomcat/10.1.41]
2025-06-03T15:53:31.199+08:00  INFO 26000 --- [springboot] [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2025-06-03T15:53:31.199+08:00  INFO 26000 --- [springboot] [           main] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 782 ms
2025-06-03T15:53:31.535+08:00  INFO 26000 --- [springboot] [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port 8080 (http) with context path '/'
2025-06-03T15:53:31.540+08:00  INFO 26000 --- [springboot] [           main] com.example.SpringbootApplication        : Started SpringbootApplication in 1.609 seconds (process running for 2.327)

CC. Spring Boot 项目包结构搭建：分层架构的规范实现

一、包创建操作（IntelliJ IDEA 环境）

1.定位根包
在项目导航栏中，展开 src/main/java 目录，找到根包 com.example（Spring Boot 应用的基础包路径）。

2.创建分层包
右键点击 com.example，依次选择 New → Package，分别创建以下四个包（严格遵循小写命名规范，符合 Java 包命名 conventions）：
controller：处理 HTTP 请求与响应的控制层
dao：数据访问层（封装数据库 CRUD 操作，如 JPA Repository）
entity：实体类层（映射数据库表结构的 POJO）
service：业务逻辑层（实现核心业务规则与事务管理）
最终包结构如下（与截图一致，红色框标注核心分层包）：

com.example
├─ controller  # 控制层（请求处理）
├─ dao         # 数据访问层（数据库交互）
├─ entity      # 实体层（表映射）
├─ service     # 业务逻辑层（事务与业务规则）
└─ SpringbootApplication.java  # 应用启动类

![在这里插入图片描述](https://i-blog.csdnimg.cn/direct/7ee323c60c80403c8f7f32b4511b838d.png

DD. 在Spring Boot项目中创建实体类和控制器

1. 创建User实体类（Entity）

路径：src/main/java/com/example/entity/User.java

步骤：

1. 在entity包上右键 → New → Java Class
2. 输入类名User并回车
3. 添加以下代码：

package com.example.entity;

public class User {
    private Integer id;
    private String name;
    private String password;
    private Integer age;
    private String sex;
    private String phone;

    // 无参构造函数
    public User() {
    }

    // 全参构造函数
    public User(Integer id, String name, String password, Integer age, String sex, String phone) {
        this.id = id;
        this.name = name;
        this.password = password;
        this.age = age;
        this.sex = sex;
        this.phone = phone;
    }

    // Getter 和 Setter 方法（按顺序添加）
    public Integer getId() { return id; }
    public void setId(Integer id) { this.id = id; }

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public String getPassword() { return password; }
    public void setPassword(String password) { this.password = password; }

    public Integer getAge() { return age; }
    public void setAge(Integer age) { this.age = age; }

    public String getSex() { return sex; }
    public void setSex(String sex) { this.sex = sex; }

    public String getPhone() { return phone; }
    public void setPhone(String phone) { this.phone = phone; }
}

说明：

• 这是一个标准的Java Bean类（POJO）
• 使用封装特性（private字段+public访问器）
• 提供了无参和全参构造函数
• 字段设计对应数据库中的用户表结构
  构造函数、Getter和Setter可以右键->生成里快速生成
  

2. 创建User控制器（Controller）

路径：src/main/java/com/example/controller/UserController.java

步骤：

1. 在controller包上右键 → New → Java Class
2. 输入类名UserController并回车
3. 添加以下代码：

package com.example.controller;

import com.example.entity.User;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("user")
public class UserController {

    @GetMapping("/start")
    public String start() {
        return "这是你的第一个Spring项目工程！已经顺利启动";
    }

    @GetMapping("/getUser")
    public User getUser() {
        return new User(1, "张三", "123456", 18, "男", "12345678901");
    }
}

说明：

• @RestController：声明这是一个RESTful风格的控制器
• @RequestMapping("user")：设置基础请求路径
• @GetMapping：处理HTTP GET请求
• start()方法：返回字符串消息，验证项目启动
• getUser()方法：返回一个User对象实例，测试数据传输
  
  

3. 验证功能

启动应用：

1. 右键运行SpringbootApplication类的main方法
2. 查看控制台日志，确认Tomcat启动成功（默认端口8080）

测试接口：

1. 访问：http://localhost:8080/user/start
   预期返回：这是你的第一个Spring项目工程！已经顺利启动
   

2. 访问：http://localhost:8080/user/getUser
   预期返回JSON数据：

   {
       "id": 1,
       "name": "张三",
       "password": "123456",
       "age": 18,
       "sex": "男",
       "phone": "12345678901"
   }
   

---

还可以这样查看



得到的结果和浏览器中是一样的.

推荐网站： https://json4u.com/ 是一个专门给开发者用的在线JSON工具网站 。它有很多实用功能：

• 数据可视化：能把JSON数据变成图形或者表格的样子展示出来，就像把一堆杂乱的东西整理得整整齐齐、清清楚楚，让你很容易看懂数据的结构 。
• 数据处理：可以把格式乱乱的JSON数据整理得规规矩矩（格式化）；也能把JSON数据变得更紧凑（压缩） ；还能检查你的JSON数据格式对不对（验证）。要是你需要把JSON数据变成其他格式，比如XML、CSV、YAML ，它也能帮你一键转换。
• 数据对比：能帮你找出两份JSON数据有哪些地方不一样，快速发现差异。
• 其他小功能：还能做Base64编解码、生成UUID这些开发中会用到的小任务 。
  +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

这个网站用起来很方便，不需要注册账号，打开就能用，而且没有广告打扰 。
它处理数据都是在你自己的浏览器里进行的，不用担心数据会被偷偷传到其他地方，比较保护隐私。

EE. 配置数据访问层：通过 MyBatis、MySQL 驱动及通用 Mapper 建立 Java 应用与 MySQL 数据库连接与操作能力

修改pom.xml，添加MyBatis依赖 添加MySQL驱动依赖 添加tk.mybatis依赖，目的的为了支持数据库访问功能。这些依赖分别提供了以下功能：

1. MyBatis 集成依赖 (mybatis-spring-boot-starter)

• 作用：
  简化 MyBatis 与 Spring Boot 的集成，提供 SQL 映射和 ORM 功能，支持通过注解或 XML 配置数据库操作。

• 你需要它的原因：

  • 后续开发中，UserDao 接口将使用 MyBatis 的 @Mapper 和 @Select 等注解（如 @Select("SELECT * FROM user")）。
  • 服务层（如 UserService）需要通过 DAO 接口访问数据库，而该依赖提供了接口与 SQL 的映射机制。

2. MySQL 驱动依赖 (mysql-connector-j)

• 作用：
  提供 Java 与 MySQL 数据库的连接功能，是 JDBC 访问 MySQL 的基础组件。

• 你需要它的原因：

  • 配置文件中已指定 MySQL 的 JDBC 连接 URL：

    spring.datasource.url=jdbc:mysql://localhost:3306/springboot
    

  • 缺少该驱动会导致应用启动时抛出 java.sql.SQLException: No suitable driver found 异常。

3. tk.mybatis 通用 Mapper (mapper-spring-boot-starter)

• 作用：
  提供通用 Mapper 功能，基于单表 CRUD 操作自动生成 SQL，减少重复代码。

• 你需要它的原因：

  • 配置文件中已包含 tk.mybatis 的配置：

    mapper.mappers=tk.mybatis.mapper.common.Mapper
    

  • 后续开发中，若 UserDao 接口继承 tk.mybatis.mapper.common.Mapper，可直接获得单表 CRUD 方法（如 selectByPrimaryKey、insert 等），无需编写具体 SQL。

        <!-- 添加MyBatis依赖 添加MySQL驱动依赖  添加tk.mybatis依赖-->
        <!-- 添加MyBatis依赖 -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>3.0.3</version>
        </dependency>

        <!-- 添加MySQL驱动依赖 -->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>

        <!-- tk.mybatis依赖 -->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>4.2.2</version>
        </dependency>

maven_repository其实就是maven的仓库repository，使用默认的C:\Users\Again\.m2\repository也可以，从上图可以看到我这里默认的仓库路径C:\Users\Again\.m2\repository里都是完整的，如果改成这个路径D:\apache-maven-3.9.9-bin\maven_repository就会有些插件缺失（上图红色波浪线报错的插件），需要下载源代码/或文档+新加载所有Maven项目，也就是如图


总之，Maven 项目运行时需要在本地仓库中找到pom.xml里声明的所有依赖（包括插件）。

Maven遵循"约定优于配置"的原则，当你在pom.xml中声明依赖后：

• 首次构建：Maven会从中央仓库或配置的远程仓库下载依赖到本地仓库（默认路径：~/.m2/repository）
• 后续构建：直接使用本地仓库的缓存文件，无需重复下载
• 添加依赖后，Maven 会自动下载所需文件到本地仓库（默认路径：~/.m2/repository）。
• 本地仓库是必需的：Maven必须在本地找到所有依赖才能编译和运行项目。
  

FF.构建数据访问层与服务层：创建 UserDao 接口与 UserService 类

一、创建 MyBatis 数据访问接口（UserDao）

文件路径：com.example.dao.UserDao
功能说明：

• 通过 @Mapper 注解标识为 MyBatis 数据访问对象（DAO）
• 使用 @Select 注解直接编写 SQL 查询语句，实现从 user 表查询所有数据
• 返回值为 List<User>，通过 MyBatis 自动映射数据库结果到 User 实体类

代码实现：

package com.example.dao;

import com.example.entity.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

import java.util.List;

@Mapper // @Mapper 是 MyBatis 中的一个注解，用于标识一个接口是一个 MyBatis 的数据访问对象（DAO：Data Access Object数据访问对象）。它告诉 MyBatis 这个接口中的方法对应数据库中的某个操作，比如查询、插入、更新和删除等。
public interface UserDao {

    @Select("SELECT * FROM user") // @Select 是 MyBatis 中的一个注解，用于标识一个方法对应数据库中的某个查询操作。它告诉 MyBatis 这个方法对应数据库中的某个查询操作，比如 SELECT、UPDATE、DELETE 等。
    List<User> getUser();
}

二、创建服务层组件（UserService）

文件路径：com.example.service.UserService
功能说明：

• 通过 @Service 注解标识为 Spring 服务层组件，封装业务逻辑
• 使用 @Autowired 自动注入 UserDao 依赖，实现服务层对数据访问层的调用
• 定义 getUser() 方法，调用 UserDao 的查询功能并返回结果

代码实现：

package com.example.service;

import com.example.dao.UserDao;
import com.example.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service // @Service 是 Spring 框架中的一个注解，用于标识一个类是一个服务层组件。它通常用于在应用程序中定义业务逻辑层，用于处理业务逻辑和数据访问。
public class UserService {
    @Autowired // @Autowired 是 Spring 框架中的一个注解，用于自动注入对象。当一个类需要依赖另一个类时，可以使用 @Autowired 来将依赖对象自动注入到该类中。
    private UserDao userDao;

    public List<User> getUser() {
        return userDao.getUser();
    }
}

三、层间协作逻辑

Controller（控制层） → UserService（服务层） → UserDao（数据访问层） → MyBatis → MySQL 数据库

• 服务层作为业务逻辑入口，协调数据访问层与上层组件的交互
• 数据访问层通过 MyBatis 实现数据库操作的封装，解耦业务逻辑与底层 SQL

四、关键注解说明

注解	作用场景	核心功能
@Mapper	数据访问接口（DAO）	告诉 MyBatis 扫描该接口，生成 SQL 执行代理对象
@Select	数据库查询方法	直接在接口方法上声明 SQL 语句，避免编写 XML 配置文件
@Service	服务层类	标识为 Spring 管理的 Bean，纳入依赖注入容器
@Autowired	依赖注入	自动将 UserDao 实例注入到 UserService 中，实现层间调用

GG. 《构建 springboot 数据库 user 表（Navicat 可视化 + SQL 脚本实现）》

一、前期准备

确保已安装 Navicat Premium 工具，且本地 MySQL 服务（localhost:3306）正常运行，可通过 Navicat 测试连接（如最后一张图中“测试连接”功能）验证。

二、Navicat 可视化操作流程

1. 连接数据库

• 打开 Navicat，在“我的连接”找到 localhost_3306，右键选择打开连接（或双击），输入密码后建立与 MySQL 服务器的连接。

2. 新建数据库

• 连接成功后，右键 localhost_3306，选择新建数据库。
• 在弹窗中填写：
  • 数据库名称：springboot
  • 字符集：utf8mb4（支持 emoji 及特殊字符）
  • 排序规则：utf8mb4_unicode_ci（通用排序，适配多语言）
• 点击确定，完成数据库创建。

3. 创建数据表（可视化方式）

• 选中左侧 springboot 数据库，点击顶部表 → 新建表，进入设计界面。

• 依次添加字段：

  字段名	类型	长度	非空	主键	注释
  id	int	-	✔️	✔️	主键 ID
  name	varchar	255	❌	❌	用户名
  password	varchar	255	❌	❌	密码
  age	int	-	❌	❌	年龄
  sex	varchar	255	❌	❌	性别
  phone	varchar	255	❌	❌	手机号

• 点击保存，命名表为 user，完成表结构创建。

4. 插入测试数据（可视化 + SQL 两种方式）

方式 1：可视化插入

• 双击左侧 user 表，进入数据编辑页，点击添加数据，手动填入：

  1, 张三, 123456, 24, 男, 18888888888  
  2, 李四, 123456, 25, 女, 19900009999  
  

• 点击保存，完成数据插入。

方式 2：SQL 脚本插入

• 选中 springboot 数据库，点击顶部新建查询，打开 SQL 编辑器。

• 粘贴插入语句：

  INSERT INTO `user` VALUES (1, '张三', '123456', 24, '男 ', '18888888888');  
  INSERT INTO `user` VALUES (2, '李四', '123456', 25, '女', '19900009999');  
  

• 点击运行，执行脚本插入数据。

三、SQL 脚本完整说明（可直接复用）

以下是创建 user 表及插入数据的完整 SQL 脚本，可通过 Navicat“运行 SQL 文件”或直接在查询编辑器执行：

/*  
  功能：创建 springboot 数据库 user 表并插入测试数据  
  适用场景：项目初始化、数据迁移  
*/  

-- 设置字符集（避免中文乱码）  
SET NAMES utf8mb4;  
SET FOREIGN_KEY_CHECKS = 0; -- 关闭外键检查（建表时可临时关闭）  

-- 1. 删除旧表（若存在，避免重复创建报错）  
DROP TABLE IF EXISTS `user`;  

-- 2. 创建新表  
CREATE TABLE `user`  (  
  `id` int NOT NULL AUTO_INCREMENT COMMENT '主键ID',  
  `name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL COMMENT '用户名',  
  `password` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL COMMENT '密码',  
  `age` int NULL DEFAULT NULL COMMENT '年龄',  
  `sex` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL COMMENT '性别',  
  `phone` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL COMMENT '手机号',  
  PRIMARY KEY (`id`) USING BTREE -- 主键索引，加速查询  
) ENGINE = InnoDB AUTO_INCREMENT = 3 -- 自增起始值  
  CHARACTER SET = utf8mb4 -- 字符集  
  COLLATE = utf8mb4_unicode_ci -- 排序规则  
  COMMENT = '用户信息表' -- 表注释  
  ROW_FORMAT = Dynamic; -- 行存储格式（适配 InnoDB）  

-- 3. 插入测试数据  
INSERT INTO `user` VALUES (1, '张三', '123456', 24, '男 ', '18888888888');  
INSERT INTO `user` VALUES (2, '李四', '123456', 25, '女', '19900009999');  

-- 4. 恢复外键检查（建表完成后开启）  
SET FOREIGN_KEY_CHECKS = 1;  

四、流程验证

• 表结构验证：在 Navicat 中展开 springboot → 表 → user，查看字段、类型、注释是否与设计一致。
• 数据验证：双击 user 表，检查是否存在“张三、李四”两条测试数据。

五、常见问题处理

1. 连接失败：

   • 检查 MySQL 服务是否启动（命令行执行 services.msc，确认 MySQL 服务状态为 Running）。
   • 核对 Navicat 连接配置（主机 localhost、端口 3306、用户名 root、密码是否正确）。

2. 建表报错：

   • 若提示“表已存在”，先执行 DROP TABLE IF EXISTS user; 再重试。
   • 检查字段名、类型是否符合 MySQL 语法（如 varchar 需指定长度）。

3. 数据插入失败：

   • 确保字段顺序与 INSERT 语句值顺序一致（如 id 自增时，可省略 id 字段，让数据库自动赋值）。

通过以上流程，可完整构建 springboot 数据库的 user 表并插入测试数据，为 Java 项目（如 Spring Boot）提供基础数据支撑 。

HH. 《Spring Boot 数据库与 MyBatis 配置流程说明（application.properties/.yml双版本） 》

一、配置文件选择与核心作用

Spring Boot 支持 application.properties（键值对格式）和 application.yml（YAML 格式）两种配置文件，核心作用是：

1. 数据库连接配置：指定 MySQL 数据库地址、账号密码、驱动等信息。
2. MyBatis 集成配置：告诉 MyBatis 去哪里找 SQL 映射文件（.xml）和实体类。
3. 通用 Mapper 配置：启用 tk.mybatis 的通用 CRUD 功能，减少代码冗余。

二、application.properties 配置详解

# 应用名称
spring.application.name=springboot

# 数据库配置
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&useSSL=false&serverTimezone=GMT%2b8&allowPublicKeyRetrieval=true
spring.datasource.username=root
spring.datasource.password=123456

# MyBatis配置
mybatis.mapper-locations=classpath:mapper/*.xml
mybatis.type-aliases-package=com.example.springboot.entity
mybatis.configuration.map-underscore-to-camel-case=true
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

# 通用Mapper配置
mapper.mappers=tk.mybatis.mapper.common.Mapper
mapper.not-empty=true
mapper.identity=MYSQL

# 服务端口配置
server.port=8080

1. 数据库连接配置

# 数据库驱动（MySQL 8+ 推荐使用 com.mysql.cj.jdbc.Driver）
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
# 数据库 URL（包含字符集、时区等参数）
spring.datasource.url=jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&useSSL=false&serverTimezone=GMT%2b8&allowPublicKeyRetrieval=true
# 数据库账号密码（根据实际环境修改）
spring.datasource.username=root
spring.datasource.password=123456

参数说明：

• serverTimezone=GMT%2b8：指定时区为北京时间（GMT+8），避免跨时区时间误差。
• allowMultiQueries=true：允许一条 SQL 执行多个语句（如批量插入）。
• useSSL=false：禁用 SSL 连接（开发环境常用，生产环境需评估安全性）。

2. MyBatis 配置

# SQL 映射文件路径（classpath 表示项目资源目录）
mybatis.mapper-locations=classpath:mapper/*.xml
# 实体类包路径（自动扫描该包下的类，无需写全类名）
mybatis.type-aliases-package=com.example.springboot.entity
# MyBatis 全局配置
mybatis.configuration.map-underscore-to-camel-case=true  # 开启驼峰命名映射（数据库字段 user_name → 实体类 userName）
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl  # 打印 SQL 日志（开发环境使用）

3. 通用 Mapper（tk.mybatis）配置

# 通用 Mapper 接口路径（所有 DAO 接口需继承此接口）
mapper.mappers=tk.mybatis.mapper.common.Mapper
# 非空判断（插入/更新时自动过滤 null 值）
mapper.not-empty=true
# 主键自增策略（MySQL 适用）
mapper.identity=MYSQL

4. 服务端口配置

# 应用端口（默认 8080，若冲突可修改为其他端口，如 8090）
server.port=8080

三、application.yml 配置详解（等价于 properties）

spring:
  application:
    name: springboot  # 应用名称
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver  # 数据库驱动
    url: jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&useSSL=false&serverTimezone=GMT%2b8&allowPublicKeyRetrieval=true  # 数据库 URL
    username: root  # 数据库账号
    password: 123456  # 数据库密码
mybatis:
  mapper-locations: classpath:mapper/*.xml  # SQL 映射文件路径
  type-aliases-package: com.example.springboot.entity  # 实体类包路径
  configuration:
    map-underscore-to-camel-case: true  # 驼峰命名映射
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl  # SQL 日志打印
mapper:
  mappers:
    - tk.mybatis.mapper.common.Mapper  # 通用 Mapper 接口
  not-empty: true  # 非空判断
  identity: MYSQL  # 主键自增策略
server:
  port: 8080  # 服务端口

YAML 格式注意事项：

• 缩进严格：使用空格缩进（2-4 个空格），禁止使用 Tab 键。
• 冒号空格：键名后必须加空格再跟值（如 server: 后需有空格）。
• 注释符号：使用 # 注释，与 properties 一致。

四、配置生效流程与验证

1. 配置文件优先级

Spring Boot 会自动读取以下位置的配置文件（优先级由高到低）：

1. src/main/resources/application.properties/.yml（项目内默认配置）
2. 命令行参数（如 --server.port=8090）
3. 环境变量

2. 验证配置是否生效

方式 1：启动项目查看日志

• 若控制台打印 SQL 语句（如 ==> Preparing: SELECT * FROM user），说明 MyBatis 配置正确。
• 若出现 JDBC Connection 相关错误，检查数据库驱动、URL、账号密码是否正确。

方式 2：访问接口测试

• 假设已编写 Controller 接口（如 /users），访问 http://localhost:8080/users，若返回数据库中的用户数据（如张三、李四），则配置成功。

五、常见问题与解决方案

1. 数据库连接失败

• 现象：启动时报 java.sql.SQLException: No suitable driver found

  • 原因：未添加 MySQL 驱动依赖或驱动类名错误（MySQL 8+ 需用 com.mysql.cj.jdbc.Driver）。
  • 解决：在 pom.xml 中添加 mysql-connector-java 依赖，并检查驱动类名是否正确。

• 现象：Access denied for user 'root'@'localhost'

  • 原因：数据库账号或密码错误。
  • 解决：核对 application.properties/.yml 中的 username 和 password，确保与 MySQL 一致。

2. MyBatis 找不到 SQL 映射文件

• 现象：启动时报 Invalid bound statement (not found): com.example.dao.UserDao.getUser
  • 原因：mapper-locations 路径错误或 XML 文件未放在指定目录。
  • 解决：
    1. 确认 mapper 目录位于 src/main/resources 下。
    2. 检查 mapper-locations 路径是否正确（如 classpath:mapper/*.xml）。

3. 时区警告（Optional）

• 现象：控制台输出 The server time zone value '***' is unrecognized
  • 解决：在数据库 URL 中添加 serverTimezone=GMT%2b8（已包含在示例配置中）。

六、两种格式对比与选择建议

维度	application.properties	application.yml
语法	键值对（key=value），结构简单	YAML 格式，缩进层级分明，可读性更强
复杂度	适合简单配置或对 YAML 不熟悉的开发者	适合复杂层级配置（如嵌套对象）
兼容性	所有 Spring Boot 版本支持	需 Spring Boot 1.4+ 版本支持
推荐场景	快速原型开发、简单项目	复杂项目、需要层级化配置的场景

建议：新项目优先使用 application.yml，享受更清晰的层级结构；若团队对 YAML 不熟悉，可沿用 properties。

通过以上配置，Spring Boot 项目即可通过 MyBatis 和 tk.mybatis 实现对 MySQL 数据库的访问，后续可继续开发 Controller 层和前端界面，完成完整的 CRUD 功能。

修改application.properties文件或者application.yml文件
application.properties文件代码

# 应用名称
spring.application.name=springboot

# 数据库配
置
spr



ing.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&useSSL=false&serverTimezone=GMT%2b8&allowPublicKeyRetrieval=true
spring.datasource.username=root
spring.datasource.password=123456

# MyBatis配置
mybatis.mapper-locations=classpath:mapper/*.xml
mybatis.type-aliases-package=com.example.springboot.entity
mybatis.configuration.map-underscore-to-camel-case=true
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

# 通用Mapper配置
mapper.mappers=tk.mybatis.mapper.common.Mapper
mapper.not-empty=true
mapper.identity=MYSQL

# 服务端口配置
server.port=8080

或者application.yml文件代码

# 应用名称
spring:
  application:
    name: springboot
  # 数据库配置
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
#    url: jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
    url: jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&useSSL=false&serverTimezone=GMT%2b8&allowPublicKeyRetrieval=true
    username: root
    password: 123456

# MyBatis配置
mybatis:
  # mapper.xml文件位置
  mapper-locations: classpath:mapper/*.xml
  # 实体类包路径，根据实际项目结构调整
  type-aliases-package: com.example.springboot.entity
  configuration:
    # 开启驼峰命名转换
    map-underscore-to-camel-case: true
    # 打印SQL语句，开发环境可开启
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

# 通用Mapper配置
mapper:
  mappers:
    - tk.mybatis.mapper.common.Mapper
  not-empty: true
  identity: MYSQL

# 服务端口配置
server:
 port: 8080

II 《UserController 新增用户查询接口：实现数据库数据获取》

一、修改UserController代码

新增内容：
在 UserController 中新增以下代码，核心目标是通过 HTTP 接口从数据库查询用户数据并返回：

    @Autowired  // @Autowired 是 Spring 框架中的一个注解，用于自动注入依赖对象。它通常用于在 Spring 容器中获取已经存在的 bean，并将其注入到当前 bean 中。
    private UserService userService; // userService是UserService接口的实例对象，通过@Autowired注解注入

    @GetMapping("/users")
    public List<User> getAllUsers() {
        return userService.getUser();
    }

代码位置：
位于 com.example.controller.UserController 类中，与 @RestController 和 @RequestMapping("user") 注解同级，作为请求处理的入口。。

二、关键注解与代码逻辑解析

1. @Autowired 注解

• 作用：
  通过 Spring 依赖注入机制，将 UserService 实例（封装了数据库访问逻辑）注入控制器，使控制器能调用 UserService 中的方法操作数据库。
• 原理：
  Spring 通过依赖注入（DI）机制，在控制器实例化时将 UserService 的 Bean 注入到 userService 变量中，避免手动创建对象，实现层间解耦。
• 关键逻辑：
  UserService → UserDao → MyBatis → MySQL 数据库
  （服务层调用数据访问层，数据访问层通过 MyBatis 执行 SQL 查询数据库）
• 注意：
  • 需确保 UserService 类通过 @Service 注解声明为 Spring Bean，否则注入失败。
  • 若项目未扫描到 UserService，会抛出 NoSuchBeanDefinitionException 异常（需在启动类中通过 @ComponentScan 包含该类所在包）。

2. @GetMapping("/users") 注解

• 作用：
  映射 HTTP GET 请求到 /users 路径，结合类上的 @RequestMapping("user")，完整请求路径为：

  http://localhost:8080/user/users  。  
  

• 参数：

  • /users：资源路径，对应“查询用户列表”操作。
  • public List<User>：返回值为用户列表，Spring 自动将其序列化为 JSON 格式（如 [User1, User2]）。

3. 方法逻辑

public List<User> getAllUsers() {  
    return userService.getUser();  
}  

数据库查询触发流程：

1. 客户端请求：发送 GET 请求到 /user/users。
2. 控制器处理：调用 userService.getUser()，该方法内部执行以下步骤：
   • 服务层（UserService）：调用 UserDao 的 getUser() 方法。
   • 数据访问层（UserDao）：通过 MyBatis 执行 SQL SELECT * FROM user 查询数据库（代码见 UserDao 中的 @Select("SELECT * FROM user")）。
   • MyBatis 交互：将数据库返回的结果集（ResultSet）自动映射为 User 实体类对象，封装成 List<User>。
3. 结果返回：控制器将 List<User> 转换为 JSON 格式，返回给客户端，完成从数据库获取数据的全流程。

KK. 《用户数据查询功能验证过程》

一、启动 Spring Boot 项目

（一）操作步骤

在 IntelliJ IDEA 中打开 Spring Boot 项目，定位到带有 @SpringBootApplication 注解的项目启动类（通常为 SpringbootApplication.java ）。点击 IDEA 工具栏中的 Run 按钮（绿色三角形图标），或使用快捷键 Shift + F10 启动项目。

（二）预期结果

控制台输出项目启动日志，包含以下关键信息：

• 服务端口：如 Tomcat started on port(s): 8080 ，表明 Tomcat 服务器已启动并监听指定端口。
• MyBatis 日志（若配置了 log-impl ）：显示 ==> Preparing: SELECT * FROM user 等 SQL 执行相关记录，说明 MyBatis 配置生效，可操作数据库。
• 项目启动成功提示：无数据库连接失败、类找不到等异常报错，确保后续接口验证可正常进行。

二、通过浏览器验证接口功能

（一）操作步骤

打开浏览器（如 Chrome、Firefox 等），在地址栏输入接口 URL：

http://localhost:8080/user/users  

说明：

• localhost：代表本地服务器，若项目部署在远程服务器，需替换为对应服务器 IP。
• 8080：项目端口，需与 application.properties 或 application.yml 中配置的 server.port 保持一致。
• user/users：接口路径，由 UserController 类上的 @RequestMapping("user") 注解和方法上的 @GetMapping("/users") 注解组合而成。

（二）预期结果

• 响应数据：浏览器页面显示 JSON 格式的用户数据，内容与数据库 user 表中的记录一致。示例响应如下：

[  
  {  
    "id": 1,  
    "name": "张三",  
    "password": "123456",  
    "age": 24,  
    "sex": "男 ",  
    "phone": "18888888888"  
  },  
  {  
    "id": 2,  
    "name": "李四",  
    "password": "123456",  
    "age": 25,  
    "sex": "女",  
    "phone": "19900009999"  
  }  
]  

• 响应状态码：为 200 OK ，可通过浏览器开发者工具查看。按 F12 打开控制台，切换到 Network 标签页，刷新页面后，在请求列表中找到 http://localhost:8080/user/users 对应的请求，其“状态”列会显示 200 ，代表请求成功。
  

三、通过 IDEA 内置 HTTP 客户端验证（generated-requests.http ）

（一）功能背景

IDEA 提供内置 HTTP 客户端工具，可直接在 IDE 内发送 HTTP 请求、查看响应，无需依赖外部工具（如浏览器、Postman ）。“在 HTTP 客户端中打开” 功能会自动生成对应接口的请求模板到 generated-requests.http 文件，简化请求编写流程。

（二）操作与验证流程

1. 触发 “在 HTTP 客户端中打开”
   在 UserController 的 @GetMapping 注解方法旁（如 getAllUsers 方法 ），点击出现的 “在 HTTP 客户端中打开” 提示。IDEA 会自动创建/打开 generated-requests.http 文件，并生成对应接口的请求模板，格式如下：
   

GET http://localhost:8080/user/users  

作用：快速生成请求 URL，避免手动输入，降低拼写错误概率。

2. 发送请求与查看响应
   打开 generated-requests.http 文件，点击请求模板左侧的绿色运行按钮（三角形图标 ）发送 GET 请求。发送后，IDEA 底部会弹出 “服务” 面板（可通过 Alt + 8 唤起 ），展开 “HTTP 请求” 节点：
   

• 请求记录：能看到 generated-requests 的请求记录，状态显示为 200 ，代表请求成功。
• 详细响应：点击该请求记录，右侧会展示：
  • 响应体：直接显示 JSON 格式的用户数据，与浏览器访问结果一致，包含数据库中张三、李四等用户信息列表。
  • 响应头：可查看 Content-Type（通常为 application/json ，说明返回 JSON 数据 ）、Status Code（状态码 200 ）等信息，确认接口通信正常。
    
    

3. 与其他验证方式对比优势

• 无需切换工具：在 IDE 内即可完成请求发送、响应查看，无需在浏览器、Postman 等工具间来回切换，提升开发效率。
• 自动关联代码：通过代码旁提示生成请求，请求 URL 与代码路由实时同步。若修改代码中的 @RequestMapping 等注解，再次触发 “在 HTTP 客户端中打开” 可更新请求模板，减少手动维护请求 URL 的成本。
• 集成日志与调试：结合 IDEA 控制台日志（如 MyBatis 的 SQL 执行日志 ），可在一个界面同时分析请求流程、数据库操作、响应结果，便于定位问题（如 SQL 执行异常时，能快速关联请求报错与日志信息 ）。

四、验证关键点与异常处理

（一）关键点验证

1. 数据库连通性：接口能返回数据，说明项目已成功连接到 MySQL 数据库，并执行了 SELECT * FROM user 查询，数据库访问链路通畅。
2. MyBatis 映射正确性：数据库字段（如 id、name ）需正确映射到 User 实体类属性，无字段缺失或类型错误（如年龄 age 应显示为数字，而非字符串 ），保证数据格式符合预期。
3. 接口路径正确性：路径 user/users 需正确匹配控制器中的路由配置，若访问时返回 404 Not Found ，则说明路径配置可能有误，需确认控制器类的 @RequestMapping("user") 注解是否正确。

（二）异常场景处理

1. 端口冲突：若启动项目时提示 Port 8080 is already in use ，需修改 application.properties 或 application.yml 中的 server.port 为其他端口（如 8090 ），重新启动项目。
2. 数据库连接失败
   • 控制台报错 Access denied for user 'root'@'localhost' ：检查 application.properties 或 application.yml 中数据库账号密码配置（spring.datasource.username/password ），确保与实际数据库账号密码一致。
   • 报错 No suitable driver found ：检查 pom.xml 文件，确认已添加 MySQL 驱动依赖（mysql-connector-java ），保证项目能连接数据库。
3. 接口路径错误：若输入 http://localhost:8080/users（缺少 user 前缀 ）返回 404 ，需确认控制器类的 @RequestMapping("user") 注解配置是否正确，保证接口路径组合无误。
4. 请求无响应/报错（IDE 内置 HTTP 客户端）
   • 检查项目是否启动：确认 Spring Boot 应用已通过 Run 按钮启动，且控制台无启动报错。若项目未启动，请求会因连接不到服务端而失败。
   • 核对请求 URL：确认 generated-requests.http 中的 URL 与实际服务端口、路径一致。若修改过 server.port 或控制器注解路径，需重新触发 “在 HTTP 客户端中打开” 更新模板。
5. 响应乱码或格式异常
   • 检查编码配置：确保 application.properties/application.yml 中配置了字符集（如 spring.http.encoding.charset = UTF-8 ），且数据库连接 URL 中设置了 useUnicode = true&characterEncoding = utf-8 ，避免因编码不一致导致响应乱码。
   • 确认实体类映射：若响应 JSON 字段缺失或类型错误，检查 User 实体类字段是否与数据库表字段正确映射（如采用驼峰命名、通过 @Column 注解配置 ），确保 MyBatis 能正确转换结果集。

五、验证工具扩展（非浏览器、非 IDE 内置方式 ）

（一）Postman 验证（推荐）

1. 操作步骤：打开 Postman，选择 GET 请求，输入 URL http://localhost:8080/user/users ，点击 Send 发送请求。
2. 优势：清晰显示响应状态码、响应头和响应体；支持保存请求历史，方便后续重复测试与接口管理。

（二）curl 命令验证（命令行）

1. 操作步骤：在终端输入以下命令：

curl http://localhost:8080/user/users  

2. 预期结果：终端输出与浏览器一致的 JSON 数据，可快速在命令行环境验证接口功能。

六、总结

通过以上多种方式（浏览器、IDEA 内置 HTTP 客户端、Postman、curl ），从不同维度验证了 UserController 中 /user/users 接口的功能正确性：

1. 项目启动正常：Spring Boot 应用成功启动，Tomcat 服务器监听指定端口，各依赖组件（如 MyBatis ）配置生效。
2. 接口响应正确：无论是浏览器、IDE 内置工具还是外部工具（Postman、curl ），都能正确获取数据库中的用户数据，返回 JSON 格式内容，且响应状态码为 200 ，表明接口通信与数据查询正常。
3. 依赖链路完整：从控制器 → 服务层 → 数据访问层 → 数据库的全流程无异常，各层通过依赖注入、注解配置等方式协作顺畅，保障了数据库查询功能的可用性，为后续用户新增、修改、删除等接口开发奠定可靠基础。

代码