简介：JPA（Java Persistence API）是Java平台用于对象关系映射（ORM）的标准，它简化了对象与关系数据库之间的映射和操作。本文通过一个完整的例子，介绍了如何使用JPA进行创建、读取、更新和删除（CRUD）等基础数据库操作。重点包括实体的定义、 EntityManager 的使用、事务管理，以及JPA的高级功能，如JPQL和Criteria查询。这些操作的实战将有助于开发者更高效地开发Java应用程序，并实现数据的持久化管理。
1. JPA核心概念和术语解释
Java持久性API（JPA）是Java企业版（Java EE）的一部分，为对象关系映射提供了标准化的解决方案。理解JPA的核心概念和术语对于深入学习和应用JPA至关重要。以下是JPA中几个关键概念和术语的简要解释：
实体（Entity）
实体是JPA中表示数据的Java类，这些类映射到数据库中的表。实体类通常通过注解 @Entity 标记，并且必须有一个主键 @Id 。
持久化上下文（Persistence Context）
持久化上下文是管理实体实例生命周期的环境。在这个上下文中，实体实例从瞬态变为持久态，反之亦然。JPA提供者负责管理这个上下文。
实体管理器（EntityManager）
实体管理器是JPA中的主要接口，用于对实体实例进行持久化操作。它负责处理实体的查找、创建、更新和删除等操作。
理解这些基本概念将为学习后续章节中更深入的JPA话题奠定坚实的基础。在第2章中，我们将深入探讨实体的定义和映射策略，进一步了解如何在代码中实现这些概念。
2. 实体定义与映射策略
2.1 实体类的基本概念
2.1.1 实体类定义规则
在Java Persistence API (JPA) 中，实体类是一个关键的概念，代表了数据库中的表，并且被 @Entity 注解标记。要定义一个实体类，必须遵守以下规则：
- 实体类必须是一个公共类。
- 实体类的名称应该是一个名词，清晰地描述它所代表的业务实体。
- 每个实体类都必须有一个无参构造函数。
- 实体类的属性通常需要被
@Column注解来定义其在数据库表中对应的列。 - 实体类可以包含其他实体类作为属性，这称为关联实体。
import javax.persistence.Entity;
import javax.persistence.Id;
@Entity
public class User {
@Id
private Long id;
private String name;
private String email;
// Getters and Setters
}
在上述代码示例中， User 类被标记为一个实体类，并且包含三个字段： id , name , 和 email 。每个字段都有相应的getter和setter方法，尽管在现代Java应用中，使用Lombok注解 @Data 可以自动生成这些方法，从而减少样板代码。
2.1.2 实体类的生命周期
实体类的生命周期涵盖了从创建到销毁的整个过程，分为以下几个阶段：
- 新建（New） ：实体对象被创建后，处于新建状态，还未与任何持久化上下文关联。
- 托管（Managed） ：当实体对象被
EntityManager管理时，它处于托管状态。此时，任何对实体对象的改变都会在事务提交时同步到数据库。 - 游离（Detached） ：实体对象从持久化上下文中分离出来后，就处于游离状态。游离实体的改变不会自动同步到数据库。
- 移除（Removed） ：实体对象被从持久化上下文中删除后，就处于移除状态。在事务提交时，对应的数据库记录将被删除。
生命周期的管理是通过 EntityManager 的API进行的，包括 persist() , merge() , remove() , 和 find() 等方法。理解实体生命周期对于编写高质量的持久化代码至关重要。
2.2 映射策略详解
2.2.1 基本映射类型
在JPA中，实体的属性可以映射到数据库表的列。基本映射类型通常是指简单数据类型的映射，例如字符串、数字、日期等。每个属性可以通过 @Column 注解来指定列名、长度、是否允许为空等信息。例如：
@Column(name = "user_name", nullable = false, length = 50)
private String name;
这段代码将 name 属性映射到名为 user_name 的数据库列，并且指定了这个列不允许为空，长度为50。
2.2.2 复合映射类型
复合映射类型涉及更复杂的数据结构，如枚举类型、嵌套类和映射集合。例如，如果一个用户实体拥有一个地址对象作为其属性，那么这个地址对象就需要被映射为多个列。
public class Address {
@Column(name = "street")
private String street;
@Column(name = "city")
private String city;
// Getters and Setters
}
@Entity
public class User {
@Id
private Long id;
private String name;
@Embedded
private Address address;
// Getters and Setters
}
在这个例子中， Address 类通过 @Embedded 注解被嵌入到 User 实体中，表明 Address 是一个复合类型。
2.2.3 表关系映射
实体间的关系是通过映射关系注解如 @OneToOne , @OneToMany , @ManyToOne , 和 @ManyToMany 来实现的。关系映射的目的是定义实体之间的各种关系。
@Entity
public class Order {
@Id
private Long id;
@OneToOne
private User user;
// Getters and Setters
}
@Entity
public class User {
@Id
private Long id;
@OneToMany(mappedBy = "user")
private List<Order> orders;
// Getters and Setters
}
在上述例子中， Order 和 User 通过 @OneToOne 注解映射为一对一关系。 Order 实体中有一个指向 User 实体的字段，而 User 实体有一个 List<Order> 类型的字段，用来存储这个用户的所有订单。
接下来的章节将继续深入探讨如何使用 EntityManager 和 EntityTransaction 进行实体操作，以及如何实现基本的CRUD（创建、读取、更新、删除）操作。
3. EntityManager 和 EntityTransaction 的使用
3.1 EntityManager 的管理与操作
3.1.1 EntityManager 的基本操作
EntityManager 是JPA中最重要的接口之一，它负责管理实体的生命周期，处理实体的持久化操作。开发者可以通过 EntityManager 接口提供的方法与持久化上下文进行交互。
创建和关闭 EntityManager 是使用JPA的基本步骤。我们通过 EntityManagerFactory 来获取 EntityManager 的实例。一旦完成操作，我们需要关闭 EntityManager 以释放其持有的资源。下面是创建和关闭 EntityManager 的示例代码：
EntityManager entityManager = entityManagerFactory.createEntityManager();
try {
// 执行业务逻辑和数据库操作
entityManager.getTransaction().begin();
// ... 业务代码 ...
entityManager.getTransaction().commit();
} finally {
entityManager.close();
}
参数说明：
-
entityManagerFactory.createEntityManager(): 通过EntityManagerFactory创建一个新的EntityManager实例。 -
entityManager.getTransaction().begin(): 开启一个新的事务。 -
entityManager.getTransaction().commit(): 提交当前事务，如果事务成功完成则保存更改。 -
entityManager.close(): 关闭EntityManager实例，释放资源。
3.1.2 EntityManager 的状态管理和作用域
EntityManager 的生命周期管理包括实体状态的同步和持久化上下文的管理。每个 EntityManager 实例都有自己的持久化上下文，这是一个实体状态的缓存区域。实体状态分为三种：新建(new)、托管(managed)和分离(detached)状态。
- 新建(new)：实体实例被创建，但还没有与任何持久化上下文关联。
- 托管(managed)：实体实例与持久化上下文关联，可以追踪实体状态的变化。
- 分离(detached)：实体实例之前托管于持久化上下文，但现在不再关联。
EntityManager 的作用域决定了其持久化上下文的边界，而持久化上下文边界决定了事务的边界。通常， EntityManager 的作用域应与事务范围一致，即在事务开始时创建 EntityManager ，事务结束时关闭它。
3.2 EntityTransaction 事务管理
3.2.1 事务的概念与属性
事务是一组操作的集合，它们作为一个整体一起成功或失败。在JPA中，事务由 EntityTransaction 接口管理，它提供了控制事务边界的方法。事务具有四个基本属性：原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）和持久性（Durability），通常称为ACID属性。
- 原子性保证事务中的所有操作要么全部完成，要么全部不完成。
- 一致性确保事务完成时，数据的一致状态不会被破坏。
- 隔离性意味着并发执行的事务是互相隔离的，一个事务的中间状态不会对其他事务可见。
- 持久性保证一旦事务提交，其所做的更改就会永久保存到数据库中。
3.2.2 事务边界和隔离级别
事务边界由 EntityTransaction 控制，一个事务的生命周期始于调用 begin() 方法开始事务，结束于调用 commit() 或 rollback() 方法。
隔离级别定义了事务执行时与其他事务隔离的程度。JPA提供了四种标准隔离级别：
-
NONE: 没有隔离，允许脏读。 -
READ_UNCOMMITTED: 允许脏读、不可重复读和幻读。 -
READ_COMMITTED: 防止脏读，但允许不可重复读和幻读。 -
REPEATABLE_READ: 防止脏读和不可重复读，但允许幻读。 -
SERIALIZABLE: 最高级别的隔离，防止脏读、不可重复读和幻读。
3.2.3 事务的传播行为
事务的传播行为指的是当一个事务方法被另一个事务方法调用时，事务如何传播。JPA定义了七种事务传播行为，其中最常用的是：
-
REQUIRED: 如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。 -
REQUIRES_NEW: 新建一个事务，如果当前存在一个事务，将当前事务挂起。 -
NESTED: 如果当前存在事务，则在这个事务的嵌套事务内执行。如果当前没有事务，则执行与REQUIRED相同的操作。
以下是事务传播行为的示例代码：
@PersistenceContext
private EntityManager entityManager;
public void doTransactionWork() {
EntityTransaction transaction = entityManager.getTransaction();
transaction.begin();
try {
// ... 执行业务逻辑 ...
// 模拟调用另一个事务性方法
doAnotherTransaction();
transaction.commit();
} catch (Exception e) {
transaction.rollback();
}
}
public void doAnotherTransaction() {
EntityTransaction transaction = entityManager.getTransaction();
transaction.begin();
try {
// ... 执行其他业务逻辑 ...
transaction.commit();
} catch (Exception e) {
transaction.rollback();
}
}
在以上代码中， doTransactionWork 方法和 doAnotherTransaction 方法都会在事务上下文中执行，但是它们的传播行为会根据方法定义的属性来决定。
代码逻辑逐行解读分析
-
@PersistenceContext: 此注解用于声明entityManager字段为持久化上下文注入点。 -
transaction.begin(): 开始一个新的事务。 -
transaction.commit(): 如果业务逻辑成功执行，提交事务，更改将被永久保存到数据库。 -
transaction.rollback(): 如果在事务中捕获到异常，回滚事务，之前的操作将不会影响数据库状态。
事务的管理是保证数据完整性和一致性的重要机制，正确使用 EntityManager 和 EntityTransaction 对开发高质量的应用程序至关重要。
注意 ：由于本章节为示例性内容，代码示例均为简化版，实际应用中需要考虑异常处理机制、资源管理等更多细节。
4. CRUD操作的实现
4.1 创建操作（Create）
4.1.1 实体状态管理和持久化
在 Java Persistence API (JPA) 中，创建操作是指将新的实体对象持久化到数据库的过程。为了深入理解这个过程，我们需要先了解实体的状态管理。实体的状态可以分为以下几种：
- 新建（New）：实体类实例刚创建，还未与
EntityManager关联。 - 管理（Managed）：实体实例与
EntityManager关联，由其负责管理。 - 游离（Detached）：实体实例之前与
EntityManager关联过，但现在没有关联。 - 移除（Removed）：实体实例与
EntityManager关联过，但已被标记为删除。
要将实体持久化，首先需要通过 EntityManager 的 persist 方法将新建状态的实体转变为管理状态，之后 JPA 就会负责将该实体数据保存到数据库。
示例代码：
EntityManager entityManager = entityManagerFactory.createEntityManager();
EntityTransaction transaction = entityManager.getTransaction();
try {
transaction.begin();
// 创建一个用户实体类实例
User newUser = new User("John", "john@example.com");
// 持久化实体，将其状态从新建转变为管理
entityManager.persist(newUser);
transaction.commit();
} catch (Exception e) {
transaction.rollback();
e.printStackTrace();
} finally {
entityManager.close();
}
代码分析：
在上述代码中，我们首先创建了一个 User 类的实例，并调用了 persist 方法，这会将用户对象的状态转变为管理状态，并将其加入持久化上下文。当事务提交时，JPA 将执行一条 INSERT SQL 语句，将用户数据保存到数据库中。
4.1.2 批量插入和性能优化
当需要向数据库插入大量实体时，逐条插入的性能开销很大，因此 JPA 提供了批量插入的支持。在批量插入操作中，使用 @BatchSize 注解可以配置批量操作的大小，这有助于提高性能。
示例代码：
@BatchSize(size = 50)
@Entity
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
// ... fields, constructors, getters, setters ...
}
代码分析：
在实体类上使用 @BatchSize 注解，可以指定每次批量操作中实体的数量。在这个例子中，我们设置了每次批量插入操作最多包含 50 条记录。
为了实现批量插入，可以使用以下代码：
List<User> users = new ArrayList<>();
for (int i = 0; i < 100; i++) {
users.add(new User("User" + i, "user" + i + "@example.com"));
if (users.size() % 50 == 0) {
entityManager.persist(users.remove(0));
}
}
// 最后一部分插入
for (User user : users) {
entityManager.persist(user);
}
// 提交事务
transaction.commit();
代码分析：
通过以上代码，我们创建了一个包含 100 个 User 实体的列表，并在列表中每50个实体进行一次批量插入。这样可以显著减少数据库的交互次数，提高插入性能。
4.2 读取操作（Read）
4.2.1 基本查询方法
读取操作是 CRUD 操作中最常见的操作之一。在 JPA 中，可以通过多种方式从数据库中检索实体对象。
1. 通过主键查询
User user = entityManager.find(User.class, 1L);
2. 基于查询语言查询
TypedQuery<User> query = entityManager.createQuery("SELECT u FROM User u WHERE u.email = :email", User.class);
query.setParameter("email", "john@example.com");
List<User> users = query.getResultList();
3. 基于 Criteria API 查询
CriteriaBuilder cb = entityManager.getCriteriaBuilder();
CriteriaQuery<User> cq = cb.createQuery(User.class);
Root<User> root = cq.from(User.class);
cq.select(root);
cq.where(cb.equal(root.get("email"), "john@example.com"));
List<User> users = entityManager.createQuery(cq).getResultList();
4.2.2 延迟加载和懒加载策略
延迟加载（Lazy Loading）是 JPA 中优化加载策略的重要概念。它允许在首次访问某个实体的属性时才进行数据库查询，而不是在实体加载时就立即进行所有相关数据的查询。
@Entity
public class Order {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@ManyToOne(fetch = FetchType.LAZY) // 懒加载
private User user;
// ... other fields, getters, setters ...
}
在上面的代码中， user 属性被标记为懒加载，这意味着直到第一次访问 user 属性（例如，调用 order.getUser().getName() ）时，才会从数据库中加载 User 实体数据。
4.3 更新操作（Update）
4.3.1 状态同步和变更检测
在 JPA 中，实体的变更检测是自动进行的。当一个实体处于管理状态时，JPA 会跟踪实体的属性变化。当事务提交时，所有被修改的属性都会自动更新到数据库。
User user = entityManager.find(User.class, 1L);
user.setEmail("newemail@example.com");
在这个例子中，我们仅仅是修改了实体的 email 属性，事务提交时，JPA 会自动执行一个 UPDATE SQL 语句来同步更新数据库中的记录。
4.3.2 乐观锁和悲观锁机制
在并发环境中，更新操作可能会遇到数据冲突问题。JPA 提供了乐观锁和悲观锁机制来处理并发冲突。
乐观锁
乐观锁通常是通过在实体中添加一个版本字段（ @Version ）来实现，每次更新操作都会检查版本号是否一致。
@Version
private int version;
当更新操作执行时，JPA 会检查版本号，如果版本号不匹配，则会抛出 OptimisticLockException 。
悲观锁
悲观锁通过获取数据库锁来避免数据冲突，通常可以使用以下方式实现：
entityManager.createQuery("SELECT u FROM User u WHERE u.id = :id FOR UPDATE")
.setParameter("id", 1L)
.getSingleResult();
代码分析：
上述查询通过 FOR UPDATE 语句在查询时就锁定了对应的数据库记录，直到事务结束才会释放锁。
4.4 删除操作（Delete）
4.4.1 删除单个实体
删除操作通常很简单，只需要获取实体的引用，然后调用 remove 方法。
User user = entityManager.find(User.class, 1L);
entityManager.remove(user);
4.4.2 批量删除和性能考量
在处理大量数据时，直接删除单个实体可能会导致性能问题，这时可以使用 JPQL 或 Criteria API 来实现批量删除。
示例代码：
entityManager.createQuery("DELETE FROM User u WHERE u.status = 'INACTIVE'")
.executeUpdate();
代码分析：
在这个例子中，我们使用 JPQL 语句直接在数据库层面执行了一个删除操作，删除所有状态为 INACTIVE 的用户。这样做可以减少应用层的内存占用，并且速度更快。
表格： CRUD 操作的对比
| 操作 | 描述 | 方法示例 |
|---|---|---|
| 创建 | 将实体保存到数据库 | entityManager.persist(user); |
| 读取 | 从数据库检索实体 | entityManager.find(User.class, 1L); |
| 更新 | 更新数据库中的实体 | user.setName("New Name"); |
| 删除 | 从数据库中删除实体 | entityManager.remove(user); |
在本章节中，我们详细介绍了 JPA 中 CRUD 操作的实现方法和相关策略，包括实体状态管理、批量操作优化以及读取、更新、删除操作的细节。希望通过以上内容，读者可以深刻理解 JPA 的 CRUD 操作，并在实际开发中运用这些知识来优化应用性能。
5. JPQL查询语言使用
JPQL（Java Persistence Query Language）是Java持久化API中用于对持久化实体进行查询的一种语言，它类似于SQL，但是是面向对象的查询语言。JPQL允许开发者以对象的方式而非数据库表的方式来编写查询语句，这样可以更灵活地处理各种复杂查询场景。
5.1 JPQL基础语法和特性
5.1.1 JPQL查询语言概述
JPQL查询语言是一种类型化的查询语言，它是在对象模型上进行操作，而不是直接在数据库表上操作。JPQL使用类名和属性名来指定要查询的数据，这些类名和属性名对应于实体类及其持久化字段。JPQL语句在运行时会转换成对应的SQL语句，由数据库执行。
一个典型的JPQL查询语句的格式如下：
TypedQuery<Type> query = entityManager.createQuery("SELECT e FROM Entity e WHERE e.property = :value", Type.class);
上面的代码中， entityManager 是 EntityManager 的一个实例。查询语句 SELECT e FROM Entity e WHERE e.property = :value 定义了一个查询，它将从 Entity 类型的实体中选择那些属性 property 等于某个值 value 的对象。
5.1.2 JPQL查询与SQL查询的区别
JPQL与SQL的主要区别在于，JPQL操作的是对象和属性，而SQL操作的是数据库表和列。下面是两者的一些主要对比点：
- 面向对象 ：JPQL完全面向对象，它允许开发者使用实体类的名称和属性进行查询。而SQL则是面向数据库表的。
- 数据库无关 ：JPQL查询是与数据库无关的，这意味着相同的JPQL查询可以在不同的数据库上执行，而无需修改。SQL查询则需要根据不同的数据库方言进行调整。
- 类型安全 ：JPQL在编译时是类型安全的，而SQL通常在运行时才进行错误检查。
5.2 JPQL高级查询技巧
5.2.1 联合查询和分组聚合
联合查询是指JPQL中可以通过连接查询来获取相关联实体的数据。分组和聚合则是指JPQL提供了类似于SQL的聚合函数，例如 COUNT , MIN , MAX , SUM , AVG 等。
例如，如果我们想要查询某个部门中所有员工的平均薪水，我们可以这样编写JPQL语句：
TypedQuery<Number> avgSalaryQuery = entityManager.createQuery("SELECT AVG(e.salary) FROM Employee e WHERE e.department = :department", Number.class);
这个查询语句会计算出指定部门中所有员工的平均薪水。
5.2.2 JPQL函数和表达式使用
JPQL提供了许多预定义的函数，可以在查询中使用，例如字符串函数、日期时间函数等。同时，JPQL允许使用表达式来执行复杂的查询逻辑。
例如，如果我们想要找出所有姓“张”的员工，可以使用 LIKE 表达式：
TypedQuery<Employee> employeesQuery = entityManager.createQuery("SELECT e FROM Employee e WHERE e.lastName LIKE :prefix", Employee.class);
employeesQuery.setParameter("prefix", "张%");
5.2.3 子查询和查询优化
JPQL支持子查询，可以嵌套在其他查询中使用，以便实现更复杂的查询逻辑。
例如，如果我们想获取薪水高于部门平均薪水的所有员工，我们可以编写如下查询：
TypedQuery<Employee> higherSalaryThanDeptAvgQuery = entityManager.createQuery(
"SELECT e FROM Employee e WHERE e.salary > (SELECT AVG(e2.salary) FROM Employee e2 WHERE e2.department = e.department)", Employee.class);
查询优化是JPQL中很重要的一部分，因为JPQL最终会转换为SQL执行。在编写JPQL查询时，应该避免产生过于复杂的查询语句，并且应该注意只查询需要的数据列，避免不必要的数据加载。
通过以上的介绍，我们可以看到JPQL提供了一种强大的方式来进行面向对象的数据库查询，它与传统的SQL相比，提供了更高的抽象层次和更好的数据库无关性。然而，开发者在使用JPQL时仍需要对其性能影响保持警惕，尤其是在涉及复杂查询和大量数据处理时。在实际应用中，应当结合具体的业务场景和数据模型，设计合理的JPQL查询语句，以达到既高效又灵活的查询效果。
6. Criteria查询的介绍
6.1 Criteria API的构建过程
6.1.1 Criteria API的基本概念
Criteria API是Java Persistence API (JPA) 中用于构建类型安全查询的一种方式。它提供了一种面向对象的查询语言，可以避免使用JPQL时常见的字符串拼接问题，从而减少运行时错误并提高代码的可维护性。
在使用Criteria API时，首先需要创建一个查询构建器（ CriteriaBuilder ），然后是查询根（ CriteriaQuery ），这使得整个查询过程变得类型安全且可编译检查。接下来，定义查询的返回类型（如实体类型、标量类型等），并构建查询条件和排序规则。
6.1.2 创建查询构建器和查询根
为了构建一个Criteria查询，我们先来看看如何获取 CriteriaBuilder 和创建 CriteriaQuery 的示例代码：
CriteriaBuilder cb = entityManager.getCriteriaBuilder();
CriteriaQuery<User> query = cb.createQuery(User.class);
上面的代码片段展示了如何为 User 实体类创建一个查询。 CriteriaBuilder 对象是从 EntityManager 获得的，它提供了用于创建查询的各种方法。 CriteriaQuery 则定义了查询的整体结构，包括返回的实体类型。
6.2 Criteria查询的动态构建
6.2.1 条件查询的构建
Criteria API允许开发者动态构建查询条件，使得查询更加灵活。这些条件可以基于实体的属性进行组合，从而形成复杂的查询逻辑。例如，我们可以基于 User 实体的 age 属性来过滤结果：
Root<User> userRoot = query.from(User.class);
Predicate agePredicate = cb.greaterThan(userRoot.get("age"), 18);
query.where(agePredicate);
在这个例子中，我们首先从 CriteriaQuery 获取到 User 实体的根引用 userRoot ，然后使用 CriteriaBuilder 的 greaterThan 方法创建了一个表示“年龄大于18岁”的 Predicate 条件。最后，这个条件被添加到查询中。
6.2.2 排序和分组的实现
除了条件过滤，Criteria API还支持对查询结果进行排序和分组。这可以让我们对数据集进行定制化的处理，以便更好地满足业务需求。例如，如果我们想按年龄升序排列用户：
query.orderBy(cb.asc(userRoot.get("age")));
如果我们需要对用户按城市分组，可以这样做：
query.groupBy(userRoot.get("city"));
6.3 Criteria与JPQL的对比
6.3.1 两者的适用场景
JPQL查询在编写上更接近于SQL语句，适合静态查询的场景，且编写起来更加直观快捷。当查询条件固定且复杂性不高时，JPQL可能是更佳的选择。
相反，Criteria API更适合动态构建查询的场景，特别是在应用中需要处理来自用户输入或配置文件的复杂查询时。由于Criteria API是类型安全的，它还能在编译阶段就捕获到潜在的错误。
6.3.2 性能比较和最佳实践
性能方面，JPQL通常会略胜一筹，因为许多JPA实现会将其优化为原生SQL执行。但是，Criteria API产生的查询通常可读性更好，并且可以在开发过程中提供更好的编译时检查。
在实际开发中，选择哪一种取决于项目需求和个人偏好。一般来说，对于需要高度定制化和动态构建的场景，推荐使用Criteria API，而在查询逻辑较为固定的情况下，JPQL可能是更优的选择。
为了进一步理解Criteria查询，接下来，我们将通过一个实际的案例来展示如何使用Criteria API进行一个完整的查询操作。
简介：JPA（Java Persistence API）是Java平台用于对象关系映射（ORM）的标准，它简化了对象与关系数据库之间的映射和操作。本文通过一个完整的例子，介绍了如何使用JPA进行创建、读取、更新和删除（CRUD）等基础数据库操作。重点包括实体的定义、 EntityManager 的使用、事务管理，以及JPA的高级功能，如JPQL和Criteria查询。这些操作的实战将有助于开发者更高效地开发Java应用程序，并实现数据的持久化管理。
扫一扫
4577
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
