Spring Boot JPA

2025 年 1 月 17 日 | 9 分钟阅读

什么是 JPA？

Spring Boot JPA 是一个 Java 规范，用于管理 Java 应用程序中的关系型数据。它允许我们在 Java 对象/类和关系型数据库之间访问和持久化数据。JPA 遵循对象-关系映射（ORM）。它是一组接口。它还提供了一个运行时 EntityManager API，用于处理针对数据库的对象的查询和事务。它使用平台无关的面向对象查询语言 JPQL（Java 持久化查询语言）。

在持久化方面，它涵盖三个领域

Java 持久化 API
对象-关系元数据
API 本身，定义在 persistence 包中

JPA 不是一个框架。它定义了一个可以由任何框架实现的理念。

我们为什么要使用 JPA？

JPA 比 JDBC、SQL 和手写映射更简单、更清晰、更省力。JPA 适用于非性能导向的复杂应用程序。JPA 相对于 JDBC 的主要优点是，在 JPA 中，数据由对象和类表示，而在 JDBC 中，数据由表和记录表示。它使用 POJO 来表示持久化数据，从而简化了数据库编程。JPA 还有其他一些优点

JPA 避免了在数据库特定 SQL 方言中编写 DDL。相反，它允许在 XML 中或使用 Java 注解进行映射。
JPA 允许我们避免在数据库特定 SQL 方言中编写 DML。
JPA 允许我们完全不使用任何 DML 语言来保存和加载 Java 对象和图。
当我们需要执行 JPQL 查询时，它允许我们以 Java 实体而不是（原生）SQL 表和列来表达查询。

JPA 特性

JPA 具有以下特性

它是一个强大的仓库和自定义对象映射抽象。
它支持跨存储持久化。这意味着一个实体可以部分存储在 MySQL 和 Neo4j（图数据库管理系统）中。
它根据查询方法名称动态生成查询。
领域基类提供基本属性。
它支持透明审计。
可以集成自定义仓库代码。
通过自定义命名空间，易于与 Spring Framework 集成。

JPA 架构

JPA 是将业务实体存储为关系型实体的一种来源。它展示了如何将 POJO 定义为实体以及如何管理带有关系的实体。

下图描述了 JPA 的类级别架构，它描述了定义在 javax persistence 包中的 JPA 核心类和接口。JPA 架构包含以下单元

Persistence：这是一个包含静态方法的类，用于获取 EntityManagerFactory 实例。
EntityManagerFactory：它是 EntityManager 的工厂类。它创建和管理 EntityManager 的多个实例。
EntityManager：它是一个接口。它控制对象的持久化操作。它适用于 Query 实例。
Entity：实体是作为数据库记录存储的持久化对象。
Persistence Unit：它定义了一组所有实体类。在应用程序中，EntityManager 实例管理它。这组实体类表示单个数据存储中包含的数据。
EntityTransaction：它与 EntityManager 类具有一对一关系。对于每个 EntityManager，操作都由 EntityTransaction 类维护。
Query：它是一个接口，由每个 JPA 供应商实现，用于获取满足条件的关系对象。

JPA 类关系

我们上面讨论过的类和接口之间保持着关系。下图显示了类和接口之间的关系。

EntityManager 和 EntityTransaction 之间的关系是一对一的。每个 EntityManager 操作都有一个 EntityTransaction 实例。
EntityManageFactory 和 EntityManager 之间的关系是一对多的。它是一个 EntityManager 实例的工厂类。
EntityManager 和 Query 之间的关系是一对多的。我们可以使用 EntityManager 类的实例执行任意数量的查询。
EntityManager 和 Entity 之间的关系是一对多的。一个 EntityManager 实例可以管理多个实体。

JPA 实现

JPA 是一个开源 API。有各种企业供应商，如 Eclipse、RedHat、Oracle 等，它们通过在产品中添加 JPA 来提供新产品。有一些流行的 JPA 实现框架，如 Hibernate、EclipseLink、DataNucleus 等。它也称为对象-关系映射（ORM）工具。

对象-关系映射（ORM）

在 ORM 中，Java 对象到数据库表的映射，反之亦然，称为对象-关系映射。ORM 映射充当关系型数据库（表和记录）和 Java 应用程序（类和对象）之间的桥梁。

在下图中，ORM 层是一个适配器层。它将对象图的语言适配到 SQL 和关系表的语言。

ORM 层存在于应用程序和数据库之间。它转换 Java 类和对象，以便它们可以存储和管理在关系型数据库中。默认情况下，持久化的名称成为表的名称，字段成为列。一旦应用程序设置完成，每行表都对应一个对象。

JPA 版本

EJB 的早期版本使用 javax.ejb.EntityBean 接口定义了持久化层并与业务逻辑层结合。EJB 规范包含 JPA 的定义。

在引入 EJB 3.0 时，持久化层被分离并指定为 JPA 1.0（Java Persistence API）。此 API 的规范于 2006 年 5 月 11 日随 JAVA EE5 的规范一起发布，使用 JSR 220。

2019 年，JPA 更名为 Jakarta Persistence。JPA 的最新版本是 2.2。它支持以下功能

Java 8、日期和时间 API
AttributeConvertes 中的 CDI 注入
它使注解成为 @Repeatable

JPA 和 Hibernate 的区别

JPA：JPA 是一个 Java 规范，用于访问、管理和持久化 Java 对象和关系型数据库之间的数据。它是 ORM 的标准方法。

Hibernate：它是一个轻量级、开源的 ORM 工具，用于将 Java 对象存储在关系型数据库系统中。它是 JPA 的提供者。它遵循 JPA 提供的通用方法。

下表描述了 JPA 和 Hibernate 之间的区别。

JPA	Hibernate
JPA 是一个用于在 Java 应用程序中映射关系型数据的 Java 规范。	Hibernate 是一个处理数据持久化的 ORM 框架。
JPA 不提供任何实现类。	它提供实现类。
它使用平台无关的查询语言，称为 JPQL（Java 持久化查询语言）。	它使用自己的查询语言，称为 HQL（Hibernate 查询语言）。
它定义在 javax.persistence 包中。	它定义在 org.hibernate 包中。
它在各种 ORM 工具中实现，如 Hibernate、EclipseLink 等。	Hibernate 是 JPA 的提供者。
JPA 使用 EntityManager 处理数据持久化。	Hibernate 使用 Session 处理数据持久化。

Spring Boot Starter Data JPA

Spring Boot 提供了启动依赖 spring-boot-starter-data-jpa，以有效地将 Spring Boot 应用程序与关系型数据库连接。spring-boot-starter-data-jpa 内部使用 spring-boot-jpa 依赖。

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

Spring Boot JPA 示例

让我们创建一个使用 JPA 连接数据库的 Spring Boot 应用程序。在以下示例中，我们使用了内存数据库 Apache Derby。

Apache Derby：它是一个开源、嵌入式关系型数据库，完全用 Java 实现。它在 Apache License 2.0 下可用。Apache Derby 具有以下优点

易于安装、部署和使用。
基于 Java、JDBC 和 SQL 标准。
它提供了一个嵌入式 JDBC 驱动程序，允许我们将 Derby 嵌入到任何基于 Java 的解决方案中。
它还支持客户端/服务器模式，使用 Derby Network Client JDBC 驱动程序和 Derby Network Server。

Spring Boot 可以自动配置嵌入式数据库，如 H2、HSQL 和 Derby 数据库。我们不需要提供任何连接 URL。我们只需包含我们想要使用的嵌入式数据库的构建依赖项。

在 Spring Boot 中，我们只需在 pom.xml 文件中添加 Derby 依赖项，即可轻松集成 Apache Derby 数据库。

<dependency>
<groupId>org.apache.derby</groupId>
<artifactId>derby</artifactId>
<scope>runtime</scope>
</dependency>

步骤 1：打开 Spring Initializr 。

步骤 2：选择最新版本的 Spring Boot 2.3.0(SNAPSHOT)

步骤 3：提供组名称。我们提供了 com.javatpoint。

步骤 4：提供工件 ID。我们提供了 apache-derby-example。

步骤 5：添加依赖项：Spring Web、Spring Data JPA 和 Apache Derby Database。

步骤 6：单击生成按钮。当我们单击生成按钮时，它会将项目包装在一个 Jar 文件中并下载到本地系统。

步骤 7：解压 Jar 文件并将其粘贴到 STS 工作区中。

步骤 8：导入项目文件夹到 STS 中。

文件 -> 导入 -> 现有 Maven 项目 -> 浏览 -> 选择文件夹 apache-derby-example -> 完成

它需要一些时间来导入。

步骤 9：在文件夹 src/main/java 中创建一个名为 com.javatpoint.model 的包。

步骤 10：在包 com.javatpoint.model 中创建一个名为 UserRecord 的类，并执行以下操作

定义三个变量 id、name 和 email。
生成 Getter 和 Setter。
右键单击文件 -> 源 -> 生成 Getter 和 Setter
定义一个默认构造函数。
使用注解 @Entity 将类标记为实体。
使用注解 @Id 将 Id 标记为主键。

UserRecord.java

package com.javatpoint.model;
import javax.persistence.Entity;
import javax.persistence.Id;
@Entity  
public class UserRecord 
{ 
@Id  
private int id;  
private String name;  
private String email;
//default conatructor  
public UserRecord()
{
}  
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 String getEmail() 
{  
return email;  
}  
public void setEmail(String email) 
{
this.email = email;  
}  
}  

步骤 11：在文件夹 src/main/java 中创建一个名为 com.javatpoint.controller 的包。

步骤 12：在包 com.javatpoint.controller 中创建一个名为 UserController 的控制器类，并执行以下操作

使用注解 @RestController 将类标记为控制器。
使用注解 @Autowired 自动装配 UserService 类。
我们定义了两个映射，一个用于获取所有用户，另一个用于添加用户。

UserController.java

package com.javatpoint.controller;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.web.bind.annotation.RequestBody;  
import org.springframework.web.bind.annotation.RequestMapping;  
import org.springframework.web.bind.annotation.RequestMethod;  
import org.springframework.web.bind.annotation.RestController;
import com.javatpoint.model.UserRecord;
import com.javatpoint.service.UserService;
import java.util.List;  
@RestController  
public class UserController 
{  
@Autowired  
private UserService userService;   
@RequestMapping("/")  
public List<UserRecord> getAllUser()
{  
return userService.getAllUsers();  
}     
@RequestMapping(value="/add-user", method=RequestMethod.POST)  
public void addUser(@RequestBody UserRecord userRecord)
{  
userService.addUser(userRecord);  
}     
}  

步骤 13：在文件夹 src/main/java 中创建一个名为 com.javatpoint.service 的包。

步骤 14：在包 com.javatpoint.service 中创建一个名为 UserService 的服务类，并执行以下操作

使用注解 @Service 将类标记为服务。
自动装配 UserRepository
定义一个方法 getAllUsers()，它返回一个列表
定义另一个名为 addUser() 的方法，用于保存用户记录。

UserService.java

package com.javatpoint.service;  
import java.util.List;  
import java.util.ArrayList;  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Service;
import com.javatpoint.model.UserRecord;
import com.javatpoint.repository.UserRepository;  
@Service  
public class UserService 
{  
@Autowired  
private UserRepository userRepository;  
public List<UserRecord> getAllUsers()
{  
List<UserRecord>userRecords = new ArrayList<>();  
userRepository.findAll().forEach(userRecords::add);  
return userRecords;  
}  
public void addUser(UserRecord userRecord)
{  
userRepository.save(userRecord);  
}  
}  

步骤 15：在文件夹 src/main/java 中创建一个名为 com.javatpoint.repository 的包。

步骤 16：在包 com.javatpoint.repository 中创建一个名为 UserRepository 的仓库接口，并扩展 CrudRepository。

UserRepository.java

package com.javatpoint.repository;  
import org.springframework.data.repository.CrudRepository;
import com.javatpoint.model.UserRecord;  
public interface UserRepository extends CrudRepository<UserRecord, String> 
{  
}  

步骤 17：现在，打开 ApacheDerbyExampleApplication.java 文件。它在设置应用程序时默认创建。

ApacheDerbyExampleApplication.java

package com.javatpoint;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class ApacheDerbyExampleApplication 
{
public static void main(String[] args) 
{
SpringApplication.run(ApacheDerbyExampleApplication.class, args);
}
}

现在，我们已经根据要求设置了所有必要的类和包。请注意，我们没有为数据库提供任何连接 URL。完成以上所有步骤后，项目目录如下所示

让我们运行该应用程序。

步骤 18：打开 ApacheDerbyExampleApplication.java 文件并将其作为 Java 应用程序运行。

步骤 19：打开浏览器并访问 URL https://:8080/。它返回一个空列表，因为我们还没有在列表中添加任何用户。

要将用户添加到数据库，我们将使用 Postman 发送 POST 请求。

步骤 20：打开 Postman 并执行以下操作

选择 POST
访问 URL https://:8080/add-user。
单击 Body
选择 Content-Type 为 JSON (application/json)。
插入要插入数据库的数据。我们插入了以下数据

{
"id": "001",
"name": "Tom",
"email": "tom@gmail.com"
}

单击发送按钮。

当我们单击发送按钮时，它显示 Status:200 OK。这意味着请求已成功执行。

步骤 21：打开浏览器并访问 URL https://:8080。它返回我们已插入数据库的用户。

下载 Apache Derby 示例项目

下一个主题Spring Boot JDBC

← 上一个下一个 →

我们提供所有技术（如 Java 教程、Android、Java 框架）的教程和面试问题

联系信息

G-13, 2nd Floor, Sec-3, Noida, UP, 201301, India

hr@tpointtech.com

+91-9599086977

关注我们

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Spring Boot 教程

创建项目

项目组件

Tool Suite

Spring Boot AOP

Spring Boot 数据库

Spring Boot 视图

SB 缓存

Spring Boot 其他

Spring Boot - RESTful

Spring 教程

Spring Cloud

Spring 微服务

面试题

Spring Boot JPA

什么是 JPA？

我们为什么要使用 JPA？

JPA 特性

JPA 架构

JPA 类关系

JPA 实现

对象-关系映射（ORM）

JPA 版本

JPA 和 Hibernate 的区别

Spring Boot Starter Data JPA

Spring Boot JPA 示例

相关帖子

Spring Boot H2 数据库

Spring Boot JDBC 示例

Spring Boot CRUD 操作

Spring Boot JDBC

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器