JPA基础教程：实体操作和数据库交互实践

本文还有配套的精品资源，点击获取

简介：JPA是Java平台上的对象-关系映射标准，它简化了数据库操作，允许开发人员面向对象地处理关系数据库。本文将介绍JPA的基本概念，包括实体、ID、关系、监听器、持久化单元、实体管理器，并详细讨论如何通过JPA实现数据库的创建、读取、更新和删除操作。同时，文章还将探讨事务管理、查询语言、性能优化以及JPA与其他ORM框架的关系。学习掌握JPA将有助于开发人员提升效率和代码的可维护性。

1. JPA的定义和目的

Java持久化API（Java Persistence API，简称JPA）是Java EE 5.0规范的一部分，旨在提供一种标准的方式来访问和管理数据库中的数据。它允许Java开发人员以面向对象的方式操作数据，而无需关心底层的SQL语句。

JPA的主要目的是简化和标准化数据持久化层的开发，减少数据库操作代码量，提高代码的可读性和可维护性。JPA的出现使得开发者可以从复杂的数据库访问逻辑中解脱出来，更加专注于业务逻辑的实现。

通过使用JPA，开发者能够以声明性的方式处理关系数据，并利用面向对象的方法构建模型。JPA框架通过实体管理器（EntityManager）和查询语言（JPQL）等抽象层，使得与数据库的交互变得透明和高效。在下一章中，我们将深入探讨实体类的概念及其在JPA中的配置。

2. 实体类概念和配置

2.1 实体类的基本概念

2.1.1 实体类的定义

实体类（Entity Class）在JPA（Java Persistence API）中是一个核心概念。它用于将Java对象映射到数据库中的表，并且提供了对数据的操作接口。实体类通常与数据库中的表存在一一对应的关系，并且使用特定的注解来标识。

实体类的特征包括：

• 使用 @Entity 注解标记，表示这个类是一个实体类。
• 实体类需要有一个无参构造器（可以有其他构造器）。
• 实体类中的字段通常需要使用 @Basic 、 @Column 等注解来定义字段映射到数据库表的列。
• 作为实体类代表的数据库表，通常使用 @Table 注解来指定表名和其他表级别的属性。

2.1.2 实体类与数据库表的映射关系

实体类与数据库表的映射关系是通过注解或者XML配置文件实现的。其中，注解配置是最常用的方式，它直接在Java类中声明映射规则，方便阅读和维护。

映射关系包括：

• 实体类的每个属性与数据库表的列的映射关系，使用 @Column 注解来定义。
• 实体类的关联关系，如一对一、一对多、多对多，使用 @OneToOne 、 @OneToMany 、 @ManyToMany 等注解来定义。
• 主键与表中主键列的映射，使用 @Id 注解标识主键属性，同时可以配合 @GeneratedValue 注解来实现主键的自动增长。

2.2 实体类的配置

实体类的配置通常有两种方式：注解配置和XML配置。

2.2.1 注解配置方式

注解配置是通过在Java实体类上添加特定的注解来实现映射的一种方式。这种方式的优点是直接在代码中定义了所有的映射关系，使得开发者能够直观地看到实体与数据库之间的关系，提高了代码的可读性。

import javax.persistence.*;

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;
    // Getters and Setters
}

2.2.2 XML配置方式

XML配置方式是通过一个或多个XML映射文件来定义实体类与数据库表之间的映射关系。这种方式的灵活性更高，可以在XML文件中详细定义复杂的映射关系，但在大型项目中，管理起来相对麻烦，不如注解配置直观。

<?xml version="1.0" encoding="UTF-8"?>
<entity-mappings xmlns="***"
                  xmlns:xsi="***"
                  xsi:schemaLocation="***
                                  ***"
                  version="2.0">

    <entity class="com.example.User" table="users">
        <id name="id" column="id">
            <GeneratedValue(strategy="IDENTITY"/>
        </id>
        <basic(name="name">
            <column name="name"/>
        </basic>
        <basic(name="email">
            <column name="email"/>
        </basic>
    </entity>

</entity-mappings>

在实际开发中，根据团队和项目的具体需求，可以选择适合的配置方式。注解方式更受青睐，因为它更简洁，但是XML方式在处理复杂的映射关系时也显得非常有用。

3. 实体ID标识和主键映射

3.1 主键的作用与重要性

3.1.1 主键的定义

主键是数据库表中每一行记录的唯一标识，是表中记录的最基本且最重要的属性。在一个表中，主键用于确保记录的唯一性，保证数据的完整性和一致性。在实体类中，与主键相对应的属性通常被标注为 @Id ，这表明该字段作为实体的唯一标识。此外，可以为这个字段配置不同的主键生成策略，以适应不同的应用场景和性能要求。

3.1.2 主键的作用

主键的作用不仅限于标识一条记录，在关系数据库中，主键通常作为外键参照其他表，从而建立表之间的关系。对于JPA而言，主键还承担着ORM中实体与数据库表映射的关键角色。例如，当使用 EntityManager 进行持久化操作时，JPA通过主键来定位需要操作的具体记录。因此，主键的设计是否合理，直接影响到数据操作的效率和复杂度。

3.2 主键生成策略

3.2.1 自动增长策略

自动增长策略是最常见的主键生成方式之一，通常与数据库的自增字段相对应。在JPA中，可以通过 @GeneratedValue 注解并指定 GenerationType.IDENTITY 来实现。这种方式使得在插入新的记录时，数据库会自动为该记录生成一个唯一的主键值。例如：

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    // 其他字段...
}

使用自动增长策略的好处在于实现简单，对应用层透明，但可能会面临性能瓶颈，特别是在高并发情况下，数据库的自增锁会成为系统的瓶颈。

3.2.2 UUID策略

为了应对自动增长策略的局限性，JPA提供了UUID策略作为主键生成的一种选择。UUID（Universally Unique Identifier）是一个128位的标识符，由32个十六进制数字（8-4-4-4-12）组成，通常用于分布式系统中以保证唯一性。在JPA中，可以通过 @GeneratedValue 注解并指定 GenerationType.AUTO 来让底层数据库自动生成UUID值。

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private String id;
    // 其他字段...
}

使用UUID作为主键可以避免数据库的锁竞争问题，同时提高分布式系统的性能。但是，UUID通常比自增主键占用更多的存储空间，并且在排序和查询性能上可能不如数字类型。

3.2.3 序列策略

序列策略是另一种在数据库中生成唯一标识的方法，尤其适用于那些不支持自增字段的数据库系统。在JPA中，可以通过 @GeneratedValue 注解并指定 GenerationType.SEQUENCE 来使用序列策略。这要求数据库中事先创建好序列对象，JPA框架将使用这个序列来为新插入的记录生成主键值。

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "user_seq")
    @SequenceGenerator(name = "user_seq", sequenceName = "user_sequence", allocationSize = 1)
    private Long id;
    // 其他字段...
}

序列策略的优点在于它避免了锁的竞争，并且在数据库层面保证了主键生成的唯一性和原子性。但它增加了数据库的负担，因为每个插入操作都需要查询数据库序列。

表格、代码块和流程图

| 策略类型 | 优点 | 缺点 | 适用场景 | |-----------|------|------|----------| | 自动增长 | 实现简单，对应用透明 | 高并发下的性能瓶颈 | 关系型数据库系统，数据插入量不大 | | UUID | 避免锁竞争，适用于分布式系统 | 占用更多存储空间，查询性能相对较低 | 高并发，分布式系统中，对性能要求较高的场合 | | 序列 | 避免锁竞争，数据库保证唯一性 | 增加数据库负担，序列管理复杂 | 不支持自增字段的数据库系统，或者有大量数据插入操作的场景 |

mermaid流程图展示了主键生成策略的选择过程：

graph TD
    A[开始选择主键生成策略]
    A --> B{是否考虑并发}
    B -- 是 --> C[选择UUID或序列策略]
    B -- 否 --> D[选择自动增长策略]
    C --> E[评估存储空间和查询性能]
    D --> F[评估数据库自增锁竞争情况]
    E --> G[最终确定策略]
    F --> G

代码块和逻辑分析：

// 示例代码：使用自动增长策略生成主键
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

在上述代码中， @GeneratedValue 注解指定了主键的生成策略为自动增长，由数据库进行管理。 GenerationType.IDENTITY 表明主键值的生成依赖于数据库的自增机制。当插入新的记录时，数据库会自动为 id 字段赋予一个唯一值。这种方式是许多Web应用常见的主键生成方式，因为其简单易用且对开发者友好。然而，开发者必须意识到，在高并发环境下，自增锁可能会成为性能瓶颈。

4. 实体关系类型和映射

4.1 实体间关系的种类

4.1.1 一对一关系

在数据库设计中，一对一关系是一种常见的实体间关联方式，它表示两个实体之间存在一一对应的关系。在JPA中，一对一关系可以通过使用 @OneToOne 注解来实现。这种关系确保了一个实体的每个实例只能关联到另一个实体的唯一实例。

一对一关系的典型应用场景包括用户和用户详细信息、订单和订单详情等。例如，每个用户都有一个唯一的用户详细信息，而用户详细信息也只属于一个用户。

4.1.2 一对多关系

一对多关系是另一个重要的实体间关联方式，通常用来描述一对多的父子关系。在JPA中，一对多关系是通过 @OneToMany 注解来表示的。这意味着一个实体的实例可以关联到多个其他实体的实例，但这些关联的实体只能属于一个父实体。

例如，一个部门可以有多个员工，但是每个员工只能属于一个部门。在这种情况下，部门实体与员工实体之间存在一对多的关系。

4.1.3 多对多关系

多对多关系较为复杂，适用于描述实体间不存在层级关系，但一个实体的多个实例可以关联到另一个实体的多个实例的情况。在JPA中，多对多关系是通过 @ManyToMany 注解来表达的。

例如，学生和课程之间的关联就是一个典型的多对多关系。一个学生可以选修多门课程，同时一门课程也可以被多个学生选修。在数据库中，这种关系通常通过一个中间表来实现，其中包含两个外键，分别指向两个关联实体的主键。

4.2 关系映射的实现

4.2.1 使用注解实现映射

在JPA中，注解是实现关系映射的最直接和最常用的方式。通过在实体类中使用特定的注解，可以明确地定义实体间的关系。

例如，使用 @OneToOne 注解定义一对一关系时，可以这样操作：

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String username;
    @OneToOne(mappedBy="user")
    private UserDetails userDetails;
    // 省略其他代码...
}

@OneToOne 注解的 mappedBy 属性指定了关系的反向操作者，即 UserDetails 实体中负责维护这种关系的字段。

使用 @OneToMany 和 @ManyToMany 注解时，需要考虑是否需要维护双向关系。如果是双向关系，则需要在两个实体中都使用注解来声明。

4.2.2 使用XML实现映射

尽管使用注解是一种便捷的映射方式，但在某些情况下，开发者可能更倾向于使用XML配置文件来实现映射。这种方式提供了更高的灵活性，尤其是在复杂的映射场景中。

XML映射需要在 persistence.xml 配置文件中指定XML映射文件的位置：

<persistence-unit name="myUnit">
    <mapping-file>com/example/mappings/MyMappings.xml</mapping-file>
</persistence-unit>

映射文件中，可以使用 <one-to-one> , <one-to-many> , <many-to-many> 等标签来定义关系。例如，定义一对多关系的XML配置如下：

<one-to-many target-entity="com.example.OrderItem"
             mapped-by="order"/>

在上述例子中， target-entity 指定了关联的目标实体类，而 mapped-by 指定了在目标实体类中对应的关联属性名称。

接下来，为确保连贯性和完整性，我们将会深入探讨这些关系映射背后的数据库层面的逻辑，以及如何在实体管理器中使用这些映射进行CRUD操作。

5. 实体监听器和生命周期事件

JPA 实体监听器提供了一种机制，允许开发者在实体的生命周期中某些关键事件发生时执行自定义的逻辑。这种机制非常有用，可以用来进行各种操作，比如审计追踪、自动化字段赋值等。本章将详细探讨实体监听器的概念、生命周期事件的种类以及如何处理这些事件。

5.1 实体监听器的作用

5.1.1 监听器的概念

在 JPA 中，实体监听器是指一个普通的 Java 类，它可以包含与实体生命周期事件相关联的方法。这些方法会在特定的事件发生时被 JPA 提供者调用。要使用实体监听器，开发者需要在实体类上使用 @EntityListeners 注解来指定相应的监听器类。

监听器类可以包含多个方法，这些方法可以在以下事件发生时被触发： - 实体的创建和加载事件 - 实体的更新和删除事件 - 实体的附加到实体管理器事件 - 实体的从实体管理器分离事件

5.1.2 生命周期事件的种类

JPA 规范定义了几个标准的生命周期事件： - PostLoad ：在实体加载后触发。 - PrePersist ：在实体持久化前触发。 - PostPersist ：在实体持久化后触发。 - PreUpdate ：在实体更新前触发。 - PostUpdate ：在实体更新后触发。 - PreRemove ：在实体删除前触发。 - PostRemove ：在实体删除后触发。

除了这些标准事件，JPA 还允许定义应用程序特定的事件。

5.2 生命周期事件的处理

5.2.1 创建和加载事件

当实体被创建时，会触发 PrePersist 和 PostPersist 事件。同样地，当实体第一次被加载时， PostLoad 事件会被触发。这些事件常用于初始化和填充特定字段。

示例代码：

import javax.persistence.PostLoad;
import javax.persistence.PostPersist;
import javax.persistence.PrePersist;

@Entity
@EntityListeners(AuditEntityListener.class)
public class AuditEntity {
    @Id
    private Long id;

    // 其他字段和方法...

    @PrePersist
    public void prePersist() {
        // 在实体持久化前执行的代码
    }

    @PostPersist
    public void postPersist() {
        // 在实体持久化后执行的代码
    }

    @PostLoad
    public void postLoad() {
        // 在实体加载后执行的代码
    }
}

public class AuditEntityListener {
    // 这里可以包含公共逻辑
}

5.2.2 更新和删除事件

当实体发生更新操作时， PreUpdate 和 PostUpdate 事件被触发。类似地，实体删除操作会触发 PreRemove 和 PostRemove 事件。开发者可以通过这些事件执行特定逻辑，如审计日志的记录。

例如，考虑一个场景，我们需要在实体每次更新时记录旧的和新的数据值。可以使用 @PreUpdate 注解的监听器方法来实现这一点：

import javax.persistence.PreUpdate;
import java.util.Arrays;

@Entity
public class AuditLog {
    // 审计日志记录的字段...
    @PreUpdate
    public void preUpdate(Entry entry) {
        // 获取旧数据
        Object[] oldData = Arrays.stream(entry.getClass().getDeclaredFields())
            .map(field -> {
                field.setAccessible(true);
                try {
                    return field.get(entry);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
                return null;
                }).toArray();

        // 业务逻辑来处理旧数据...
        // 获取新数据
        Object[] newData = Arrays.stream(entry.getClass().getDeclaredFields())
            .map(field -> {
                field.setAccessible(true);
                try {
                    return field.get(entry);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
                return null;
                }).toArray();

        // 业务逻辑来处理新数据...
    }
}

这个例子中，我们使用反射技术来获取实体字段的旧值和新值。注意，这只是一个简单的例子，实际中可能需要更复杂的逻辑来处理数据变化。

5.2.3 附加和分离事件

除了实体的创建、更新、删除等事件外，JPA 还提供了对实体附加到实体管理器 ( PrePersist , PostPersist , PostLoad ) 和从实体管理器分离 ( PreRemove , PostRemove ) 时的事件处理。

在 PostPersist 事件之后，一个实体会被附加到当前事务的上下文中，这意味着它已经存在于数据库中。这是插入数据后添加额外逻辑的一个好时机。

而在 PreRemove 事件之前，实体会被从实体管理器分离，但仍然存在于数据库中。 PostRemove 事件在实体从数据库删除后触发。这两个事件通常用于清理资源或者在删除前进行某些确认。

5.2.4 更多监听器应用示例

实体监听器可以用来实现许多有用的功能，下面是一些可能的应用示例：

• 审计追踪 ：可以记录每次实体更改的时间戳和修改者。
• 业务逻辑的执行 ：可以用来实现某些业务规则，比如不允许在周末更新某些实体。
• 字段值的自动填充 ：可以在创建或更新实体之前自动填充某些字段的值，例如生成序列号。

通过合理使用实体监听器，开发者可以提高代码的模块化，使得实体类保持简洁，同时将业务逻辑和其他关注点分离。

表格：实体监听器常见用途对比

| 监听器用途 | 适用场景 | 优点 | 注意事项 | |------------|----------|------|----------| | 审计追踪 | 记录实体的修改历史 | 提供变更历史记录 | 要考虑数据的保护和隐私 | | 业务规则实施 | 确保业务逻辑的正确执行 | 业务逻辑集中管理 | 避免过于复杂的业务规则 | | 字段自动填充 | 自动化字段赋值，如自增ID | 减少重复代码 | 需要注意字段赋值的逻辑顺序 |

Mermaid 流程图：实体生命周期事件处理流程

graph LR
    A[实体操作开始] -->|创建| B(PrePersist)
    B --> C[持久化实体]
    C -->|数据库中存在| D(PostPersist)
    C -->|数据库中不存在| D
    D --> E[附加到EntityManager]
    E --> F(PostLoad)
    F --> G[实体操作结束]

    A -->|更新| H(PreUpdate)
    H --> I[更新实体]
    I -->|数据库中更新| J(PostUpdate)
    J -->|附加到EntityManager| F

    A -->|删除| K(PreRemove)
    K --> L[删除实体]
    L -->|数据库中删除| M(PostRemove)
    M -->|从EntityManager分离| N[实体操作结束]

请注意，实体监听器的使用应该谨慎，避免引入不必要的性能开销和复杂的业务逻辑。在设计时，应明确划分关注点，保持业务逻辑的清晰与简洁。实体监听器为实体状态的变更提供了强大的灵活性和扩展性，但是过度使用可能会导致维护困难，因此需要权衡利弊进行合理设计。

6. 持久化单元配置和实体管理器使用

在本章中，我们将深入探讨JPA中的持久化单元配置和实体管理器的使用。这些内容对于理解如何在项目中有效地管理实体数据至关重要。

6.1 持久化单元的配置

6.1.1 persistence.xml的作用

persistence.xml 文件位于项目的 META-INF 目录下，是JPA持久化配置的核心文件。在这个文件中，我们可以定义持久化单元，指定使用的持久化提供者（例如Hibernate），配置数据库连接信息，以及包含实体类列表。它是运行时由实体管理器工厂读取的配置文件，决定了持久化上下文的配置。

<persistence xmlns="***"
             xmlns:xsi="***"
             xsi:schemaLocation="***
             ***"
             version="2.1">
  <persistence-unit name="examplePersistenceUnit" transaction-type="RESOURCE_LOCAL">
    <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
    <non-jta-data-source>jdbc/MyDataSource</non-jta-data-source>
    <properties>
      <property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect"/>
      <property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/mydb"/>
      <property name="hibernate.connection.username" value="root"/>
      <property name="hibernate.connection.password" value="password"/>
    </properties>
  </persistence-unit>
</persistence>

6.1.2 配置持久化单元

在配置持久化单元时，需要注意几个关键的属性：

• <provider> ：指定持久化提供者，JPA标准没有实现，一般使用Hibernate或者其他第三方实现。
• <non-jta-data-source> ：指定数据源，也可以使用JTA数据源。
• <properties> ：配置特定于提供者的属性，如数据库方言、连接信息、连接池配置等。

6.2 实体管理器的使用

6.2.1 实体管理器工厂的获取

实体管理器工厂负责为实体管理器提供实例。它是线程安全的，并且可以从应用服务器的上下文中获取，或者通过 Persistence.createEntityManagerFactory 方法创建。

EntityManagerFactory factory = Persistence.createEntityManagerFactory("examplePersistenceUnit");

6.2.2 实体管理器的基本操作

实体管理器用于管理实体的生命周期。我们可以使用它来创建和删除实体，执行查询，以及同步实体状态。

// 开始事务
EntityManager entityManager = factory.createEntityManager();
EntityTransaction transaction = entityManager.getTransaction();
transaction.begin();

try {
    // 创建一个实体
    User user = new User();
    user.setName("John Doe");
    entityManager.persist(user);

    // 执行查询
    TypedQuery<User> query = entityManager.createQuery("SELECT u FROM User u", User.class);
    List<User> users = query.getResultList();

    // 更新实体
    user.setName("Jane Doe");
    entityManager.merge(user);

    // 删除实体
    entityManager.remove(entityManager.find(User.class, user.getId()));

    // 提交事务
    ***mit();
} catch (Exception e) {
    // 回滚事务
    transaction.rollback();
} finally {
    // 关闭实体管理器
    entityManager.close();
}

6.2.3 持久化上下文的管理

实体管理器包含一个持久化上下文（Persistence Context），它是一个缓存，存放所有托管状态的实体。JPA通过这个上下文来确保数据的一致性。

• 脏检查 : 持久化上下文在提交事务时会检查所有的更改，并将更改同步到数据库。
• 一级缓存 : 持久化上下文充当一级缓存，提供快速访问实体实例。

在使用实体管理器时，必须注意事务边界，确保所有持久化操作都在事务的上下文中执行，这样可以有效地利用JPA提供的懒加载、缓存机制等特性。

本章节介绍了持久化单元的配置方法和实体管理器的使用，为理解后续的CRUD操作、事务管理和查询语言奠定了基础。通过本章内容的学习，读者应该能够掌握如何设置JPA环境，以及如何在Java环境中操作数据库。

7. 创建、读取、更新、删除操作（CRUD）实践

在第七章中，我们将深入探讨使用JPA进行数据库操作时最基础且重要的CRUD操作。CRUD操作是数据持久层的基石，它们分别对应了创建（Create）、读取（Read）、更新（Update）、删除（Delete）数据库记录的过程。在这一章节中，我们将通过代码实例和详细的解释，帮助读者掌握如何使用JPA实现这些操作。

7.1 创建操作的实现

创建操作涉及将新的实体对象保存到数据库中。在JPA中，这一操作通常通过 EntityManager 类完成。

7.1.1 使用EntityManager进行持久化

要将一个新的实体对象保存到数据库，首先要使用 EntityManager 的 persist 方法。下面是代码示例：

// 假设有一个实体类User和EntityManager实例em
User user = new User("username", "password", "***");
em.persist(user); // 调用persist方法将user对象持久化到数据库

persist 方法会将一个新的实体对象的状态与数据库同步，并返回一个管理的实体实例。JPA在事务提交时将实体对象的状态持久化到数据库。

7.1.2 使用JPQL进行批量插入

批量操作在处理大量数据时特别有用。借助JPQL（Java Persistence Query Language），我们可以执行批量插入操作：

String jpql = "INSERT INTO User (username, password, email) VALUES ('username1', 'password1', 'email1')";
Query query = em.createQuery(jpql);
int affectedRows = query.executeUpdate(); // 使用executeUpdate进行批量插入操作

请注意，JPQL不支持直接的批量 INSERT 语句。通常的做法是使用 UPDATE 语句，将一个不存在的虚拟ID赋予实体，从而触发插入操作。

7.2 读取操作的实现

读取操作，也称为检索操作，是指从数据库中检索实体对象的过程。

7.2.1 根据主键查询

根据主键查询是最常见的读取操作之一。使用 EntityManager 的 find 方法可以直接根据主键检索实体：

User foundUser = em.find(User.class, 1L); // 通过主键1L查找User实体

如果 find 方法找不到指定的实体，它将返回 null 。

7.2.2 使用JPQL和Criteria查询

find 方法只能根据主键进行查询。如果需要根据其他属性或复杂条件查询，可以使用JPQL或Criteria API。

使用JPQL查询 ：

TypedQuery<User> query = em.createQuery("SELECT u FROM User u WHERE u.email = :email", User.class);
query.setParameter("email", "***");
List<User> resultList = query.getResultList(); // 查询邮箱为***的所有User对象

使用Criteria API查询 ：

CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<User> criteriaQuery = cb.createQuery(User.class);
Root<User> userRoot = criteriaQuery.from(User.class);
criteriaQuery.select(userRoot).where(cb.equal(userRoot.get("email"), "***"));
TypedQuery<User> query = em.createQuery(criteriaQuery);
List<User> resultList = query.getResultList();

7.3 更新操作的实现

更新操作涉及修改已经持久化的实体对象。

7.3.1 修改实体状态

要更新实体对象，首先需要通过 EntityManager 获取实体对象，并对其进行修改：

User userToUpdate = em.find(User.class, 1L);
userToUpdate.setEmail("***"); // 修改实体的email属性

修改实体对象后，当事务提交时，JPA将检测到实体状态的变更并同步到数据库。

7.3.2 使用JPQL更新数据

如果你需要批量更新数据，可以使用JPQL：

String jpql = "UPDATE User u SET u.email = :newEmail WHERE u.id = :id";
Query query = em.createQuery(jpql);
query.setParameter("newEmail", "***");
query.setParameter("id", 1L);
int affectedRows = query.executeUpdate(); // 执行更新操作

7.4 删除操作的实现

删除操作涉及从数据库中删除实体对象。

7.4.1 根据主键删除实体

要删除一个实体，可以通过 EntityManager 的 remove 方法，根据主键进行删除：

User userToDelete = em.find(User.class, 1L);
em.remove(userToDelete); // 删除主键为1L的User实体

7.4.2 使用JPQL删除操作

如果你需要根据特定的条件删除多个实体，可以使用JPQL：

String jpql = "DELETE FROM User u WHERE u.email = :email";
Query query = em.createQuery(jpql);
query.setParameter("email", "***");
int affectedRows = query.executeUpdate(); // 执行删除操作

请注意，删除操作会立即反映到数据库中，因此需要谨慎使用。

通过本章内容的学习，您将掌握JPA在实际开发中的核心操作技巧。下一章节我们将深入探索事务管理，理解如何在JPA中进行有效的事务控制。

本文还有配套的精品资源，点击获取

简介：JPA是Java平台上的对象-关系映射标准，它简化了数据库操作，允许开发人员面向对象地处理关系数据库。本文将介绍JPA的基本概念，包括实体、ID、关系、监听器、持久化单元、实体管理器，并详细讨论如何通过JPA实现数据库的创建、读取、更新和删除操作。同时，文章还将探讨事务管理、查询语言、性能优化以及JPA与其他ORM框架的关系。学习掌握JPA将有助于开发人员提升效率和代码的可维护性。

本文还有配套的精品资源，点击获取