Java+MySQL学生信息管理系统：三层架构与JDBC实战详解

简介：本资源是一套基于Java SE开发的学生信息管理系统（V3.0），面向高校计算机专业初学者及课程设计实践者，解决单用户环境下学生数据的结构化管理问题。系统采用控制台交互方式，依托MySQL实现数据持久化，涵盖管理员登录、学生信息增删改查等核心功能，适合作为Java基础语法、JDBC编程与数据库应用的综合实训参考。压缩包共33个文件，含6个核心Java源码与对应class字节码、3个SQL建库建表脚本、2个MySQL驱动jar包、1个演示视频mp4、1份技术说明书docx及多张运行截图png，整体大小37.67MB，目录结构清晰，便于快速定位源码、数据库与执行入口。已有65人学习下载，配套演示视频完整呈现登录、新增、查询、修改、删除等全流程操作，运行必读txt提供环境配置与启动指引，显著降低上手门槛。

1. 项目概述与核心价值

最近在整理过去的项目代码，翻出来一个大学时期做的“学生信息管理系统”。别看它只是个基于Java控制台和MySQL的“小玩意儿”，但麻雀虽小，五脏俱全。对于刚学完Java基础和数据库，想找个项目练手、巩固知识体系，或者准备面试需要项目经验的同学来说，这个项目是个非常扎实的起点。它避开了复杂的前端框架和花哨的界面，让你能集中火力攻克核心业务逻辑、数据库操作和面向对象设计。我当年就是靠着它，把JDBC、DAO模式、集合操作这些知识点从书本上的概念，变成了手指敲出来的肌肉记忆。今天，我就把这个项目的完整设计思路、踩过的坑，以及如何让它从“能跑”到“跑得稳”的经验，掰开揉碎了分享给你。

这个系统本质上是一个针对学生信息的CRUD（增删改查）管理应用。用户通过控制台输入指令，系统完成对学生基本信息的录入、查询、修改、删除，并将数据持久化到MySQL数据库中。它解决的核心问题是：如何将面向对象的编程思想与关系型数据库操作有机结合，构建一个结构清晰、易于维护的应用程序。适合的读者包括：正在学习Java SE和MySQL的在校学生、需要基础项目填充简历的求职者，以及希望理解经典三层架构（表现层、业务逻辑层、数据访问层）入门实践的任何开发者。

2. 项目整体设计与架构拆解

2.1 技术选型背后的逻辑

为什么是Java控制台 + MySQL？这个组合在今天看来似乎有些“复古”，但其教学和练手价值极高。

首先，Java控制台迫使你专注于业务逻辑本身。没有前端页面的干扰，所有交互都通过System.in和System.out完成，这要求你必须设计清晰的用户操作流程和健壮的输入验证。比如，如何提示用户输入？如何解析用户输入的字符串？输入错误了怎么友好地提示并重新输入？这些问题在Web开发中被框架部分屏蔽了，但在控制台程序中必须亲手解决，能极大地锻炼你的流程控制能力和异常处理思维。

其次，MySQL作为最流行的开源关系型数据库之一，是学习SQL和数据库操作的绝佳选择。通过这个项目，你不仅要学会写INSERT、SELECT、UPDATE、DELETE这些基本语句，更要理解连接数据库的步骤（加载驱动、获取连接）、如何防止SQL注入（使用PreparedStatement）、以及事务的基本概念。这些是后端开发的基石，无论以后用Spring Boot还是其他框架，原理都是相通的。

注意：很多新手会直接用Statement执行拼接的SQL字符串，这存在严重的SQL注入风险。从项目一开始就要养成使用PreparedStatement的好习惯，这是区分“玩具代码”和“可上线代码”的第一个关键点。

2.2 系统核心架构模式：经典三层架构

为了让代码结构清晰、职责分离，我们采用经典的三层架构。这听起来高大上，其实很简单，就是把不同功能的代码放到不同的“包”（package）里。

1. 表现层 (Presentation Layer)

• 职责：负责与用户交互。接收用户的输入，展示处理结果。
• 在本项目中的体现：就是一个或多个包含main方法的类，里面充满了Scanner和System.out.println。它调用业务逻辑层提供的方法，并把业务层返回的数据（比如一个Student对象的列表）格式化成友好的字符串输出到控制台。
• 设计要点：这一层应该尽可能“薄”，它只关心“输入什么”和“输出什么”，不关心数据从哪里来、怎么处理。所有业务判断和数据库操作都应该交给下层。

2. 业务逻辑层 (Business Logic Layer)

• 职责：承上启下。处理具体的业务规则和逻辑。
• 在本项目中的体现：例如，在添加学生之前，业务层需要检查学号是否已存在；在删除学生时，可能需要判断该学生是否有关联的成绩记录（如果系统后续扩展了成绩管理模块）。这一层的方法接收表现层传来的参数，组织调用一个或多个数据访问层的方法，完成一个完整的业务操作。
• 设计要点：这里是业务规则集中的地方。比如，“学号必须唯一”这条规则，应该在业务层的addStudent方法中，先调用数据访问层的findByStudentId方法查询，如果已存在则抛出异常或返回错误信息给表现层。

3. 数据访问层 (Data Access Layer, DAL)

• 职责：专门负责与数据库打交道。执行SQL语句，把数据库查询结果封装成Java对象，或者把Java对象的数据持久化到数据库。
• 在本项目中的体现：通常包含DAO（Data Access Object）接口及其实现类。例如StudentDao接口，定义了save,delete,findById,findAll等方法。实现类StudentDaoImpl里面就是具体的JDBC代码。
• 设计要点：这一层要高度抽象，只关注数据的存取。它不应该包含任何业务逻辑（比如“学号必须唯一”的判断不应该写在这里）。通常，一个DAO类对应数据库中的一张表。

为什么这么分层？最大的好处是解耦和可维护性。假设明天我们想把控制台界面换成Swing图形界面，或者甚至改成Web服务，我们只需要重写表现层，业务逻辑层和数据访问层的代码几乎可以原封不动地复用。同样，如果要把MySQL数据库换成PostgreSQL，也只需要修改数据访问层的具体实现（主要是SQL语句和连接方式），上层业务不受影响。

2.3 数据库表结构设计

学生信息管理，核心就是一张student表。设计表结构是项目的基石，设计得好，后续编程事半功倍。

CREATE TABLE `student` ( `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键ID', `student_id` varchar(20) NOT NULL COMMENT '学号', `name` varchar(50) NOT NULL COMMENT '姓名', `gender` char(1) DEFAULT NULL COMMENT '性别（M:男, F:女）', `age` int(11) DEFAULT NULL COMMENT '年龄', `major` varchar(100) DEFAULT NULL COMMENT '专业', `phone` varchar(20) DEFAULT NULL COMMENT '电话', `email` varchar(100) DEFAULT NULL COMMENT '邮箱', `enrollment_date` date DEFAULT NULL COMMENT '入学日期', PRIMARY KEY (`id`), UNIQUE KEY `uk_student_id` (`student_id`), KEY `idx_name` (`name`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='学生信息表';

字段设计解析与避坑指南：

1. 主键id：使用自增整数AUTO_INCREMENT作为代理主键。为什么不直接用student_id（学号）当主键？因为学号虽然是业务上的唯一标识，但它属于业务数据，有可能变更（虽然概率小）。使用与业务无关的自增ID作为主键，能使外键关联更稳定，也是行业内的常见实践。
2. 唯一键uk_student_id：在student_id上建立唯一约束，从数据库层面保证了学号的唯一性，这是业务规则的最终防线。即使业务层代码有漏洞漏掉了校验，数据库也会阻止重复数据的插入。
3. 索引idx_name：在name字段上建立了普通索引。因为按姓名查询是一个高频操作。虽然本项目数据量小，索引效果不明显，但养成在常用查询条件上建索引的习惯很重要。
4. 字符集utf8mb4：一定要用utf8mb4，而不是老的utf8。utf8mb4才是真正的UTF-8编码，支持存储emoji表情等所有Unicode字符，避免未来出现乱码问题。
5. 字段类型选择：
   • gender用char(1)，存储‘M’或‘F’，比用varchar更节省空间。
   • phone和email虽然看起来是数字或字符串，但因其格式特殊且不需要做数学运算，一律用varchar。
   • enrollment_date用date类型，专门存储日期，比用varchar或datetime更规范，便于进行日期范围的查询和计算。

3. 核心模块实现与代码精讲

3.1 实体类（Entity）设计：Student.java

实体类是数据库表在Java世界中的映射，一个对象对应表里的一行记录。

package com.example.sms.entity; import java.time.LocalDate; public class Student { private Integer id; // 对应表的主键id private String studentId; // 学号 private String name; private String gender; // “M” 或 “F” private Integer age; private String major; private String phone; private String email; private LocalDate enrollmentDate; // 使用Java 8的日期API // 无参构造器（ORM框架通常需要） public Student() { } // 全参构造器（方便初始化） public Student(String studentId, String name, String gender, Integer age, String major, String phone, String email, LocalDate enrollmentDate) { this.studentId = studentId; this.name = name; this.gender = gender; this.age = age; this.major = major; this.phone = phone; this.email = email; this.enrollmentDate = enrollmentDate; } // Getter和Setter方法（此处省略，实际需完整生成） // ... // 重写toString方法，方便控制台输出 @Override public String toString() { return String.format("学号：%s, 姓名：%s, 性别：%s, 年龄：%d, 专业：%s, 电话：%s, 邮箱：%s, 入学日期：%s", studentId, name, gender, age, major, phone, email, enrollmentDate); } }

关键点与心得：

• 使用LocalDate而不是java.util.Date或java.sql.Date。LocalDate是Java 8引入的日期时间API的一部分，它不可变且线程安全，API设计更现代、更易用。与数据库交互时，可以通过PreparedStatement的setObject和ResultSet的getObject来直接转换。
• toString()方法的重写非常有用。在调试和控制台输出时，直接打印对象就能看到清晰的信息，无需手动拼接属性。

3.2 数据访问层（DAO）实现：JDBC工具类与StudentDaoImpl

这是项目中最核心、最容易出问题的部分。我们分两步走：先封装一个JDBC工具类，再实现DAO。

3.2.1 JDBC工具类 (DBUtil.java)为了避免在每个DAO方法中都重复编写加载驱动、获取连接、关闭资源的代码，我们将其封装起来。

package com.example.sms.util; import java.io.InputStream; import java.sql.*; import java.util.Properties; public class DBUtil { private static String url; private static String user; private static String password; private static String driver; // 静态代码块，在类加载时读取数据库配置 static { try { // 1. 读取配置文件（db.properties） InputStream is = DBUtil.class.getClassLoader().getResourceAsStream("db.properties"); Properties props = new Properties(); props.load(is); // 2. 获取配置值 url = props.getProperty("jdbc.url"); user = props.getProperty("jdbc.user"); password = props.getProperty("jdbc.password"); driver = props.getProperty("jdbc.driver"); // 3. 注册驱动 (对于MySQL Connector/J 8.0+，这步可以省略，但写上更稳妥) Class.forName(driver); } catch (Exception e) { e.printStackTrace(); throw new RuntimeException("初始化数据库连接池失败！", e); } } // 获取数据库连接 public static Connection getConnection() throws SQLException { return DriverManager.getConnection(url, user, password); } // 关闭资源（重载方法，应对不同场景） public static void close(Connection conn, Statement stmt, ResultSet rs) { close(rs); close(stmt); close(conn); } public static void close(Connection conn, Statement stmt) { close(stmt); close(conn); } // 关闭单个资源 private static void close(AutoCloseable ac) { if (ac != null) { try { ac.close(); } catch (Exception e) { e.printStackTrace(); // 生产环境应记录日志，而非打印 } } } }

对应的db.properties配置文件：

jdbc.driver=com.mysql.cj.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/student_db?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai jdbc.user=root jdbc.password=your_password

重要提示：jdbc.url中的参数至关重要。

• useUnicode=true&characterEncoding=utf8：确保传输过程中使用正确的编码，防止中文乱码。
• useSSL=false：本地开发环境如果未配置SSL，需要关闭，否则会连接失败。生产环境应设置为true并提供证书。
• serverTimezone=Asia/Shanghai：指定服务器时区，避免因时区不一致导致的日期时间错误。这是Java连接MySQL 8.0+最常见的问题之一。

3.2.2 DAO接口与实现 (StudentDao & StudentDaoImpl)先定义接口，约定好数据访问有哪些操作。

package com.example.sms.dao; import com.example.sms.entity.Student; import java.util.List; public interface StudentDao { // 新增学生 int save(Student student); // 根据ID删除学生 int deleteById(Integer id); // 更新学生信息 int update(Student student); // 根据ID查询学生 Student findById(Integer id); // 根据学号查询学生（用于唯一性校验） Student findByStudentId(String studentId); // 查询所有学生 List<Student> findAll(); // 根据姓名模糊查询 List<Student> findByName(String name); }

然后是具体的实现类，这里展示最复杂的save和findAll方法。

package com.example.sms.dao.impl; import com.example.sms.dao.StudentDao; import com.example.sms.entity.Student; import com.example.sms.util.DBUtil; import java.sql.*; import java.util.ArrayList; import java.util.List; public class StudentDaoImpl implements StudentDao { @Override public int save(Student student) { Connection conn = null; PreparedStatement pstmt = null; ResultSet generatedKeys = null; // 用于获取自增主键 try { conn = DBUtil.getConnection(); // SQL语句，使用?作为占位符 String sql = "INSERT INTO student(student_id, name, gender, age, major, phone, email, enrollment_date) VALUES(?,?,?,?,?,?,?,?)"; // 创建PreparedStatement，并告知需要返回生成的主键 pstmt = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS); // 设置参数，注意下标从1开始 pstmt.setString(1, student.getStudentId()); pstmt.setString(2, student.getName()); pstmt.setString(3, student.getGender()); pstmt.setInt(4, student.getAge()); pstmt.setString(5, student.getMajor()); pstmt.setString(6, student.getPhone()); pstmt.setString(7, student.getEmail()); // 处理LocalDate类型 pstmt.setObject(8, student.getEnrollmentDate()); // 执行更新 int affectedRows = pstmt.executeUpdate(); // 获取数据库生成的主键ID，并设置回Student对象 if (affectedRows > 0) { generatedKeys = pstmt.getGeneratedKeys(); if (generatedKeys.next()) { int generatedId = generatedKeys.getInt(1); student.setId(generatedId); // 将ID回填到对象中 } } return affectedRows; } catch (SQLException e) { e.printStackTrace(); // 在实际项目中，应该抛出自定义异常，而不是打印 return 0; } finally { // 确保资源被关闭，避免内存泄漏 DBUtil.close(conn, pstmt, generatedKeys); } } @Override public List<Student> findAll() { List<Student> studentList = new ArrayList<>(); Connection conn = null; PreparedStatement pstmt = null; ResultSet rs = null; try { conn = DBUtil.getConnection(); String sql = "SELECT id, student_id, name, gender, age, major, phone, email, enrollment_date FROM student"; pstmt = conn.prepareStatement(sql); rs = pstmt.executeQuery(); // 遍历结果集，将每一行数据封装成一个Student对象 while (rs.next()) { Student student = new Student(); student.setId(rs.getInt("id")); student.setStudentId(rs.getString("student_id")); student.setName(rs.getString("name")); student.setGender(rs.getString("gender")); student.setAge(rs.getInt("age")); student.setMajor(rs.getString("major")); student.setPhone(rs.getString("phone")); student.setEmail(rs.getString("email")); // 从结果集中获取SQL Date，并转换为LocalDate Date sqlDate = rs.getDate("enrollment_date"); if (sqlDate != null) { student.setEnrollmentDate(sqlDate.toLocalDate()); } studentList.add(student); } } catch (SQLException e) { e.printStackTrace(); } finally { DBUtil.close(conn, pstmt, rs); } return studentList; } // ... 其他方法（deleteById, update, findById等）实现逻辑类似 }

DAO层编码核心经验：

1. 必须使用PreparedStatement：这是防止SQL注入攻击的唯一正确方式。不要用字符串拼接SQL。
2. 资源关闭必须放在finally块中：确保无论是否发生异常，数据库连接、语句、结果集都会被关闭，防止资源泄漏。我们的DBUtil.close方法已经处理了null检查和异常捕获。
3. 处理自增主键：插入数据后，通过Statement.RETURN_GENERATED_KEYS和pstmt.getGeneratedKeys()获取数据库生成的主键值，并回填到实体对象中。这样，在插入后你就能立刻知道这条记录的ID。
4. 结果集到对象的映射：findAll方法中，手动从ResultSet中取数据并set到对象属性的过程，就是最简单的ORM（对象关系映射）。这个过程稍显繁琐，但能让你深刻理解框架（如MyBatis）背后在做什么。

3.3 业务逻辑层（Service）实现

业务层是连接表现层和数据访问层的桥梁，负责处理业务规则。

package com.example.sms.service; import com.example.sms.dao.StudentDao; import com.example.sms.dao.impl.StudentDaoImpl; import com.example.sms.entity.Student; import java.util.List; public class StudentService { private StudentDao studentDao = new StudentDaoImpl(); // 添加学生（包含业务规则：学号不能重复） public boolean addStudent(Student student) { // 1. 业务校验：学号唯一性 Student existingStudent = studentDao.findByStudentId(student.getStudentId()); if (existingStudent != null) { System.out.println("添加失败：学号 " + student.getStudentId() + " 已存在！"); return false; } // 2. 其他业务校验（如年龄范围、邮箱格式等，此处省略） // if (student.getAge() < 0 || student.getAge() > 150) { ... } // 3. 调用DAO层保存数据 int result = studentDao.save(student); return result > 0; } // 删除学生（可能包含关联性检查，如该学生是否有成绩记录） public boolean deleteStudent(Integer id) { // 在实际系统中，删除前可能需要检查外键约束 // 例如：先查询该学生是否在`score`表中有记录，如果有，则不允许删除或级联删除 // 本项目暂不考虑关联表，直接删除 int result = studentDao.deleteById(id); if (result > 0) { System.out.println("删除成功！"); return true; } else { System.out.println("删除失败，未找到ID为 " + id + " 的学生。"); return false; } } // 查询所有学生 public List<Student> getAllStudents() { return studentDao.findAll(); } // 根据姓名模糊查询 public List<Student> searchStudentsByName(String nameKeyword) { if (nameKeyword == null || nameKeyword.trim().isEmpty()) { // 如果查询条件为空，可以返回所有，也可以返回空列表，根据业务定 return studentDao.findAll(); } return studentDao.findByName("%" + nameKeyword.trim() + "%"); // 添加模糊查询通配符 } // ... 其他业务方法（update, findById等） }

业务层设计心得：

• 校验前置：所有业务规则的校验（如唯一性、有效性）都应该放在Service层，DAO层只负责最纯粹的数据存取。这符合“单一职责原则”。
• 事务的雏形：想象一下，如果一个业务操作需要连续调用两次studentDao.save()，并且要求它们要么都成功，要么都失败（原子性），那么就需要在Service层引入数据库事务管理。可以通过Connection的setAutoCommit(false)、commit()和rollback()来实现。这是业务层一个非常重要的扩展点。
• 异常处理：目前的代码只是简单打印和返回boolean。在更正式的项目中，应该定义自定义的业务异常（如StudentDuplicateException），并在Service层抛出，由表现层统一捕获并处理，这样逻辑更清晰。

3.4 表现层（控制台菜单）实现

表现层是用户入口，需要设计清晰的菜单和友好的交互。

package com.example.sms.view; import com.example.sms.entity.Student; import com.example.sms.service.StudentService; import java.time.LocalDate; import java.time.format.DateTimeFormatter; import java.time.format.DateTimeParseException; import java.util.List; import java.util.Scanner; public class ConsoleUI { private StudentService studentService = new StudentService(); private Scanner scanner = new Scanner(System.in); private DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd"); public void start() { while (true) { showMainMenu(); String choice = scanner.nextLine(); switch (choice) { case "1": addStudent(); break; case "2": deleteStudent(); break; case "3": updateStudent(); break; case "4": queryStudentById(); break; case "5": queryAllStudents(); break; case "6": searchStudentsByName(); break; case "0": System.out.println("感谢使用学生信息管理系统，再见！"); scanner.close(); return; default: System.out.println("输入有误，请重新选择！"); } System.out.println("\n按回车键继续..."); scanner.nextLine(); // 暂停一下，让用户看清结果 } } private void showMainMenu() { System.out.println("\n========== 学生信息管理系统 =========="); System.out.println("1. 添加学生"); System.out.println("2. 删除学生"); System.out.println("3. 修改学生信息"); System.out.println("4. 按ID查询学生"); System.out.println("5. 查询所有学生"); System.out.println("6. 按姓名模糊查询"); System.out.println("0. 退出系统"); System.out.println("====================================="); System.out.print("请选择操作："); } private void addStudent() { System.out.println("\n--- 添加学生 ---"); try { Student student = new Student(); System.out.print("请输入学号："); student.setStudentId(scanner.nextLine().trim()); System.out.print("请输入姓名："); student.setName(scanner.nextLine().trim()); System.out.print("请输入性别(M/F)："); student.setGender(scanner.nextLine().trim().toUpperCase()); System.out.print("请输入年龄："); String ageInput = scanner.nextLine().trim(); student.setAge(ageInput.isEmpty() ? null : Integer.parseInt(ageInput)); // 处理空输入 System.out.print("请输入专业："); student.setMajor(scanner.nextLine().trim()); System.out.print("请输入电话："); student.setPhone(scanner.nextLine().trim()); System.out.print("请输入邮箱："); student.setEmail(scanner.nextLine().trim()); System.out.print("请输入入学日期(格式：yyyy-MM-dd，可为空)："); String dateInput = scanner.nextLine().trim(); if (!dateInput.isEmpty()) { student.setEnrollmentDate(LocalDate.parse(dateInput, dateFormatter)); } boolean success = studentService.addStudent(student); if (success) { System.out.println("学生信息添加成功！"); } } catch (NumberFormatException e) { System.out.println("年龄输入格式错误，请输入数字。"); } catch (DateTimeParseException e) { System.out.println("日期格式错误，请按yyyy-MM-dd格式输入。"); } catch (Exception e) { System.out.println("添加过程中发生错误：" + e.getMessage()); } } private void queryAllStudents() { System.out.println("\n--- 所有学生列表 ---"); List<Student> students = studentService.getAllStudents(); if (students == null || students.isEmpty()) { System.out.println("当前没有学生信息。"); } else { // 简单表格化输出 System.out.println("ID\t学号\t\t姓名\t性别\t年龄\t专业"); System.out.println("------------------------------------------------------------"); for (Student s : students) { System.out.printf("%d\t%s\t%s\t%s\t%d\t%s%n", s.getId(), s.getStudentId(), s.getName(), s.getGender(), s.getAge(), s.getMajor()); } System.out.println("------------------------------------------------------------"); System.out.println("共计 " + students.size() + " 条记录。"); } } // ... 其他方法（deleteStudent, updateStudent等）实现逻辑类似，都需要细致的输入处理和校验 }

控制台交互设计技巧：

1. 输入校验与容错：这是控制台程序体验的关键。对数字输入（如年龄）要用try-catch捕获NumberFormatException；对日期输入要指定格式并捕获DateTimeParseException；对可能为空的字段要妥善处理（如使用三元运算符）。
2. 友好的输出格式：使用printf或String.format进行格式化输出，让数据对齐，更易阅读。可以考虑将输出逻辑封装成独立的方法，甚至支持简单的分页。
3. 循环与退出机制：主菜单使用while(true)循环，直到用户选择退出。确保在退出前关闭Scanner等资源。
4. 操作反馈：每一个操作（增删改查）后，都要给用户明确的成功或失败提示，并说明原因（如“删除失败，未找到该学生”）。

4. 项目运行、调试与进阶思考

4.1 环境准备与项目启动

要让这个项目跑起来，你需要完成以下几步：

1. 安装Java开发环境：确保已安装JDK 8或更高版本（推荐JDK 11或17 LTS版本），并配置好JAVA_HOME和PATH环境变量。在命令行输入java -version和javac -version验证。
2. 安装与配置MySQL：
   • 从MySQL官网下载社区版安装包并安装。
   • 记住安装时设置的root用户密码。
   • 启动MySQL服务。
   • 使用命令行或MySQL Workbench等工具，登录后执行前面提供的建表SQL语句，创建数据库student_db和student表。
3. 准备项目依赖：你需要MySQL的JDBC驱动jar包（如mysql-connector-java-8.0.33.jar）。如果你使用IDE（如IntelliJ IDEA或Eclipse）：
   • 创建一个新的Java项目。
   • 将上面编写的.java文件放到对应的包路径下。
   • 将下载的JDBC驱动jar包添加到项目的ClassPath（构建路径）中。在IDEA中，通常是将jar包复制到项目根目录下的lib文件夹，然后右键选择“Add as Library”。
4. 修改配置文件：在项目的src目录（或资源目录）下创建db.properties文件，根据你的MySQL安装情况，修改jdbc.url中的数据库地址、端口和数据库名，以及jdbc.password。
5. 运行：找到ConsoleUI类，运行其main方法（或直接运行start()方法）。

4.2 常见问题排查与解决实录

在开发和运行过程中，你几乎一定会遇到下面这些问题：

问题现象	可能原因	解决方案
ClassNotFoundException: com.mysql.cj.jdbc.Driver	1. JDBC驱动jar包未正确添加到类路径。 2.db.properties中jdbc.driver配置错误。	1. 检查IDE中项目依赖，确认驱动jar包已添加。 2. 检查驱动类名，MySQL 8.0+通常是com.mysql.cj.jdbc.Driver。
Communications link failure或连接被拒绝	1. MySQL服务未启动。 2.jdbc.url中的IP、端口或数据库名错误。 3. 防火墙阻止了连接。	1. 在服务管理器中启动MySQL服务。 2. 检查jdbc.url，确保数据库student_db已创建。 3. 检查MySQL是否允许远程连接（本地连接通常没问题）。
中文乱码	1. 数据库、表字符集不是utf8mb4。 2. JDBC连接字符串未指定字符集。 3. 程序控制台输出编码与系统不匹配。	1. 确认建表语句使用了CHARSET=utf8mb4。 2. 确保jdbc.url中包含characterEncoding=utf8。 3. 对于控制台，可尝试在启动JVM时加参数-Dfile.encoding=UTF-8。
java.sql.SQLException: The server time zone value ...	MySQL服务器时区未设置或与Java应用时区不一致。	在jdbc.url末尾添加&serverTimezone=Asia/Shanghai（或你所在的时区）。
插入数据失败，但程序未报错	1. 表字段有非空约束，但插入时传了null。 2. 数据长度超出字段定义。 3. 唯一约束冲突（如重复学号）。	1. 检查INSERT语句的字段和值是否一一对应，非空字段必须赋值。 2. 检查业务层日志或PreparedStatement.executeUpdate()的返回值，它返回受影响的行数，为0则表示插入失败。
查询结果始终为空	1. SQL语句有误，特别是模糊查询时通配符%的位置。 2. 程序中的查询条件与数据库数据不匹配（如大小写、空格）。 3. 数据库连接到了错误的库或表。	1. 将DAO层中拼接好的SQL（带参数值）打印出来，复制到数据库客户端直接执行，看是否有结果。 2. 检查输入条件，使用trim()去除空格。

一个关键的调试技巧：打印真实SQL。在DAO层的catch块中或调试时，将PreparedStatement最终要执行的SQL打印出来，对于排查问题有奇效。虽然不能直接拿到拼接后的SQL，但可以打印出带?的SQL和各个参数的值，手动拼接一下就能在数据库工具里测试了。

// 在设置参数后，执行前，可以打印日志（实际项目用log4j等） System.out.println("执行SQL: " + pstmt.toString()); // 某些驱动会输出带参SQL // 或者手动记录 System.out.println("SQL: " + sql + ", 参数: [" + student.getName() + ", ...]");

4.3 从“项目完成”到“项目完善”：进阶思考

做到上面这些，一个可运行的学生信息管理系统就完成了。但如果你想让它更接近“企业级”雏形，或者为面试增加亮点，可以考虑以下扩展方向：

1. 引入连接池：频繁创建和关闭数据库连接非常消耗资源。可以集成如HikariCP、Druid这样的数据库连接池。只需将DBUtil.getConnection()方法改为从连接池获取连接即可，这是性能优化的重要一步。
2. 使用日志框架：将代码中的System.out.println和e.printStackTrace()替换为Log4j 2或SLF4J等日志框架。可以灵活控制日志级别，输出到文件，方便线上问题排查。
3. 实现分页查询：当学生数据很多时，一次性查询所有数据不合理。可以在DAO层和Service层增加分页查询接口，使用MySQL的LIMIT offset, pageSize语法。
4. 增加事务管理：如前所述，在Service层方法中，对涉及多个DAO操作的方法，手动管理事务，保证数据一致性。
5. 抽象与优化：
   • 当前的DAO实现类中，每个实体类都要写一套几乎雷同的CRUD代码，存在大量重复。可以尝试提炼一个泛型基类BaseDao，将通用的getConnection、close、以及简单的findById、findAll方法实现放在基类中，让具体的StudentDaoImpl只实现特殊的查询。
   • 手动的ResultSet到对象的映射很繁琐。可以尝试写一个简单的反射工具类，根据ResultSet的元数据和类的属性自动完成映射，这能让你更深入理解ORM框架的原理。
6. 打包与部署：学习如何使用Maven或Gradle管理项目依赖，将项目打包成可执行的JAR文件，这样你就可以通过java -jar sms.jar来运行它了。

这个基于控制台的学生管理系统，虽然界面简陋，但它完整地实践了软件分层的思想、面向对象的设计、JDBC的核心操作以及基本的异常处理和输入校验。把它吃透，你就为学习Spring Boot、MyBatis等企业级框架打下了无比坚实的基础。编程路上，很多时候把简单的东西做扎实了，复杂的东西自然就通了。

本文还有配套的精品资源，点击获取