当前位置：首页 > article >正文

十八：Spring Boot 依赖（3）-- spring-boot-starter-data-jpa 依赖详解

article 2024/11/13 17:58:43

1. 理解 JPA（Java Persistence API）

1.1 什么是 JPA？

1.2 JPA 与 Hibernate 的关系

1.3 JPA 的基本注解：@Entity, @Table, @Id, @GeneratedValue

1.4 JPA 与数据库表的映射

2. Spring Data JPA 概述

2.1 什么是 Spring Data JPA？

2.2 spring-boot-starter-data-jpa 的作用

2.3 配置 spring-boot-starter-data-jpa 依赖

3. Spring Boot 和 JPA 整合案例

3.1 创建一个基本的 CRUD Web 应用

3.2 Spring Boot 集成 JPA 的实践

3.2.1 引入基本的 Spring Data JPA 依赖

3.2.2 引入数据库连接池（默认使用 HikariCP）推荐默认的就行

使用 DBCP2 连接池

使用 C3P0 连接池

3.2.3 数据库驱动

3.2.4 配置 application.properties 或 application.yml

4. 实体类与数据库表映射

4.1 数据库建表语句

4.2 创建一个 JPA 实体类

4.2 使用 JPA 的基本类型映射（如：@Column, @OneToMany, @ManyToOne 等）

JPA 提供了许多注解来描述实体类与数据库表之间的关系，包括对列、主键、关系的映射。

4.2.1 @Column

4.2.2 @ManyToOne 和 @OneToMany

4.2.3 @OneToOne

4.2.4 @ManyToMany

5. Spring Data JPA Repository

5.1 JpaRepository 和 CrudRepository 接口

5.1.1 CrudRepository 接口

5.1.2 JpaRepository 接口（推荐，实现的多）

5.2 创建 Repository 接口

5.3 常用的 CRUD 操作（保存、查询、删除、更新）

5.4 自定义查询方法（如：通过方法名自动生成查询）

5.5 使用 @Query 注解编写自定义 SQL 查询

5.5.1 使用 JPQL（推荐方式）

5.5.2 使用原生 SQL

5.5.3 使用 @Modifying 和 @Transactional 进行更新/删除操作

6. JPA 查询功能

6.1 JPQL查询

6.2 Criteria API（动态查询）

6.3 使用 Spring Data JPA 提供的分页与排序功能

6.3.1 分页

6.3.2 排序

7. 事务管理

7.1 什么是事务？

7.2 Spring 的事务管理基础

7.3 使用 @Transactional 注解

7.4 事务的传播行为和隔离级别

7.5 事务回滚机制

8. 配置与优化

8.1 配置数据源（DataSource）

8.2 使用 application.properties 配置数据库连接池

8.3 配置 JPA 的 Hibernate 属性（如：DDL 自动生成策略、SQL 日志输出等）

8.3.1 配置 Hibernate 的 DDL 自动生成策略

8.3.2 配置 Hibernate 的 SQL 日志输出

1. 理解 JPA（Java Persistence API）
- 1.1 什么是 JPA？
  - JPA（Java Persistence API）是 Java 平台的一部分，专门用于简化 Java 应用程序与关系型数据库之间的交互。它定义了一种标准的方式来映射 Java 对象到数据库表，同时提供了操作数据库（增、删、改、查）的接口，支持对象关系映射（ORM）。JPA 作为一种规范，定义了如何在 Java 应用程序中实现持久化，但并没有提供具体的实现。
    
    JPA 的实现可以有多个，其中最常见的实现是 Hibernate，但也有其他实现，如 EclipseLink、OpenJPA 等。
- 1.2 JPA 与 Hibernate 的关系
  - Hibernate 是一个非常流行的 JPA 实现。它是一个开源的 ORM 框架，遵循了 JPA 的规范，并提供了一些额外的功能，比如自动生成 SQL、缓存机制等。简单来说，Hibernate 实现了 JPA 规范，它可以作为 JPA 的一个持久化提供者。
  - JPA 是一个规范，它规定了 Java 对象和关系型数据库之间的映射规则以及操作数据库的 API。
  - Hibernate 是一个实现，它提供了具体的代码来执行 JPA 规范中定义的操作。
  - 例如，你可以使用 Hibernate 来实现 JPA 标准的接口，或者直接使用 Hibernate 提供的扩展功能。JPA 的目标是解耦持久化层，使得应用程序不依赖于某一个具体的实现，而是遵循 JPA 规范，便于切换实现。
- 1.3 JPA 的基本注解：@Entity, @Table, @Id, @GeneratedValue
  - 在 JPA 中，注解是实现对象关系映射的关键。常见的注解包括：
  - @Entity：标识一个类是一个实体类，表示该类的实例将会与数据库中的一条记录映射。每个 @Entity 注解的类对应数据库中的一张表。
    - ```
    @Entity
    public class User {
        // 类体
    }
```
- @Table：指定数据库表的名称。如果不使用该注解，默认情况下，实体类的名字将会被用作表名。通过 @Table 可以自定义表名以及其他表级别的配置（如 schema、catalog 等）。
  - ```
  @Entity
  @Table(name = "users")
  public class User {
      // 类体
  }
```
  - @Id：指定实体类的主键字段。每个实体类必须至少有一个主键字段，JPA 使用该字段来唯一标识实体类的对象。
    - ```
    @Entity
    public class User {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long id;
        // 其他字段
    }
```
- @GeneratedValue：指定主键的生成策略。通常与 @Id 一起使用，表示主键的值如何自动生成。可以选择不同的生成策略，如 AUTO、IDENTITY、SEQUENCE 等。
  - GenerationType.AUTO：JPA 容器根据数据库的不同选择合适的生成策略。
  - GenerationType.IDENTITY：通过数据库的自增列生成主键值。
  - GenerationType.SEQUENCE：使用数据库序列生成主键值（通常用于数据库支持序列的情况）。
  - GenerationType.TABLE：使用一个特殊的数据库表来生成主键（这种方式比较少见）。
  - ```
  @Entity
  public class User {
      @Id
      @GeneratedValue(strategy = GenerationType.IDENTITY)
      private Long id;
      // 其他字段
  }
```
- 1.4 JPA 与数据库表的映射
  - JPA 将 Java 对象（类）和数据库表之间进行映射，这种映射关系主要由注解和配置来定义。JPA 实现了对象关系映射（ORM），它能够将数据库中的记录转换为 Java 对象，并允许开发人员通过操作对象来间接操作数据库。
  - 常见的映射关系如下：
    - 一对一关系（@OneToOne）：一个实体对应另一个实体的一个实例。
    - 一对多关系（@OneToMany）：一个实体对应多个实体。
    - 多对一关系（@ManyToOne）：多个实体对应一个实体。
    - 多对多关系（@ManyToMany）：多个实体对应多个实体。
  - 举个例子，假设我们有一个 User 实体类和一个 Address 实体类，一个用户可能有多个地址（多对一关系），那么我们可以使用 @OneToMany 和 @ManyToOne 来进行映射：
  - ```
  @Entity
  public class User {
      @Id
      @GeneratedValue(strategy = GenerationType.IDENTITY)
      private Long id;
      
      @OneToMany(mappedBy = "user")
      private List<Address> addresses;
      
      // 其他字段和方法
  }
  
  @Entity
  public class Address {
      @Id
      @GeneratedValue(strategy = GenerationType.IDENTITY)
      private Long id;
      
      @ManyToOne
      @JoinColumn(name = "user_id")
      private User user;
      
  }
```
2. Spring Data JPA 概述
- 2.1 什么是 Spring Data JPA？
  - Spring Data JPA 是 Spring Data 项目的一个子项目，它简化了基于 JPA（Java Persistence API）进行数据库操作的开发。Spring Data JPA 基于 JPA 规范，结合 Spring 的优势，提供了对 JPA 持久化技术的简化支持，特别是在 Spring Boot 应用中使用时，极大地减少了样板代码（boilerplate code）。
    
    Spring Data JPA 通过提供一个简单的接口 JpaRepository 和一些其他的 CRUD 接口，使开发者可以轻松实现对数据库的基本操作，如增、删、改、查等，而无需编写实现代码。它通过动态代理技术，自动生成实现类，简化了开发过程。
    
    核心特性：
    - 简化 CRUD 操作：无需编写实现代码，直接通过继承接口来使用常见的数据库操作。
    - 基于 JPA：继承了 JPA 的标准特性，如实体类映射、查询方法等。
    - 查询方法自动生成：Spring Data JPA 根据方法名自动生成 SQL 查询，无需手写 SQL。
    - 分页和排序支持：内置分页、排序功能，支持复杂的查询。
- 2.2 spring-boot-starter-data-jpa 的作用
  - spring-boot-starter-data-jpa 是 Spring Boot 提供的一个启动器（starter），用于集成和配置 Spring Data JPA。在应用中引入该依赖后，Spring Boot 会自动配置与 JPA 相关的 Bean，简化了 JPA 的配置和初始化工作。
  - 作用：
    - 自动配置数据源（DataSource）、JPA 相关的配置（如 EntityManagerFactory）、事务管理器（PlatformTransactionManager）等。
    - 集成常见的 JPA 实现（如 Hibernate），并提供简单的配置方式。
    - 支持自动创建数据库表和执行初始化 SQL（根据 spring.jpa.hibernate.ddl-auto 配置项）。
    - 提供分页、排序等功能，结合 Spring Data JPA 的接口，可以非常方便地执行复杂查询。
  - 自动配置：
    - 配置数据库连接、实体类管理、事务管理等。
    - 使用 JpaRepository 等接口简化持久化操作。
- 2.3 配置 spring-boot-starter-data-jpa 依赖
  - 要在 Spring Boot 项目中使用 Spring Data JPA，首先需要在项目的 pom.xml 文件中添加 spring-boot-starter-data-jpa 依赖。这个依赖会自动引入 Spring Data JPA 和 Hibernate 等相关库。
  - 在 pom.xml 中添加 spring-boot-starter-data-jpa 依赖。
    - ```
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
```

3. Spring Boot 和 JPA 整合案例

3.1 创建一个基本的 CRUD Web 应用

3.2 Spring Boot 集成 JPA 的实践

3.2.1 引入基本的 Spring Data JPA 依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

3.2.2 引入数据库连接池（默认使用 HikariCP）推荐默认的就行
- Spring Boot 默认使用 HikariCP 作为连接池，它不需要额外的依赖。如果你使用的是 HikariCP，你不需要手动添加依赖，因为它已经包含在 Spring Boot 的默认配置中。
- 如果你需要使用其他连接池（例如 DBCP2 或 C3P0），可以选择手动添加相应的依赖：
  - 使用 DBCP2 连接池
    - ```
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-dbcp2</artifactId>
    </dependency>
```
- 使用 C3P0 连接池
  - ```
  <dependency>
      <groupId>com.mchange</groupId>
      <artifactId>c3p0</artifactId>
  </dependency>
```
3.2.3 数据库驱动
- 根据你使用的数据库，你需要添加相应的数据库驱动。例如，假设你使用 MySQL，你需要添加 MySQL 驱动：
- ```
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
```

3.2.4 配置 `application.properties` 或 `application.yml`

application.properties

# 数据库配置
spring.datasource.url=jdbc:mysql://localhost:3306/lirui?useSSL=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# 使用HikariCP作为连接池（Spring Boot默认使用HikariCP）
spring.datasource.hikari.maximum-pool-size=10
spring.datasource.hikari.minimum-idle=5

# JPA配置
spring.jpa.database-platform=org.hibernate.dialect.MySQL5Dialect
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true

application.yml

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/lirui?useSSL=false&serverTimezone=UTC
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Driver

  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
    database-platform: org.hibernate.dialect.MySQL5Dialect

  hikari:
    maximum-pool-size: 10
    minimum-idle: 5

4. 实体类与数据库表映射
- 4.1 数据库建表语句
  - ```
  CREATE TABLE `users` (
    `id` int(11) NOT NULL AUTO_INCREMENT,
    `name` varchar(255) NOT NULL,
    `email` varchar(255) NOT NULL,
    PRIMARY KEY (`id`)
  ) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4;
```
- 4.2 创建一个 JPA 实体类
  - ```
  package com.lirui.springbootmoduledemo.dao;
  
  
  import javax.persistence.*;
  
  @Entity  // 标识该类为一个 JPA 实体类
  @Table(name = "users")  // 映射到数据库中的 users 表
  public class User {
  
      @Id  // 主键标识
      @GeneratedValue(strategy = GenerationType.IDENTITY)  // 自增主键
      @Column(name = "id")  // 映射到数据库中的 id 列
      private Integer id;
  
      @Column(name = "name", nullable = false, length = 255)  // 映射到 name 列
      private String name;
  
      @Column(name = "email", nullable = false, length = 255)  // 映射到 email 列
      private String email;
  
      // Getter 和 Setter 方法
      public Integer getId() {
          return id;
      }
  
      public void setId(Integer id) {
          this.id = id;
      }
  
      public String getName() {
          return name;
      }
  
      public void setName(String name) {
          this.name = name;
      }
  
      public String getEmail() {
          return email;
      }
  
      public void setEmail(String email) {
          this.email = email;
      }
  
      @Override
      public String toString() {
          return "User{" +
                  "id=" + id +
                  ", name='" + name + '\'' +
                  ", email='" + email + '\'' +
                  '}';
      }
  }
```
- @Entity：声明 User 类是一个 JPA 实体类，Spring Data JPA 会根据该类生成对应的数据库表操作。
- @Table(name = "users")：指定实体类对应的数据库表名为 users。如果类名与表名相同，可以省略这个注解。
- @Id：标识该字段是实体的主键（id 字段）。
- @GeneratedValue(strategy = GenerationType.IDENTITY)：指定主键的生成策略为 IDENTITY，表示使用数据库的自增机制。适用于 MySQL 等数据库。
- @Column(name = "column_name")：映射实体类字段到数据库表中的列（如 name、email）。使用 nullable = false 来指定列不允许为 NULL，并且可以设置列的最大长度（如 length = 255）。
- Integer 类型的 id 字段：我们将 id 定义为 Integer 类型，这样它可以自动与数据库中的 int 类型映射。如果你更倾向于使用 Long 类型，也可以使用 Long 类型。
- 4.2 使用 JPA 的基本类型映射（如：@Column, @OneToMany, @ManyToOne 等）
  - JPA 提供了许多注解来描述实体类与数据库表之间的关系，包括对列、主键、关系的映射。
  - 4.2.1 @Column
    - 映射实体类属性到数据库表的列。
    - 可设置属性（如：nullable、length、unique、columnDefinition 等）。
      - nullable
        
        定义列是否允许 NULL 值。
        
        默认值：true（表示列允许为 NULL）。
        
        使用场景：如果我们希望某个字段在数据库中不能为空，可以将 nullable 设置为 false，表示该列必须有值。
      - length
        
        定义字符串类型的列（如 String）的最大长度。
        
        使用场景：主要用于设置数据库中 VARCHAR 类型的字段的最大长度。如果没有显式设置，默认长度为 255。
        
        适用类型：String、char 和 Character 类型。
      - unique
        
        功能：指定列是否应该是唯一的。
        
        默认值：false（表示列不要求唯一）。
        
        使用场景：如果我们希望某个字段的值在数据库中是唯一的，可以设置 unique = true，表示该列的值在数据库表中必须是唯一的。
      - columnDefinition
        
        功能：指定列的具体定义，包括数据类型、默认值、约束等。
        
        使用场景：当我们需要对列进行更精细的控制，例如设置数据库列的数据类型、默认值、约束条件等时，可以使用 columnDefinition。它允许你直接写 SQL 语句来控制列的定义。
        
        @Column(columnDefinition = "VARCHAR(100) NOT NULL DEFAULT 'Unknown'") private String username;
      - name
        
        定义数据库中列的名称。如果不设置，默认使用字段名。
      - insertable
        
        指定是否允许在插入时写入该列。默认值是 true。
      - updatable
        
        指定是否允许更新该列。默认值是 true。
      - precision 和 scale
        
        主要用于 BigDecimal 类型，用于定义列的精度和小数位数。
  - 4.2.2 @ManyToOne 和 @OneToMany
    - @ManyToOne：表示多对一的关系。例如，一个用户有多个订单，但每个订单只能属于一个用户。
    - @OneToMany：表示一对多的关系。例如，一个用户可以有多个订单。
    - ```
    import javax.persistence.Entity;
    import javax.persistence.Id;
    import javax.persistence.OneToMany;
    import java.util.List;
    
    @Entity
    @Table(name = "user")
    public class User {
    
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long id;
    
        private String username;
    
        @OneToMany(mappedBy = "user")  // 通过 user 字段映射到 Order
        private List<Order> orders;  // 一对多关系
    
        // Getter 和 Setter
    }
```
```
    import javax.persistence.Entity;
    import javax.persistence.Id;
    import javax.persistence.ManyToOne;
    
    @Entity
    @Table(name = "order")
    public class Order {
    
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long id;
    
        private String productName;
    
        @ManyToOne  // 多对一关系
        @JoinColumn(name = "user_id")  // 映射外键
        private User user;  // 每个订单对应一个用户
    
        // Getter 和 Setter
    }
```
- 4.2.3 @OneToOne
  - 如果实体之间存在一对一关系，可以使用 @OneToOne 注解。
```
  @Entity
  public class Profile {
  
      @Id
      @GeneratedValue(strategy = GenerationType.IDENTITY)
      private Long id;
  
      private String bio;
  
      @OneToOne
      @JoinColumn(name = "user_id")  // 外键字段
      private User user;  // 一对一关系
  
      // Getter 和 Setter
  }
```
- 4.2.4 @ManyToMany
  - 如果两个实体之间存在多对多的关系，可以使用 @ManyToMany 注解。
```
  @Entity
  public class Course {
  
      @Id
      @GeneratedValue(strategy = GenerationType.IDENTITY)
      private Long id;
  
      private String name;
  
      @ManyToMany
      @JoinTable(
          name = "course_student", 
          joinColumns = @JoinColumn(name = "course_id"), 
          inverseJoinColumns = @JoinColumn(name = "student_id")
      )
      private List<Student> students;
  
      // Getter 和 Setter
  }
```