Java操作MySQL数据库学习：从基础入门到高级实践

一、基础概念

（一）数据库基础

数据库是计算机科学中用于存储和管理数据的系统。它通过结构化的方式组织数据，使得数据的检索、更新和管理更加高效。在数据库中，数据通常以表的形式存储，每个表由多个字段组成，字段定义了数据的类型和属性。例如，一个学生表可能包含学号、姓名、年龄和性别等字段。

关系型数据库

关系型数据库是基于关系模型的数据库，它使用表格来存储数据，并通过关系来表示数据之间的联系。关系型数据库的核心概念包括表、字段、记录、主键和外键等。表是数据存储的基本单位，字段定义了表中数据的类型和属性，记录是表中的一行数据，主键是表中唯一标识一条记录的字段或字段组合，外键用于建立表与表之间的关系。

SQL语言

SQL（Structured Query Language）是用于管理和操作关系型数据库的标准语言。它包括数据定义语言（DDL）、数据操纵语言（DML）和数据控制语言（DCL）。

数据定义语言（DDL）：用于定义数据库的结构，包括创建、修改和删除数据库对象，如表、索引等。例如：
```
CREATE TABLE students (
    id INT PRIMARY KEY,
    name VARCHAR(50),
    age INT,
    gender CHAR(1)
);
```
数据操纵语言（DML）：用于操作数据库中的数据，包括插入、更新、删除和查询数据。例如：
```
INSERT INTO students (id, name, age, gender) VALUES (1, 'Alice', 20, 'F');
SELECT * FROM students WHERE age > 18;
```
数据控制语言（DCL）：用于控制数据库的访问权限，包括授权和撤销权限。例如：
```
GRANT SELECT, INSERT ON students TO user1;
```

（二）MySQL基础

MySQL是一种广泛使用的开源关系型数据库管理系统，以其高性能、可靠性和易用性而受到开发者的青睐。以下是学习MySQL的基础内容：

安装与配置

在开始学习MySQL之前，需要先安装并配置MySQL服务器。安装过程因操作系统而异，但通常可以通过以下步骤完成：

下载MySQL安装包：从MySQL官方网站下载适合操作系统的安装包。
安装MySQL：运行安装程序，按照提示完成安装。
配置MySQL：在安装过程中或安装完成后，需要配置MySQL的参数，如设置root用户密码、配置字符集等。

常用命令

熟悉MySQL的常用命令是进行数据库操作的基础。以下是一些常用的MySQL命令：

登录MySQL：
```
mysql -u root -p
```
退出MySQL：
```
exit;
```
查看数据库列表：
```
SHOW DATABASES;
```
创建数据库：
```
CREATE DATABASE mydatabase;
```
切换数据库：
```
USE mydatabase;
```

创建表：

CREATE TABLE students (
    id INT PRIMARY KEY,
    name VARCHAR(50),
    age INT,
    gender CHAR(1)
);

插入数据：

INSERT INTO students (id, name, age, gender) VALUES (1, 'Alice', 20, 'F');

查询数据：
```
SELECT * FROM students;
```

存储引擎

MySQL支持多种存储引擎，每种存储引擎都有其特点和适用场景。常见的存储引擎包括InnoDB和MyISAM：

InnoDB：支持事务处理、行级锁定和外键约束，适用于需要高并发和事务支持的应用场景。
MyISAM：不支持事务处理，但查询速度较快，适用于以读操作为主的场景。

（三）Java基础

Java是一种面向对象的编程语言，具有跨平台、高性能和安全性等特点。以下是学习Java操作MySQL数据库所需的基础知识：

基本语法

掌握Java的基本语法是进行数据库操作的前提。包括数据类型、变量、流程控制语句、数组等。例如：

int age = 20;
if (age > 18) {
    System.out.println("Adult");
} else {
    System.out.println("Minor");
}

面向对象编程

Java的核心是面向对象编程，它通过类和对象来组织代码。类是对象的模板，定义了对象的属性和行为；对象是类的实例。例如：

public class Student {
    private int id;
    private String name;
    private int age;
    private char gender;

    public Student(int id, String name, int age, char gender) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    // Getter and Setter methods
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }
}

异常处理

Java的异常处理机制用于处理程序运行时可能出现的错误。通过try-catch块捕获异常，并在catch块中处理异常。例如：

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Error: " + e.getMessage());
}

二、Java连接MySQL数据库

（一）JDBC（Java Database Connectivity）

JDBC是Java与数据库交互的标准接口，它提供了一套API，使得Java程序能够连接和操作数据库。以下是学习JDBC的关键内容：

加载JDBC驱动程序

在使用JDBC连接MySQL之前，需要加载MySQL的JDBC驱动程序。通常使用Class.forName()方法加载驱动：

Class.forName("com.mysql.cj.jdbc.Driver");

建立数据库连接

通过DriverManager.getConnection()方法建立与MySQL数据库的连接。需要提供数据库的URL、用户名和密码：

String url = "jdbc:mysql://localhost:3306/mydatabase";
String user = "root";
String password = "password";
Connection connection = DriverManager.getConnection(url, user, password);

执行SQL语句

在建立连接后，可以通过Statement或PreparedStatement对象执行SQL语句。Statement对象用于执行简单的SQL语句，而PreparedStatement对象用于执行预编译的SQL语句，可以提高性能并防止SQL注入。

使用Statement对象：

Statement statement = connection.createStatement();
ResultSet resultSet = statement.executeQuery("SELECT * FROM students");
while (resultSet.next()) {
    System.out.println(resultSet.getString("name"));
}

使用PreparedStatement对象：

String sql = "SELECT * FROM students WHERE age > ?";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, 18);
ResultSet resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {
    System.out.println(resultSet.getString("name"));
}

处理查询结果

查询结果通过ResultSet对象返回。可以使用ResultSet的方法获取字段值，并遍历结果集：

while (resultSet.next()) {
    int id = resultSet.getInt("id");
    String name = resultSet.getString("name");
    int age = resultSet.getInt("age");
    char gender = resultSet.getString("gender").charAt(0);
    System.out.println(id + ", " + name + ", " + age + ", " + gender);
}

关闭数据库连接

在完成数据库操作后，需要关闭ResultSet、Statement和Connection对象，以释放数据库资源：

if (resultSet != null) {
    resultSet.close();
}
if (statement != null) {
    statement.close();
}
if (connection != null) {
    connection.close();
}

（二）连接池技术（可选）

连接池是一种数据库连接管理技术，它可以提高数据库连接的效率，减少频繁创建和关闭连接的开销。以下是常用的连接池实现及其使用方法：

DBCP（Database Connection Pool）

DBCP是Apache提供的连接池实现。使用DBCP需要配置连接池的参数，如最大连接数、最小空闲连接数等：

BasicDataSource dataSource = new BasicDataSource();
dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/mydatabase");
dataSource.setUsername("root");
dataSource.setPassword("password");
dataSource.setMaxTotal(10); // 最大连接数
dataSource.setMinIdle(2); // 最小空闲连接数
Connection connection = dataSource.getConnection();

C3P0

C3P0是另一个流行的连接池实现。它的配置方式与DBCP类似：

ComboPooledDataSource dataSource = new ComboPooledDataSource();
dataSource.setDriverClass("com.mysql.cj.jdbc.Driver");
dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/mydatabase");
dataSource.setUser("root");
dataSource.setPassword("password");
dataSource.setMaxPoolSize(10); // 最大连接数
dataSource.setMinPoolSize(2); // 最小空闲连接数
Connection connection = dataSource.getConnection();

Druid

Druid是阿里巴巴提供的连接池实现，它提供了更多的功能和更好的性能。使用Druid需要配置连接池的参数：

DruidDataSource dataSource = new DruidDataSource();
dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/mydatabase");
dataSource.setUsername("root");
dataSource.setPassword("password");
dataSource.setMaxActive(10); // 最大连接数
dataSource.setMinIdle(2); // 最小空闲连接数
Connection connection = dataSource.getConnection();

三、CRUD操作（增、删、改、查）

（一）创建（Create）

创建操作是指向数据库中插入新的数据。在Java中，可以通过PreparedStatement或Statement对象执行INSERT语句来完成创建操作。以下是具体的实现步骤：

使用`PreparedStatement`对象

PreparedStatement对象是预编译的SQL语句，它可以提高性能并防止SQL注入。以下是使用PreparedStatement对象插入数据的示例：

String sql = "INSERT INTO students (id, name, age, gender) VALUES (?, ?, ?, ?)";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, 2);
preparedStatement.setString(2, "Bob");
preparedStatement.setInt(3, 22);
preparedStatement.setString(4, "M");
int rows = preparedStatement.executeUpdate();
if (rows > 0) {
    System.out.println("Data inserted successfully.");
}

获取自增主键

在插入数据时，如果表的主键是自增的，可以通过PreparedStatement对象获取插入后的自增主键值：

String sql = "INSERT INTO students (name, age, gender) VALUES (?, ?, ?)";
PreparedStatement preparedStatement = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
preparedStatement.setString(1, "Charlie");
preparedStatement.setInt(2, 25);
preparedStatement.setString(3, "M");
int rows = preparedStatement.executeUpdate();
if (rows > 0) {
    ResultSet generatedKeys = preparedStatement.getGeneratedKeys();
    if (generatedKeys.next()) {
        int generatedId = generatedKeys.getInt(1);
        System.out.println("Generated ID: " + generatedId);
    }
}

（二）查询（Retrieve）

查询操作是指从数据库中检索数据。在Java中，可以通过SELECT语句查询数据，并通过PreparedStatement或Statement对象执行查询。以下是具体的实现步骤：

使用`PreparedStatement`对象

PreparedStatement对象不仅可以防止SQL注入，还可以提高查询性能。以下是使用PreparedStatement对象查询数据的示例：

String sql = "SELECT * FROM students WHERE age > ?";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, 18);
ResultSet resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {
    int id = resultSet.getInt("id");
    String name = resultSet.getString("name");
    int age = resultSet.getInt("age");
    char gender = resultSet.getString("gender").charAt(0);
    System.out.println(id + ", " + name + ", " + age + ", " + gender);
}

分页查询

分页查询是指将查询结果分成多个页面显示。在MySQL中，可以通过LIMIT子句实现分页查询。以下是分页查询的示例：

int pageNumber = 1; // 当前页码
int pageSize = 10; // 每页显示的记录数
String sql = "SELECT * FROM students LIMIT ?, ?";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, (pageNumber - 1) * pageSize);
preparedStatement.setInt(2, pageSize);
ResultSet resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {
    int id = resultSet.getInt("id");
    String name = resultSet.getString("name");
    int age = resultSet.getInt("age");
    char gender = resultSet.getString("gender").charAt(0);
    System.out.println(id + ", " + name + ", " + age + ", " + gender);
}

（三）更新（Update）

更新操作是指修改数据库中的现有数据。在Java中，可以通过UPDATE语句更新数据，并通过PreparedStatement或Statement对象执行更新操作。以下是具体的实现步骤：

使用`PreparedStatement`对象

PreparedStatement对象可以提高更新操作的性能并防止SQL注入。以下是使用PreparedStatement对象更新数据的示例：

String sql = "UPDATE students SET age = ? WHERE id = ?";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, 23);
preparedStatement.setInt(2, 1);
int rows = preparedStatement.executeUpdate();
if (rows > 0) {
    System.out.println("Data updated successfully.");
}

（四）删除（Delete）

删除操作是指从数据库中删除数据。在Java中，可以通过DELETE语句删除数据，并通过PreparedStatement或Statement对象执行删除操作。以下是具体的实现步骤：

使用`PreparedStatement`对象

PreparedStatement对象可以提高删除操作的性能并防止SQL注入。以下是使用PreparedStatement对象删除数据的示例：

String sql = "DELETE FROM students WHERE id = ?";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, 1);
int rows = preparedStatement.executeUpdate();
if (rows > 0) {
    System.out.println("Data deleted successfully.");
}

四、事务处理

（一）事务的基本概念

事务是一组逻辑操作单元，它使得一系列的操作要么全部成功，要么全部失败。事务的ACID特性是保证数据库操作完整性和一致性的关键：

原子性（Atomicity）：事务中的所有操作要么全部完成，要么全部不完成。
一致性（Consistency）：事务执行前后，数据库的状态保持一致。
隔离性（Isolation）：多个事务并发执行时，每个事务看到的数据库状态是独立的。
持久性（Durability）：事务一旦提交，其结果是永久性的。

（二）事务的使用

在Java中，可以通过Connection对象管理事务。以下是具体的实现步骤：

开启事务

通过设置Connection对象的事务隔离级别和关闭自动提交模式来开启事务：

connection.setAutoCommit(false); // 关闭自动提交模式
connection.setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ); // 设置事务隔离级别

提交事务

在事务操作成功后，通过调用commit()方法提交事务：

connection.commit();

回滚事务

在事务操作失败时，通过调用rollback()方法回滚事务：

connection.rollback();

关闭事务

在事务操作完成后，需要关闭Connection对象以释放资源：

connection.close();

异常处理

在事务操作中，需要捕获异常并根据异常情况决定是否回滚事务：

try {
    connection.setAutoCommit(false);
    // 执行事务操作
    connection.commit();
} catch (SQLException e) {
    connection.rollback();
    e.printStackTrace();
} finally {
    connection.close();
}

五、高级应用

（一）存储过程

存储过程是存储在数据库中的一组预编译的SQL语句。它可以提高代码的复用性和执行效率。以下是学习存储过程的关键内容：

创建存储过程

在MySQL中，可以通过以下语法创建存储过程：

DELIMITER //
CREATE PROCEDURE GetStudentsByAge(IN age INT)
BEGIN
    SELECT * FROM students WHERE age > age;
END //
DELIMITER ;

调用存储过程

在Java中，可以通过CallableStatement对象调用存储过程。以下是调用存储过程的示例：

String sql = "{CALL GetStudentsByAge(?)}";
CallableStatement callableStatement = connection.prepareCall(sql);
callableStatement.setInt(1, 18);
ResultSet resultSet = callableStatement.executeQuery();
while (resultSet.next()) {
    int id = resultSet.getInt("id");
    String name = resultSet.getString("name");
    int age = resultSet.getInt("age");
    char gender = resultSet.getString("gender").charAt(0);
    System.out.println(id + ", " + name + ", " + age + ", " + gender);
}

（二）批处理

批处理是指一次性执行多个SQL语句。它可以提高批量操作的效率。以下是使用PreparedStatement对象进行批处理的示例：

String sql = "INSERT INTO students (id, name, age, gender) VALUES (?, ?, ?, ?)";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1, 3);
preparedStatement.setString(2, "David");
preparedStatement.setInt(3, 28);
preparedStatement.setString(4, "M");
preparedStatement.addBatch();

preparedStatement.setInt(1, 4);
preparedStatement.setString(2, "Eve");
preparedStatement.setInt(3, 21);
preparedStatement.setString(4, "F");
preparedStatement.addBatch();

int[] rows = preparedStatement.executeBatch();
for (int row : rows) {
    System.out.println("Rows affected: " + row);
}

（三）动态SQL

动态SQL是指在运行时根据条件动态生成SQL语句。在Java中，可以通过StringBuilder或StringBuffer等类动态拼接SQL语句。以下是动态SQL的示例：

StringBuilder sql = new StringBuilder("SELECT * FROM students");
if (age > 0) {
    sql.append(" WHERE age > ").append(age);
}
Statement statement = connection.createStatement();
ResultSet resultSet = statement.executeQuery(sql.toString());
while (resultSet.next()) {
    int id = resultSet.getInt("id");
    String name = resultSet.getString("name");
    int age = resultSet.getInt("age");
    char gender = resultSet.getString("gender").charAt(0);
    System.out.println(id + ", " + name + ", " + age + ", " + gender);
}

（四）ORM框架（可选）

ORM（Object-Relational Mapping）框架是一种将数据库中的表映射为Java对象的技术。它简化了数据库操作的代码，提高了开发效率。以下是常用的ORM框架及其使用方法：

Hibernate

Hibernate是一个流行的ORM框架。它通过配置文件和注解将Java类映射为数据库表。以下是Hibernate的基本使用方法：

配置Hibernate：在hibernate.cfg.xml文件中配置数据库连接信息和映射文件。

定义实体类：通过注解将Java类映射为数据库表。

@Entity
@Table(name = "students")
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    @Column(name = "name")
    private String name;

    @Column(name = "age")
    private int age;

    @Column(name = "gender")
    private char gender;

    // Getter and Setter methods
}

操作数据库：通过Session对象执行CRUD操作。

Session session = HibernateUtil.getSessionFactory().openSession();
Transaction transaction = session.beginTransaction();
Student student = new Student();
student.setName("Frank");
student.setAge(24);
student.setGender('M');
session.save(student);
transaction.commit();
session.close();

MyBatis

MyBatis是一个轻量级的ORM框架。它通过映射文件将SQL语句与Java对象关联起来。以下是MyBatis的基本使用方法：

配置MyBatis：在mybatis-config.xml文件中配置数据库连接信息和映射文件。

定义映射文件：在映射文件中定义SQL语句和Java对象的映射关系。

<select id="getStudentsByAge" parameterType="int" resultType="Student">
    SELECT * FROM students WHERE age > #{age}
</select>

操作数据库：通过SqlSession对象执行CRUD操作。

SqlSession sqlSession = MyBatisUtil.getSqlSessionFactory().openSession();
List<Student> students = sqlSession.selectList("getStudentsByAge", 18);
for (Student student : students) {
    System.out.println(student.getName());
}
sqlSession.close();

六、性能优化

（一）数据库性能优化

优化数据库性能是提高应用性能的关键。以下是一些常见的数据库性能优化方法：

合理设计数据库表结构

规范化设计：通过规范化设计减少数据冗余，提高数据一致性。
索引优化：合理使用索引可以提高查询速度，但过多的索引会降低插入、更新和删除的性能。
分区表：对于大型表，可以通过分区表的方式将数据分散存储，提高查询效率。

优化SQL语句

避免全表扫描：通过使用索引和优化查询条件，避免全表扫描。
减少数据传输量：通过在查询中指定需要的字段，减少不必要的数据传输。
使用批量操作：通过批处理操作减少数据库交互次数。

（二）Java性能优化

在Java中，可以通过以下方法优化数据库操作的性能：

使用连接池

连接池可以减少频繁创建和关闭数据库连接的开销，提高数据库操作的效率。

预编译SQL语句

使用PreparedStatement对象预编译SQL语句可以提高性能并防止SQL注入。

批量操作

通过批量操作减少数据库交互次数，提高性能。

七、安全与异常处理

（一）SQL注入

SQL注入是一种常见的安全漏洞，攻击者通过在输入中插入恶意SQL代码来攻击数据库。以下是防止SQL注入的方法：

使用`PreparedStatement`对象

PreparedStatement对象可以预编译SQL语句，防止SQL注入。例如：

String sql = "SELECT * FROM students WHERE name = ?";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1, "Alice");
ResultSet resultSet = preparedStatement.executeQuery();

对用户输入进行校验

在将用户输入传递给SQL语句之前，对输入进行校验，确保输入的合法性。

（二）异常处理

在Java中，可以通过try-catch块捕获异常，并在catch块中处理异常。以下是异常处理的示例：

try {
    // 数据库操作代码
} catch (SQLException e) {
    e.printStackTrace();
    // 处理异常
} finally {
    // 关闭数据库连接
    if (resultSet != null) {
        resultSet.close();
    }
    if (statement != null) {
        statement.close();
    }
    if (connection != null) {
        connection.close();
    }
}

八、实践项目

（一）小型项目实践

通过开发一个小型的Java应用程序，如学生管理系统、图书管理系统等，将所学的Java数据库操作知识应用到实际项目中。以下是学生管理系统的实现步骤：

项目需求分析

功能需求：学生信息的增、删、改、查，分页查询，事务处理等。
技术选型：Java、MySQL、JDBC。

数据库设计

创建学生表students，包含字段id、name、age和gender。

Java代码实现

加载JDBC驱动并建立连接：

public class DatabaseUtil {
    private static final String URL = "jdbc:mysql://localhost:3306/mydatabase";
    private static final String USER = "root";
    private static final String PASSWORD = "password";

    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(URL, USER, PASSWORD);
    }
}

实现CRUD操作：

public class StudentDao {
    public void addStudent(Student student) throws SQLException {
        String sql = "INSERT INTO students (name, age, gender) VALUES (?, ?, ?)";
        try (Connection connection = DatabaseUtil.getConnection();
             PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setString(1, student.getName());
            preparedStatement.setInt(2, student.getAge());
            preparedStatement.setString(3, String.valueOf(student.getGender()));
            preparedStatement.executeUpdate();
        }
    }

    public List<Student> getStudents(int pageNumber, int pageSize) throws SQLException {
        List<Student> students = new ArrayList<>();
        String sql = "SELECT * FROM students LIMIT ?, ?";
        try (Connection connection = DatabaseUtil.getConnection();
             PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setInt(1, (pageNumber - 1) * pageSize);
            preparedStatement.setInt(2, pageSize);
            ResultSet resultSet = preparedStatement.executeQuery();
            while (resultSet.next()) {
                Student student = new Student();
                student.setId(resultSet.getInt("id"));
                student.setName(resultSet.getString("name"));
                student.setAge(resultSet.getInt("age"));
                student.setGender(resultSet.getString("gender").charAt(0));
                students.add(student);
            }
        }
        return students;
    }

    public void updateStudent(Student student) throws SQLException {
        String sql = "UPDATE students SET name = ?, age = ?, gender = ? WHERE id = ?";
        try (Connection connection = DatabaseUtil.getConnection();
             PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setString(1, student.getName());
            preparedStatement.setInt(2, student.getAge());
            preparedStatement.setString(3, String.valueOf(student.getGender()));
            preparedStatement.setInt(4, student.getId());
            preparedStatement.executeUpdate();
        }
    }

    public void deleteStudent(int id) throws SQLException {
        String sql = "DELETE FROM students WHERE id = ?";
        try (Connection connection = DatabaseUtil.getConnection();
             PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setInt(1, id);
            preparedStatement.executeUpdate();
        }
    }
}

事务处理：

public class StudentService {
    private StudentDao studentDao = new StudentDao();

    public void addStudent(Student student) throws SQLException {
        try (Connection connection = DatabaseUtil.getConnection()) {
            connection.setAutoCommit(false);
            studentDao.addStudent(student);
            connection.commit();
        } catch (SQLException e) {
            throw new SQLException("Error adding student", e);
        }
    }

    public void updateStudent(Student student) throws SQLException {
        try (Connection connection = DatabaseUtil.getConnection()) {
            connection.setAutoCommit(false);
            studentDao.updateStudent(student);
            connection.commit();
        } catch (SQLException e) {
            throw new SQLException("Error updating student", e);
        }
    }

    public void deleteStudent(int id) throws SQLException {
        try (Connection connection = DatabaseUtil.getConnection()) {
            connection.setAutoCommit(false);
            studentDao.deleteStudent(id);
            connection.commit();
        } catch (SQLException e) {
            throw new SQLException("Error deleting student", e);
        }
    }
}

分页查询：

public class StudentController {
    private StudentService studentService = new StudentService();

    public void displayStudents(int pageNumber, int pageSize) throws SQLException {
        List<Student> students = studentService.getStudents(pageNumber, pageSize);
        for (Student student : students) {
            System.out.println(student.getId() + ", " + student.getName() + ", " + student.getAge() + ", " + student.getGender());
        }
    }
}

主程序：

public class Main {
    public static void main(String[] args) throws SQLException {
        StudentController studentController = new StudentController();
        studentController.displayStudents(1, 10);
    }
}

（二）项目优化与维护

在完成项目开发后，需要对项目进行优化和维护。以下是优化和维护的步骤：

性能优化

优化数据库表结构：通过添加索引、分区表等方式优化数据库性能。
优化SQL语句：通过减少全表扫描、减少数据传输量等方式优化SQL语句。
使用连接池：通过使用连接池减少数据库连接的创建和关闭次数。

代码优化

提高代码可读性：通过合理的命名、注释和代码结构提高代码的可读性。
减少重复代码：通过封装和复用代码减少重复代码。

功能扩展

添加新功能：根据用户需求添加新功能，如学生信息的导出、搜索功能等。
修复已知问题：根据用户反馈修复已知问题，提高系统的稳定性和可靠性。

posted @ 2025-04-08 16:21 软件职业规划阅读(48) 评论(0) 收藏举报

刷新页面返回顶部

Java操作MySQL数据库学习：从基础入门到高级实践

一、基础概念

（一）数据库基础

关系型数据库

SQL语言

（二）MySQL基础

安装与配置

常用命令

存储引擎

（三）Java基础

基本语法

面向对象编程

异常处理

二、Java连接MySQL数据库

（一）JDBC（Java Database Connectivity）

加载JDBC驱动程序

建立数据库连接

执行SQL语句

处理查询结果

关闭数据库连接

（二）连接池技术（可选）

DBCP（Database Connection Pool）

C3P0

Druid

三、CRUD操作（增、删、改、查）

（一）创建（Create）

使用PreparedStatement对象

获取自增主键

（二）查询（Retrieve）

使用PreparedStatement对象

分页查询

（三）更新（Update）

使用PreparedStatement对象

（四）删除（Delete）

使用PreparedStatement对象

四、事务处理

（一）事务的基本概念

（二）事务的使用

开启事务

提交事务

回滚事务

关闭事务

异常处理

五、高级应用

（一）存储过程

创建存储过程

调用存储过程

（二）批处理

（三）动态SQL

（四）ORM框架（可选）

Hibernate

MyBatis

六、性能优化

（一）数据库性能优化

合理设计数据库表结构

优化SQL语句

（二）Java性能优化

使用连接池

预编译SQL语句

批量操作

七、安全与异常处理

（一）SQL注入

使用PreparedStatement对象

对用户输入进行校验

（二）异常处理

八、实践项目

（一）小型项目实践

项目需求分析

数据库设计

Java代码实现

（二）项目优化与维护

性能优化

代码优化

功能扩展

公告

使用`PreparedStatement`对象

使用`PreparedStatement`对象

使用`PreparedStatement`对象

使用`PreparedStatement`对象

使用`PreparedStatement`对象