Java连接MySQL数据库如何实现？-建站教程-锦华智联科技

准备工作
- 安装 JDK
- 安装 MySQL 数据库
- 安装 IDE (推荐 IntelliJ IDEA 或 Eclipse)
- 准备一个 MySQL 数据库和表
使用传统 JDBC (Java Database Connectivity)
- 步骤 1: 添加 MySQL JDBC 驱动依赖
- 步骤 2: 加载并注册驱动
- 步骤 3: 建立数据库连接
- 步骤 4: 创建 Statement 对象
- 步骤 5: 执行 SQL 语句
- 步骤 6: 处理结果集
- 步骤 7: 关闭资源 (非常重要！)
- 完整 JDBC 代码示例
- JDBC 优缺点分析
使用 Spring Data JPA (更现代、推荐的方式)
- 什么是 Spring Data JPA？
- 步骤 1: 创建 Spring Boot 项目
- 步骤 2: 添加依赖
- 步骤 3: 配置数据库连接信息
- 步骤 4: 创建实体类
- 步骤 5: 创建 Repository 接口
- 步骤 6: 创建 Service 和 Controller 进行测试
- Spring Data JPA 优缺点分析
总结与对比

准备工作

在开始编码之前,请确保你的电脑上已安装以下软件：

（图片来源网络，侵删）

JDK (Java Development Kit): Java 开发工具包，建议使用 JDK 8 或更高版本。
MySQL Server: MySQL 数据库服务器，建议版本 5.7 或 8.0。
IDE (Integrated Development Environment): 集成开发环境，强烈推荐 IntelliJ IDEA (社区版免费) 或 Eclipse。
数据库管理工具: 可选，但强烈推荐，如 Navicat for MySQL, DBeaver 或 MySQL 自带的 mysql 命令行工具。

准备一个测试数据库和表：

打开你的 MySQL 客户端，执行以下 SQL 语句来创建一个名为 jdbctest 的数据库和一个 users 表。

-- 创建数据库
CREATE DATABASE IF NOT EXISTS jdbctest;
-- 使用该数据库
USE jdbctest;
-- 创建 users 表
CREATE TABLE IF NOT EXISTS users (
    id INT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(50) NOT NULL,
    password VARCHAR(50) NOT NULL,
    email VARCHAR(100),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
-- 插入一些测试数据
INSERT INTO users (username, password, email) VALUES
('zhangsan', '123456', 'zhangsan@example.com'),
('lisi', 'password123', 'lisi@example.com');

方式一：使用传统 JDBC

JDBC 是 Java 访问数据库的官方标准 API，它提供了一套接口，允许 Java 程序执行 SQL 语句。

步骤 1: 添加 MySQL JDBC 驱动依赖

你需要将 MySQL 提供的 JDBC 驱动程序（一个 .jar 文件）添加到你的项目中。

（图片来源网络，侵删）

Maven 用户: 在 pom.xml 文件中添加以下依赖。
```
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.28</version> 
</dependency>
```
注意：对于较新的 Spring Boot 项目，你可能只需要 groupId 和 artifactId，版本号会由 spring-boot-starter-parent 自动管理。
Gradle 用户: 在 build.gradle 文件中添加以下依赖。
```
implementation 'mysql:mysql-connector-java:8.0.28'
```
手动下载用户: 访问 MySQL Connector/J 下载页面，下载对应的 .jar 文件,并将其添加到项目的类路径中。
（图片来源网络，侵删）

步骤 2: 加载并注册驱动

JDBC 4.0 之后（JDK 6+），这一步通常是自动完成的,但显式写出有助于理解。

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

注意：com.mysql.cj.jdbc.Driver 是 MySQL Connector/J 8.0 的驱动类名，旧版本可能是 com.mysql.jdbc.Driver。

步骤 3: 建立数据库连接

使用 DriverManager 的 getConnection() 方法来获取连接对象，你需要提供数据库的 URL、用户名和密码。

String url = "jdbc:mysql://localhost:3306/jdbctest?useSSL=false&serverTimezone=UTC";
String username = "root"; // 你的 MySQL 用户名
String password = "your_password"; // 你的 MySQL 密码
Connection connection = DriverManager.getConnection(url, username, password);

jdbc:mysql://: 协议。
localhost:3306: 数据库服务器的地址和端口。
/jdbctest: 要连接的数据库名。
?useSSL=false&serverTimezone=UTC: 连接参数。useSSL=false 用于禁用 SSL（本地开发时常用），serverTimezone=UTC 用于设置时区,避免警告。

步骤 4: 创建 Statement 对象

通过 Connection 对象创建一个 Statement 对象，用于执行 SQL 语句。

Statement statement = connection.createStatement();

步骤 5: 执行 SQL 语句

使用 Statement 对象的 executeQuery() 或 executeUpdate() 方法执行 SQL。

executeQuery(): 用于执行查询操作（SELECT），返回一个 ResultSet 对象。
executeUpdate(): 用于执行更新操作（INSERT, UPDATE, DELETE），返回一个整数,表示受影响的行数。

// 示例：查询所有用户
String sql = "SELECT * FROM users";
ResultSet resultSet = statement.executeQuery(sql);
// 示例：插入一个新用户
String insertSql = "INSERT INTO users (username, password, email) VALUES ('wangwu', 'qwerty', 'wangwu@example.com')";
int rowsAffected = statement.executeUpdate(insertSql);
System.out.println("插入了 " + rowsAffected + " 行数据。");

步骤 6: 处理结果集

如果执行的是查询，结果会存储在 ResultSet 对象中,你需要遍历这个对象来获取数据。

while (resultSet.next()) {
    // 通过列名或列索引获取数据
    int id = resultSet.getInt("id");
    String username = resultSet.getString("username");
    String email = resultSet.getString("email");
    System.out.println("ID: " + id + ", 用户名: " + username + ", 邮箱: " + email);
}

步骤 7: 关闭资源 (非常重要！)

为了防止数据库连接泄漏，你必须在使用完之后，按照创建的逆序关闭所有资源：ResultSet -> Statement -> Connection。

if (resultSet != null) {
    try {
        resultSet.close();
    } catch (SQLException e) {
        e.printStackTrace();
    }
}
if (statement != null) {
    try {
        statement.close();
    } catch (SQLException e) {
        e.printStackTrace();
    }
}
if (connection != null) {
    try {
        connection.close();
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

完整 JDBC 代码示例

import java.sql.*;
public class JdbcDemo {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/jdbctest?useSSL=false&serverTimezone=UTC";
        String username = "root";
        String password = "your_password";
        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;
        try {
            // 1. 加载驱动 (JDBC 4.0+ 可省略)
            Class.forName("com.mysql.cj.jdbc.Driver");
            // 2. 获取连接
            connection = DriverManager.getConnection(url, username, password);
            // 3. 创建 Statement
            statement = connection.createStatement();
            // 4. 执行查询
            String sql = "SELECT id, username, email FROM users";
            resultSet = statement.executeQuery(sql);
            // 5. 处理结果集
            System.out.println("ID\t用户名\t\t邮箱");
            System.out.println("---------------------------");
            while (resultSet.next()) {
                System.out.print(resultSet.getInt("id") + "\t");
                System.out.print(resultSet.getString("username") + "\t\t");
                System.out.println(resultSet.getString("email"));
            }
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        } finally {
            // 6. 关闭资源
            if (resultSet != null) {
                try { resultSet.close(); } catch (SQLException e) { e.printStackTrace(); }
            }
            if (statement != null) {
                try { statement.close(); } catch (SQLException e) { e.printStackTrace(); }
            }
            if (connection != null) {
                try { connection.close(); } catch (SQLException e) { e.printStackTrace(); }
            }
        }
    }
}

JDBC 优缺点分析

优点:
- 标准: Java 官方 API，所有 Java EE 应用服务器都支持。
- 轻量级: 不需要引入额外的框架。
- 灵活: 对 SQL 的控制非常精细。
缺点:
- 繁琐: 需要编写大量模板代码（加载驱动、获取连接、关闭资源等）。
- 易错: 手动管理资源容易导致连接泄漏。
- 代码耦合: SQL 语句硬编码在 Java 代码中,不易维护。
- 需要手动处理结果集: 将 ResultSet 映射到 Java 对象需要手动编写代码。

方式二：使用 Spring Data JPA (更现代、推荐的方式)

对于任何现代 Java Web 应用，尤其是基于 Spring Boot 的项目，强烈推荐使用 Spring Data JPA,它极大地简化了数据访问层的开发。

什么是 Spring Data JPA?

Spring Data JPA 是 Spring 框架的一个子项目，它对标准 JPA (Java Persistence API) 进行了封装，让你可以通过声明式的方式实现数据访问，你只需要定义一个接口，Spring 就会自动为你实现增删改查方法,无需编写任何实现代码。

步骤 1: 创建 Spring Boot 项目

使用 Spring Initializr (start.spring.io) 来创建一个新项目。

Project: Maven Project
Language: Java
Spring Boot: 选择一个稳定版本 (如 2.7.x 或 3.x.x)
Project Metadata:
- Group: com.example
- Artifact: demo
- Name: demo
- Description: Demo project for Spring Boot
- Package name: com.example.demo
Dependencies:
- Spring Web: 用于构建 Web 应用。
- Spring Data JPA: 核心,用于数据访问。
- MySQL Driver: 连接 MySQL 所需的驱动。

点击 "Generate" 下载项目压缩包，并用你的 IDE 打开它。

步骤 2: 添加依赖

检查 pom.xml 文件，确保已经包含了以下依赖（在创建项目时选择它们会自动添加）。

<dependencies>
    <!-- Spring Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- Spring Data JPA -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <!-- MySQL Driver -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
    <!-- Lombok (可选，简化代码) -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <!-- Test -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

步骤 3: 配置数据库连接信息

在 src/main/resources/application.properties 文件中添加数据库连接配置。

# DataSource Configuration
spring.datasource.url=jdbc:mysql://localhost:3306/jdbctest?useSSL=false&serverTimezone=UTC&allowPublicKeyRetrieval=true
spring.datasource.username=root
spring.datasource.password=your_password
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
# JPA/Hibernate Configuration
# 自动更新数据库表结构 (开发环境使用)
spring.jpa.hibernate.ddl-auto=update
# 显示执行的 SQL 语句
spring.jpa.show-sql=true
# 格式化 SQL 语句
spring.jpa.properties.hibernate.format_sql=true
# 指定 SQL 方言
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL8Dialect

步骤 4: 创建实体类

创建一个 Java 类，它对应数据库中的 users 表。

// src/main/java/com/example/demo/entity/User.java
package com.example.demo.entity;
import jakarta.persistence.*;
import lombok.Data;
import java.time.LocalDateTime;
@Data // Lombok 注解，自动生成 getter, setter, toString 等
@Entity // 声明这是一个 JPA 实体
@Table(name = "users") // 对应数据库中的 users 表
public class User {
    @Id // 声明主键
    @GeneratedValue(strategy = GenerationType.IDENTITY) // 主键生成策略为自增
    private Integer id;
    @Column(name = "username", nullable = false, length = 50)
    private String username;
    @Column(name = "password", nullable = false, length = 50)
    private String password;
    @Column(name = "email", length = 100)
    private String email;
    @Column(name = "created_at", updatable = false) // 创建后不可更新
    private LocalDateTime createdAt;
}

步骤 5: 创建 Repository 接口

这是 Spring Data JPA 的神奇之处，你只需要创建一个接口，并继承 JpaRepository,无需提供任何实现。

// src/main/java/com/example/demo/repository/UserRepository.java
package com.example.demo.repository;
import com.example.demo.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.Optional;
public interface UserRepository extends JpaRepository<User, Integer> {
    // Spring Data JPA 会自动根据方法名生成查询语句
    // findByUsername -> "SELECT u FROM User u WHERE u.username = ?1"
    Optional<User> findByUsername(String username);
}

步骤 6: 创建 Service 和 Controller 进行测试

创建一个 Service 来调用 Repository，再创建一个 Controller 来暴露一个 REST API 接口。

Service 层:

// src/main/java/com/example/demo/service/UserService.java
package com.example.demo.service;
import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    public List<User> getAllUsers() {
        return userRepository.findAll();
    }
    public User createUser(User user) {
        // 可以在这里添加业务逻辑，如密码加密
        return userRepository.save(user);
    }
}

Controller 层:

// src/main/java/com/example/demo/controller/UserController.java
package com.example.demo.controller;
import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/api/users")
public class UserController {
    @Autowired
    private UserService userService;
    @GetMapping
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }
    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.createUser(user);
    }
}

如何测试

运行 DemoApplication.java 主类。
使用 Postman 或 curl 等工具发送请求。

获取所有用户:
```
curl http://localhost:8080/api/users
```
你应该能看到之前插入的 zhangsan, lisi 的 JSON 数据。

创建一个新用户:

curl -X POST -H "Content-Type: application/json" -d '{"username":"wangwu","password":"123","email":"wangwu@new.com"}' http://localhost:8080/api/users

再次执行获取所有用户的请求，你就会看到新创建的 wangwu。

Spring Data JPA 优缺点分析

优点:
- 开发效率极高: 只需定义接口，即可拥有完整的 CRUD 功能。
- 代码简洁: 没有样板代码,业务逻辑清晰。
- 面向对象: 操作的是 Java 对象，而非 SQL 语句。
- 强大的查询功能: 支持通过方法名定义查询，也支持 @Query 注解自定义 JPQL/SQL。
- 集成事务管理: 与 Spring 的事务管理无缝集成。
缺点:
- 学习曲线: 需要理解 JPA/Hibernate 的概念和注解。
- 性能开销: ORM 框架会带来一定的性能开销，对于超高性能要求的场景可能需要优化或使用原生 SQL。
- SQL 控制力稍弱: 对于极其复杂或特定数据库优化的 SQL，可能需要通过 @Query 或使用原生 SQL 来实现。

总结与对比

特性	传统 JDBC	Spring Data JPA
易用性	繁琐，需要大量样板代码	极高，只需定义接口
开发效率	低	高
代码可维护性	差，SQL 与 Java 代码耦合	好，关注点分离
性能	直接，性能最好	有 ORM 开销，但通常可接受
灵活性	对 SQL 控制力最强	复杂 SQL 需要通过 `@Query` 或原生 SQL 实现
适用场景	简单工具、脚本、学习 JDBC 原理	几乎所有现代 Java Web 应用，尤其是企业级应用

如果你是初学者，想了解 Java 如何与数据库交互，从 JDBC 开始是很好的选择,它能让你理解数据库连接和操作的本质。
如果你正在开发一个实际的项目，特别是基于 Spring Boot 的项目，请毫不犹豫地选择 Spring Data JPA，它将为你节省大量时间和精力，让你更专注于业务逻辑的实现,而不是重复编写数据访问层代码。

Java连接MySQL数据库如何实现？

目录