Spring Boot MySQL

最后修改于 2023 年 8 月 2 日

在本文中，我们将展示如何在 Spring Boot 应用程序中使用 MySQL 数据库。

Spring 是一个流行的 Java 应用程序框架，用于创建企业应用程序。Spring Boot 是 Spring 框架的演进，它有助于以最小的 effort 创建基于 Spring 的独立、生产级应用程序。

MySQL

MySQL 是领先的开源数据库管理系统。它是一个多用户、多线程的数据库管理系统。MySQL 在网络上尤其受欢迎。它是非常流行的 LAMP 平台的一部分，该平台包括 Linux、Apache、MySQL 和 PHP。MySQL 数据库可在最重要的操作系统平台上使用。它运行在 BSD Unix、Linux、Windows 和 Mac 上。

MySQL 设置

我们将展示如何在 Debian Linux 系统上安装 MySQL 数据库。

$ sudo apt-get install mysql-server

此命令安装 MySQL 服务器和相关软件包。

$ sudo systemctl mysql start
$ sudo systemctl mysql stop

这两个命令用于启动和停止 MySQL。

$ sudo systemctl status mysql

我们使用 systemctl status mysql 命令检查数据库的状态。

$ sudo mysql -u root -p

现在我们需要重置 root 密码。我们启动 mysql 命令行工具。（服务器必须正在运行。）我们以 root 用户身份连接。

mysql> ALTER USER 'root'@'localhost' IDENTIFIED BY 'newpasswd';

我们为 root 设置一个新密码。

mysql> CREATE DATABASE testdb;

我们创建一个新的 testdb 数据库。

mysql> CREATE USER user12@localhost IDENTIFIED BY 's$cret';
mysql> GRANT ALL ON testdb.* TO user12@localhost;

我们创建一个新的 MySQL 用户并授予其对 testdb 数据库的权限。

创建 MySQL 表

现在我们将创建一个名为 cities 的新 MySQL 表。

DROP TABLE IF EXISTS cities;
CREATE TABLE cities(id INT PRIMARY KEY AUTO_INCREMENT, name VARCHAR(255),
    population INT);

INSERT INTO cities(name, population) VALUES('Bratislava', 432000);
INSERT INTO cities(name, population) VALUES('Budapest', 1759000);
INSERT INTO cities(name, population) VALUES('Prague', 1280000);
INSERT INTO cities(name, population) VALUES('Warsaw', 1748000);
INSERT INTO cities(name, population) VALUES('Los Angeles', 3971000);
INSERT INTO cities(name, population) VALUES('New York', 8550000);
INSERT INTO cities(name, population) VALUES('Edinburgh', 464000);
INSERT INTO cities(name, population) VALUES('Berlin', 3671000);

这是创建 cities 表的 SQL 语句。

mysql> use testdb;
mysql> source cities_mysql.sql

使用 source 命令，我们执行 SQL 语句。

Spring Boot MySQL 示例

以下应用程序是一个简单的 Spring Boot Web 应用程序，它使用 MySQL 数据库。我们有一个主页，其中包含一个用于显示来自数据库表的数据的链接。我们使用 Mustache 模板系统将数据与 HTML 结合起来。

build.gradle
...
src
├── main
│   ├── java
│   │   └── com
│   │       └── zetcode
│   │           ├── Application.java
│   │           ├── controller
│   │           │   └── MyController.java
│   │           ├── model
│   │           │   └── City.java
│   │           ├── repository
│   │           │   └── CityRepository.java
│   │           └── service
│   │               ├── CityService.java
│   │               └── ICityService.java
│   └── resources
│       ├── application.properties
│       ├── static
│       │   └── index.html
│       └── templates
│           └── showCities.mustache
└── test
    ├── java
    └── resources

这是项目结构。

plugins {
    id 'org.springframework.boot' version '3.1.1'
    id 'io.spring.dependency-management' version '1.1.0'
    id 'java'
}

group = 'com.zetcode'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '17'

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.springframework.boot:spring-boot-starter-mustache'
    runtimeOnly 'mysql:mysql-connector-java'
}

Spring Boot 启动器是一组方便的依赖描述符，它们极大地简化了应用程序配置。spring-boot-starter-web 是一个用于构建 Web 应用程序（包括 RESTful 应用程序）的启动器，它使用 Spring MVC。

spring-boot-starter-mustache 是一个用于构建使用 Mustache 视图的 MVC Web 应用程序的启动器。spring-boot-starter-data-jpa 是一个用于使用 Spring Data JPA 和 Hibernate 的启动器。

mysql-connector-java 依赖项用于 MySQL 数据库驱动程序。

spring.main.banner-mode=off
logging.level.org.springframework=ERROR

spring.datasource.url=jdbc:mysql://:3306/testdb?serverTimezone=UTC
spring.datasource.username=user12
spring.datasource.password=s$cret

spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQLDialect

在 application.properties 文件中，我们编写了 Spring Boot 应用程序的各种配置设置。使用 spring.main.banner-mode 属性，我们关闭了 Spring 标语。使用 logging.level.org.springframework，我们将 spring 框架的日志级别设置为 ERROR。在 spring 数据源属性中，我们设置 MySQL 数据源。我们还设置了 Hibernate 方言。

package com.zetcode.model;

import java.util.Objects;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.Table;

@Entity
@Table(name = "cities")
public class City {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    private String name;
    private int population;

    public City() {
    }

    public City(Long id, String name, int population) {
        this.id = id;
        this.name = name;
        this.population = population;
    }

    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public int getPopulation() {
        return population;
    }

    public void setPopulation(int population) {
        this.population = population;
    }

    @Override
    public int hashCode() {
        int hash = 7;
        hash = 79 * hash + Objects.hashCode(this.id);
        hash = 79 * hash + Objects.hashCode(this.name);
        hash = 79 * hash + this.population;
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final City other = (City) obj;
        if (this.population != other.population) {
            return false;
        }
        if (!Objects.equals(this.name, other.name)) {
            return false;
        }
        return Objects.equals(this.id, other.id);
    }

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("City{");
        sb.append("id=").append(id);
        sb.append(", name='").append(name).append('\'');
        sb.append(", population=").append(population);
        sb.append('}');
        return sb.toString();
    }
}

这是 City 实体。每个实体都必须至少定义两个注解：@Entity 和 @Id。

@Entity
@Table(name = "cities")
public class City {

@Entity 注解指定该类是一个实体，并映射到一个数据库表，而 @Table 注解指定要用于映射的数据库表的名称。

@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;

实体的主键使用 @Id 注解指定。 @GeneratedValue 提供了一种生成主键值的方法。

package com.zetcode.repository;

import com.zetcode.model.City;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface CityRepository extends CrudRepository<City, Long> {

}

通过扩展 Spring CrudRepository，我们将为我们的数据存储库实现一些方法，包括 findAll。 通过这种方式，我们节省了大量的样板代码。

package com.zetcode.service;

import com.zetcode.model.City;
import java.util.List;

public interface ICityService {

    List<City> findAll();
}

ICityService 提供了 findAll 契约方法声明，以从数据源获取所有城市。

package com.zetcode.service;

import com.zetcode.model.City;
import com.zetcode.repository.CityRepository;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class CityService implements ICityService {

    private final CityRepository repository;

    public CityService(CityRepository repository) {
        this.repository = repository;
    }

    @Override
    public List<City> findAll() {

        return (List<City>) repository.findAll();
    }
}

CityService 包含 findAll 方法的实现。 我们使用存储库从数据库检索数据。

private final CityRepository repository;

public CityService(CityRepository repository) {
    this.repository = repository;
}

CityRepository 被注入。

return (List<City>) repository.findAll();

存储库的 findAll 方法返回城市列表。

package com.zetcode.controller;

import com.zetcode.model.City;
import com.zetcode.service.ICityService;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

import java.util.List;

@Controller
public class MyController {

    private final ICityService cityService;

    public MyController(ICityService cityService) {
        this.cityService = cityService;
    }

    @GetMapping("/cities")
    public String findCities(Model model) {

        var cities = (List<City>) cityService.findAll();

        model.addAttribute("cities", cities);

        return "showCities";
    }
}

MyController 类使用 @Controller 注解。

private final ICityService cityService;

public MyController(ICityService cityService) {
    this.cityService = cityService;
    }

我们将 ICityService 注入到 cityService 字段中。

@GetMapping("/cities")
public String findCities(Model model) {

    var cities = (List<City>) cityService.findAll();

    model.addAttribute("cities", cities);

    return "showCities";
}

我们将 /cities 路径的请求映射到控制器的 findCities 方法。 @GetMapping 注解将 GET 请求映射到该方法。 模型获得一个城市列表，并且处理被发送到 showCities.mustache Mustache 模板文件。

<!DOCTYPE html>
<html lang="en">
<head>
    <title>Cities</title>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
</head>
<body>
<h2>List of cities</h2>

<table>
    <tr>
        <th>Id</th>
        <th>Name</th>
        <th>Population</th>
    </tr>

    {{#cities}}
    <tr>
        <td>{{id}}</td>
        <td>{{name}}</td>
        <td>{{population}}</td>
    </tr>
    {{/cities}}

</table>
</body>
</html>

在 showCities.mustache 模板文件中，我们在 HTML 表格中显示数据。

<!DOCTYPE html>
<html lang="en">

<head>
    <title>Home page</title>
    <meta charset="UTF-8"/>
    <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
</head>

<body>
<a href="/cities">Show cities</a>
</body>

</html>

在 index.html 中，有一个链接用于显示所有城市。

package com.zetcode;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

Application 设置了 Spring Boot 应用程序。@SpringBootApplication 启用了自动配置和组件扫描。

$ ./gradlew bootRun

运行应用程序后，我们可以导航到 localhost:8080。

在本文中，我们展示了如何在 Spring Boot 应用程序中使用 MySQL 数据库。

作者

我的名字是 Jan Bodnar，我是一个充满激情的程序员，拥有丰富的编程经验。自 2007 年以来，我一直在撰写编程文章。到目前为止，我已经撰写了 1,400 多篇文章和 8 本电子书。我拥有超过十年的编程教学经验。

列出 所有 Spring Boot 教程。