Java 基础语法详解（十）
二十五、JDBC 数据库操作基础
JDBC（Java Database Connectivity）是 Java 访问数据库的标准接口，通过 JDBC 可实现与 MySQL、Oracle 等关系型数据库的交互，核心流程为 “加载驱动→建立连接→执行 SQL→处理结果→关闭资源”。
1. 前置准备
（1）环境配置
-
安装 MySQL 数据库（推荐 8.0 版本），创建数据库student_db；
-
在项目中导入 MySQL JDBC 驱动（Maven 项目可添加依赖，非 Maven 项目需手动导入mysql-connector-java-8.0.x.jar）：
<!-- Maven依赖 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.32</version>
</dependency>
- 创建学生表student，SQL 语句：
CREATE TABLE student (
id INT PRIMARY KEY AUTO_INCREMENT,
name VARCHAR(50) NOT NULL,
student_id VARCHAR(20) NOT NULL UNIQUE,
age INT NOT NULL,
status VARCHAR(20) NOT NULL
);
（2）JDBC 核心 API
| API 类 / 接口 | 功能描述 |
|---|---|
| DriverManager | 管理数据库驱动，提供getConnection()方法建立数据库连接 |
| Connection | 代表数据库连接，用于创建Statement/PreparedStatement对象执行 SQL |
| PreparedStatement | 预编译 SQL 语句对象，避免 SQL 注入，支持参数占位符（?） |
| ResultSet | 存储 SQL 查询结果的数据集，通过next()遍历，getXxx()获取字段值 |
| SQLException | JDBC 操作中抛出的异常，需捕获或声明抛出 |
2. JDBC 核心操作（CRUD）
（1）工具类封装（避免代码重复）
创建JDBCUtils类，封装连接建立和资源关闭逻辑：
import java.sql.*;
public class JDBCUtils {
// 数据库连接信息（根据实际情况修改）
private static final String URL = "jdbc:mysql://localhost:3306/student_db?useSSL=false&serverTimezone=UTC";
private static final String USER = "root"; // 数据库用户名
private static final String PASSWORD = "123456"; // 数据库密码
/**
* 建立数据库连接
*/
public static Connection getConnection() throws SQLException {
// MySQL 8.0+无需显式加载驱动（DriverManager自动加载）
return DriverManager.getConnection(URL, USER, PASSWORD);
}
/**
* 关闭资源（ResultSet + PreparedStatement + Connection）
*/
public static void closeResources(ResultSet rs, PreparedStatement pstmt, Connection conn) {
try {
if (rs != null) rs.close(); // 关闭结果集
if (pstmt != null) pstmt.close(); // 关闭SQL语句对象
if (conn != null) conn.close(); // 关闭连接
} catch (SQLException e) {
e.printStackTrace();
}
}
}
（2）添加学生（插入数据）
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class JDBCInsertDemo {
public static boolean addStudentToDB(Student student) {
Connection conn = null;
PreparedStatement pstmt = null;
// SQL语句：使用?作为参数占位符
String sql = "INSERT INTO student (name, student_id, age, status) VALUES (?, ?, ?, ?)";
try {
// 1. 建立连接
conn = JDBCUtils.getConnection();
// 2. 创建PreparedStatement对象
pstmt = conn.prepareStatement(sql);
// 3. 给占位符赋值（索引从1开始）
pstmt.setString(1, student.getName()); // 第1个?：姓名
pstmt.setString(2, student.getStudentId()); // 第2个?：学号
pstmt.setInt(3, student.getAge()); // 第3个?：年龄
pstmt.setString(4, student.getStatus().getDesc()); // 第4个?：状态（枚举转字符串）
// 4. 执行SQL（插入/更新/删除用executeUpdate()，返回影响行数）
int rows = pstmt.executeUpdate();
return rows > 0; // 影响行数>0表示执行成功
} catch (SQLException e) {
e.printStackTrace();
return false;
} finally {
// 5. 关闭资源
JDBCUtils.closeResources(null, pstmt, conn);
}
}
// 测试
public static void main(String[] args) {
Student student = new Student("张三", "2025001", 20, StudentStatus.STUDYING);
boolean result = addStudentToDB(student);
System.out.println(result ? "添加到数据库成功" : "添加到数据库失败");
}
}
（3）查询学生（根据学号）
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class JDBCQueryDemo {
public static Student getStudentFromDBByStudentId(String studentId) {
Connection conn = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
String sql = "SELECT name, student_id, age, status FROM student WHERE student_id = ?";
try {
conn = JDBCUtils.getConnection();
pstmt = conn.prepareStatement(sql);
pstmt.setString(1, studentId); // 赋值学号参数
// 执行查询（用executeQuery()，返回ResultSet）
rs = pstmt.executeQuery();
// 遍历结果集（rs.next()：判断是否有下一条数据）
if (rs.next()) {
// 通过字段名或索引获取值（推荐用字段名，避免索引变化导致错误）
String name = rs.getString("name");
int age = rs.getInt("age");
String statusDesc = rs.getString("status");
// 枚举转换（根据状态描述匹配枚举）
StudentStatus status = getStatusByDesc(statusDesc);
// 创建并返回Student对象
return new Student(name, studentId, age, status);
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
JDBCUtils.closeResources(rs, pstmt, conn);
}
return null; // 未查询到返回null
}
// 辅助方法：根据状态描述获取枚举
private static StudentStatus getStatusByDesc(String desc) {
for (StudentStatus status : StudentStatus.values()) {
if (status.getDesc().equals(desc)) {
return status;
}
}
throw new IllegalArgumentException("无效的状态描述：" + desc);
}
// 测试
public static void main(String[] args) {
Student student = getStudentFromDBByStudentId("2025001");
if (student != null) {
System.out.println("查询到学生：" + student);
} else {
System.out.println("未查询到该学生");
}
}
}
（4）删除学生（根据学号）
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class JDBCDeleteDemo {
public static boolean deleteStudentFromDBByStudentId(String studentId) {
Connection conn = null;
PreparedStatement pstmt = null;
String sql = "DELETE FROM student WHERE student_id = ?";
try {
conn = JDBCUtils.getConnection();
pstmt = conn.prepareStatement(sql);
pstmt.setString(1, studentId);
int rows = pstmt.executeUpdate();
return rows > 0;
} catch (SQLException e) {
e.printStackTrace();
return false;
} finally {
JDBCUtils.closeResources(null, pstmt, conn);
}
}
// 测试
public static void main(String[] args) {
boolean result = deleteStudentFromDBByStudentId("2025001");
System.out.println(result ? "从数据库删除成功" : "从数据库删除失败");
}
}
二十六、简易学生管理系统对接数据库（升级改造）
基于之前的内存版学生管理系统，升级为 “数据库持久化版”，将学生信息存储到 MySQL 中，替换原有的ArrayList存储方式，同时保留注解校验、枚举等核心特性。
1. 改造StudentManager类
import java.util.ArrayList;
import java.util.List;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
public class StudentManagerDB {
/**
* 添加学生（数据库版）
*/
public boolean addStudent(Student student) {
try {
// 1. 注解校验学生信息
Validator.validate(student);
// 2. 校验学号在数据库中是否已存在
if (getStudentByStudentId(student.getStudentId()) != null) {
System.out.println("添加失败：学号" + student.getStudentId() + "已存在！");
return false;
}
// 3. 插入数据库
boolean dbResult = JDBCInsertDemo.addStudentToDB(student);
if (dbResult) {
System.out.println("添加成功：" + student);
return true;
} else {
System.out.println("添加失败：数据库操作异常");
return false;
}
} catch (IllegalAccessException | IllegalArgumentException e) {
System.out.println("添加失败：" + e.getMessage());
return false;
}
}
/**
* 根据学号查询学生（数据库版）
*/
public Student getStudentByStudentId(String studentId) {
Student student = JDBCQueryDemo.getStudentFromDBByStudentId(studentId);
if (student != null) {
System.out.println("查询成功：" + student);
} else {
System.out.println("查询失败：学号" + studentId + "不存在！");
}
return student;
}
/**
* 根据学号删除学生（数据库版）
*/
public boolean deleteStudentByStudentId(String studentId) {
if (getStudentByStudentId(studentId) == null) {
return false;
}
boolean dbResult = JDBCDeleteDemo.deleteStudentFromDBByStudentId(studentId);
if (dbResult) {
System.out.println("删除成功：学号" + studentId);
return true;
} else {
System.out.println("删除失败：数据库操作异常");
return false;
}
}
/**
* 遍历所有学生（数据库版）
*/
public List<Student> listAllStudents() {
List<Student> studentList = new ArrayList<>();
Connection conn = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
String sql = "SELECT name, student_id, age, status FROM student";
try {
conn = JDBCUtils.getConnection();
pstmt = conn.prepareStatement(sql);
rs = pstmt.executeQuery();
// 遍历结果集，封装为Student列表
while (rs.next()) {
String name = rs.getString("name");
String studentId = rs.getString("student_id");
int age = rs.getInt("age");
String statusDesc = rs.getString("status");
StudentStatus status = JDBCQueryDemo.getStatusByDesc(statusDesc);
studentList.add(new Student(name, studentId, age, status));
}
// 打印所有学生
if (studentList.isEmpty()) {
System.out.println("当前无学生信息！");
} else {
System.out.println("\n=== 所有学生信息 ===");
for (int i = 0; i < studentList.size(); i++) {
System.out.println((i + 1) + ". " + studentList.get(i));
}
System.out.println("===================\n");
}
} catch (SQLException e) {
e.printStackTrace();
System.out.println("查询所有学生失败：数据库操作异常");
} finally {
JDBCUtils.closeResources(rs, pstmt, conn);
}
return studentList;
}
}
2. 测试改造后的系统
public class StudentManagerDBTest {
public static void main(String[] args) {
StudentManagerDB manager = new StudentManagerDB();
// 1. 添加学生
System.out.println("=== 测试添加学生 ===");
manager.addStudent(new Student("张三", "2025001", 20, StudentStatus.STUDYING));
manager.addStudent(new Student("李四", "2025002", 22, StudentStatus.SUSPENDED));
manager.addStudent(new Student("王五", "2025003", 21, StudentStatus.GRADUATED));
// 2. 查询学生
System.out.println("\n=== 测试查询学生 ===");
manager.getStudentByStudentId("2025002");
// 3. 遍历所有学生
System.out.println("\n=== 测试遍历所有学生 ===");
manager.listAllStudents();
// 4. 删除学生
System.out.println("\n=== 测试删除学生 ===");
manager.deleteStudentByStudentId("2025003");
// 5. 再次遍历所有学生
System.out.println("\n=== 再次遍历所有学生 ===");
manager.listAllStudents();
}
}
3. 改造后运行结果
=== 测试添加学生 ===
对象校验通过！
添加成功：Student{姓名='张三', 学号='2025001', 年龄=20, 状态='在读'}
对象校验通过！
添加成功：Student{姓名='李四', 学号='2025002', 年龄=22, 状态='休学'}
对象校验通过！
添加成功：Student{姓名='王五', 学号='2025003', 年龄=21, 状态='毕业'}
=== 测试查询学生 ===
查询成功：Student{姓名='李四', 学号='2025002', 年龄=22, 状态='休学'}
=== 测试遍历所有学生 ===
=== 所有学生信息 ===
1. Student{姓名='张三', 学号='2025001', 年龄=20, 状态='在读'}
2. Student{姓名='李四', 学号='2025002', 年龄=22, 状态='休学'}
3. Student{姓名='王五', 学号='2025003', 年龄=21, 状态='毕业'}
===================
=== 测试删除学生 ===
查询成功：Student{姓名='王五', 学号='2025003', 年龄=21, 状态='毕业'}
删除成功：学号2025003
=== 再次遍历所有学生 ===
=== 所有学生信息 ===
1. Student{姓名='张三', 学号='2025001', 年龄=20, 状态='在读'}
2. Student{姓名='李四', 学号='2025002', 年龄=22, 状态='休学'}
===================
二十七、Java 基础语法知识体系总结
通过前面的学习，我们已构建起完整的 Java 基础语法知识框架，核心可归纳为 “四大支柱 + 两大工具 + 一个实践”：
1. 四大核心支柱（语言基础）
| 支柱 | 核心内容 |
|---|---|
| 数据类型与语法 | 8 种基本类型、引用类型（类 / 数组 / 集合）、运算符、流程控制（分支 / 循环） |
| 面向对象思想 | 封装（类与对象）、继承（extends/super）、多态（方法重写 / 向上转型）、抽象类与接口 |
| 异常处理 | try-catch-finally、throw/throws、自定义异常、异常链 |
| 高级特性 | 枚举（固定常量集）、注解（元数据标记）、反射（运行时操作类结构） |
2. 两大实用工具（开发必备）
| 工具 | 核心作用 |
|---|---|
| 集合框架 | ArrayList/HashMap等容器，解决动态数据存储问题，提升数据操作效率 |
| JDBC | 数据库访问接口，实现数据持久化，衔接内存数据与磁盘数据库 |
扫一扫
12万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
