实战系列（四）| JPA详解，包含详细代码

女爷i 2023-10-15 23:09 36阅读 0赞

#### 目录 ####

*  1. 概念与原理：
 *  2. 支持的数据库：
 *  3. 优缺点：
 *  4. 应用场景：
 *  5. 主要方法：
 *  6. 方法说明包含代码：
 *  7. 案例代码：
 *  8. JPA学习资料

JPA（Java Persistence API）是 Java EE 规范中的一部分，它定义了一组标准的 API，用于将 Java 对象映射到关系数据库表。JPA 的目标是简化企业应用开发，使得开发者能够更容易地实现对象与数据库表之间的映射关系。下面是 JPA 的一些基本概念、支持的数据库、优缺点以及具体应用场景和案例代码：  
![在这里插入图片描述][99ec37cc036d48c2952618bdf94d4378.png_pic_center]

## 1. 概念与原理： ##

JPA 主要包括以下几个概念：

*  实体（Entity）：现实世界中某个具体事物在数据库中的映射。实体类需要继承 `java.io.Serializable` 接口，并使用 JPA 注解来描述与数据库表之间的映射关系。
 *  持久化（Persistence）：将实体对象映射到数据库表并将其状态保存在数据库中的过程。
 *  持久化管理（Persistence Management）：负责管理实体对象与数据库表之间的映射关系以及实体对象的持久化操作。
 *  查询（Query）：JPA 提供了一种标准的查询语言（JPQL），用于编写类型安全的查询语句。此外，我们还可以使用 Criteria API 来编写更加灵活的查询条件。

## 2. 支持的数据库： ##

JPA 本身并不依赖于特定的数据库，而是通过各种 ORM（对象关系映射）实现来支持不同类型的数据库。常见的 JPA ORM 实现有：

*  Hibernate：支持多种数据库，如 MySQL、PostgreSQL、Oracle、SQL Server 等。
 *  EclipseLink：支持多种数据库，如 MySQL、PostgreSQL、Oracle、SQL Server 等。
 *  OpenJPA：支持多种数据库，如 MySQL、PostgreSQL、Oracle、SQL Server 等。

## 3. 优缺点： ##

优点：

*  简化了 Java 对象与数据库表之间的映射关系，降低了开发难度。
 *  支持多种数据库，具有较好的移植性。
 *  提供了丰富的查询语言和查询方式，方便开发者编写复杂查询。  
    缺点：
 *  学习成本较高，需要掌握一系列的 JPA 注解和 API。
 *  在某些场景下，JPA 的查询性能可能不如原生 SQL 查询。

## 4. 应用场景： ##

JPA 适用于以下场景：

*  企业级应用开发：JPA 可以简化对象与数据库表之间的映射关系，降低开发难度。
 *  Web 应用开发：JPA 可以方便地集成到 Spring Boot 等 Web 开发框架中，提高开发效率。
 *  数据库迁移：JPA 支持多种数据库，可以在不同数据库之间进行迁移。

## 5. 主要方法： ##

JPA（Java Persistence API）是一种用于持久化 Java 对象到关系型数据库的标准规范。JPA 提供了一组 API，用于定义实体类、数据访问和查询。以下是 JPA 的一些主要方法，包括具体代码示例：

1.  实体类相关方法：

*  `Entity`：JPA 实体类，用于映射数据库表。
 *  `@Entity` 注解：标记一个类作为 JPA 实体类。
 *  `@Table` 注解：指定实体类对应的数据库表名。
 *  `@Id` 注解：标记实体类的主键属性。
 *  `@GeneratedValue` 注解：指定主键生成策略。
 *  `@Column` 注解：指定实体类属性对应的数据库列。

@Entity  
    @Table(name = "user")  
    public class User {
          
       @Id  
       @GeneratedValue(strategy = GenerationType.IDENTITY)  
       private Long id;
       @Column(name = "email")  
       private String email;
       @Column(name = "last_name")  
       private String lastName;
       // 省略 getter 和 setter 方法  
    }

1.  数据访问相关方法：

*  `EntityManager`：JPA 提供的数据访问接口，用于执行 CRUD（创建、读取、更新、删除）操作。
 *  `getEntityManager()`：获取 `EntityManager` 实例。
 *  `findAll()`：查询所有记录。
 *  `findById(Long id)`：根据 ID 查询记录。
 *  `save(User user)`：保存一个实体对象到数据库。
 *  `deleteById(Long id)`：删除指定 ID 的记录。

@Repository  
    public interface UserRepository extends JpaRepository<User, Long> {
          
    }

1.  查询相关方法：

*  `CriteriaBuilder`：JPA 提供的查询构建器，用于构建 JPQL（Java Persistence Query Language）查询。
 *  `CriteriaQuery`：JPA 查询接口，用于编写 JPQL 查询。
 *  `Root`：JPQL 查询的根对象，用于表示实体类。
 *  `Predicate`：JPQL 查询的谓词，用于表示查询条件。
 *  `createQuery(Query query)`：根据给定的 JPQL 查询生成查询对象。

1.  JPQL 查询：

*  JPQL 是 JPA 提供的一种查询语言，用于编写类型安全的查询。
 *  JPQL 查询可以与 CriteriaBuilder 和 CriteriaQuery 结合使用，也可以直接在 Java 代码中编写。

@Repository  
    public interface UserRepository extends JpaRepository<User, Long> {
          
       @Query("select u from User u where u.email =?1 and u.lastName =?2")  
       List<User> findByEmailAddressAndLastName(String email, String lastName);
       // 使用 CriteriaBuilder 和 CriteriaQuery 进行查询  
       @Query(value = "select u from User u where u.email =?1 and u.lastName =?2", nativeQuery = true)  
       List<User> findByEmailAddressAndLastName2(String email, String lastName);  
    }

以上是 JPA 的一些主要方法。通过使用这些方法和 JPQL 查询，我们可以实现对数据库的复杂查询和操作。在实际项目中，我们还可以利用 Spring Data JPA 等框架，进一步简化 JPA 的使用。

## 6. 方法说明包含代码： ##

JPA（Java Persistence API）是一种用于持久化 Java 对象到关系型数据库的标准规范。下面列举了一些 JPA 的常见用法，并提供了详细的代码示例。

1.  实体类映射：  
    首先，需要创建一个实体类，用于映射数据库表。例如，以下代码创建了一个名为 `User` 的实体类，用于映射 `user` 表：

import javax.persistence.*;
    @Entity  
    @Table(name = "user")  
    public class User {
          
       @Id  
       @GeneratedValue(strategy = GenerationType.IDENTITY)  
       private Long id;
       @Column(name = "email")  
       private String email;
       @Column(name = "last_name")  
       private String lastName;
       // 省略 getter 和 setter 方法  
    }

1.  实体类关联：  
    使用 `@OneToOne`、`@OneToMany`、`@ManyToOne` 和 `@ManyToMany` 等注解可以实现实体类之间的关联。例如，以下代码表示一个 `User` 和 `Address` 之间的一对一关联：

import javax.persistence.*;
    @Entity  
    public class User {
          
       //...
       @OneToOne  
       @JoinColumn(name = "address_id")  
       private Address address;
       // 省略 getter 和 setter 方法  
    }

1.  查询：  
    使用 `EntityManager` 接口可以执行 CRUD 操作。例如，以下代码查询所有 `User` 实体：

import javax.persistence.EntityManager;  
    import javax.persistence.PersistenceContext;  
    import java.util.List;
    public class UserRepository {
          
       @PersistenceContext  
       private EntityManager entityManager;
       public List<User> findAll() {
          
           return entityManager.createQuery("SELECT u FROM User u", User.class).getResultList();  
       }  
    }

1.  查询示例：  
    使用 JPQL（Java Persistence Query Language）编写查询。例如，以下代码查询所有年龄大于等于 26 岁的用户：

import javax.persistence.EntityManager;  
    import javax.persistence.PersistenceContext;  
    import java.util.List;
    public class UserRepository {
          
       @PersistenceContext  
       private EntityManager entityManager;
       public List<User> findUsersByAge() {
          
           String queryString = "SELECT u FROM User u WHERE u.age >= 26";  
           return entityManager.createQuery(queryString, User.class).getResultList();  
       }  
    }

1.  事务支持：  
    使用 `@Transactional` 注解可以支持事务。例如，以下代码在一个事务中执行插入和查询操作：

import org.springframework.transaction.annotation.Transactional;
    @Service  
    public class UserService {
          
       @Autowired  
       private UserRepository userRepository;
       @Transactional  
       public void insertUser(User user) {
          
           userRepository.save(user);  
           userRepository.findUsersByAge();  
       }  
    }

以上是 JPA 的一些常见用法。在实际项目中，可以根据具体需求进行相应的调整。

## 7. 案例代码： ##

假设我们要开发一个简单的用户管理系统，可以使用 JPA 来进行数据持久化和查询。  
首先，创建一个 User 实体类：

import javax.persistence.*;
    @Entity  
    public class User {
          
       @Id  
       @GeneratedValue(strategy = GenerationType.IDENTITY)  
       private Long id;
       @Column(nullable = false, unique = true)  
       private String username;
       @Column(nullable = false)  
       private String password;
       // 省略 getter 和 setter 方法  
    }

接下来，创建一个 UserRepository 接口，用于进行持久化操作：

import javax.persistence.EntityManager;  
    import javax.persistence.PersistenceContext;  
    import java.util.List;
    public interface UserRepository {
          
       EntityManager getEntityManager();
       List<User> findAll();
       User findById(Long id);
       void save(User user);
       void deleteById(Long id);  
    }

在实际项目中，我们可以将这个接口集成到 Spring Boot 中，通过 `@SpringBootApplication` 注解的 `@EnablePersistence` 功能来开启持久化功能。  
接下来，我们使用 JPQL 进行查询：

import javax.persistence.criteria.CriteriaBuilder;  
    import javax.persistence.criteria.CriteriaQuery;  
    import javax.persistence.criteria.Predicate;  
    import javax.persistence.criteria.Root;
    public class UserService {
          
       public List<User> findByUsername(String username) {
          
           CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();  
           CriteriaQuery<User> query = cb.createQuery(User.class);  
           Root<User> user = query.from(User.class);  
           Predicate predicate = cb.equal(user.get("username"), username);  
           query.where(predicate);  
           return getEntityManager().createQuery(query).getResultList();  
       }  
    }

最后，我们可以在控制器中使用这个接口来进行数据的增删改查操作：

import org.springframework.beans.factory.annotation.Autowired;  
    import org.springframework.web.bind.annotation.*;
    import java.util.List;
    @RestController  
    @RequestMapping("/users")  
    public class UserController {
          
       @Autowired  
       private UserRepository userRepository;
       @GetMapping  
       public List<User> findAll() {
          
           return userRepository.findAll();  
       }
       @GetMapping("/{id}")  
       public User findById(@PathVariable Long id) {
          
           return userRepository.findById(id);  
       }
       @PostMapping  
       public void save(@RequestBody User user) {
          
           userRepository.save(user);  
       }
       @DeleteMapping("/{id}")  
       public void deleteById(@PathVariable Long id) {
          
           userRepository.deleteById(id);  
       }  
    }

以上代码展示了一个简单的基于 JPA 的用户管理系统。在这个系统中，我们使用 JPA 进行数据的持久化和查询，通过 Spring Boot 框架来进行 Web 请求的处理。

## 8. JPA学习资料 ##

JPA（Java Persistence API）的官方网站为：https://java.net/projects/jpa/  
在这个网站上，你可以找到 JPA 的最新规范文档、API 参考以及一些示例代码。以下是一些有用的链接：

*  JPA 2.2 规范文档：https://java.net/projects/jpa/downloads/jpa-2.2-spec.pdf
 *  JPA 2.1 规范文档：https://java.net/projects/jpa/downloads/jpa-2.1-spec.pdf
 *  JPA Tutorial（教程）：https://java.net/projects/jpa/tutorial/  
    此外，还有许多关于 JPA 的学习资料和教程，以下是一些建议：

1.  《Java Persistence API: The Book》：由 JPA 规范的主要作者之一，Roger Counsell 编写的 JPA 入门书籍。该书详细介绍了 JPA 的基本概念、API 和最佳实践。
2.  《Mastering Java Persistence: JPA, Hibernate, and Spring Data JPA》：这本书由著名的 Java EE 作者 Martin Fowler 编写，涵盖了 JPA 的高级主题，包括 Hibernate 和 Spring Data JPA。
3.  《JPA in Action》：这本书由 Donald Kuchling 编写，提供了丰富的示例和实际项目中的场景，适合有一定 JPA 基础的读者。
4.  《Java Persistence with Hibernate》：这本书由 Gavin King（Hibernate 的主要作者之一）和 James Fowler 编写，主要介绍了 Hibernate，但也涵盖了 JPA 的基本知识。![在这里插入图片描述][5586eff672e4492295f8713254bd5494.jpeg_pic_center]
5.  在线课程：网上有许多关于 JPA 的免费或付费在线课程，例如在 Coursera、Udemy、慕课网等平台上可以找到一些优质的课程。  
    学习 JPA 时，可以结合实际项目进行实践，这样可以更好地理解 JPA 的原理和应用。同时，多参考一些资料和社区讨论，有助于解决遇到的问题和提高自己的技能。

[99ec37cc036d48c2952618bdf94d4378.png_pic_center]: https://img-blog.csdnimg.cn/99ec37cc036d48c2952618bdf94d4378.png#pic_center
[5586eff672e4492295f8713254bd5494.jpeg_pic_center]: https://img-blog.csdnimg.cn/5586eff672e4492295f8713254bd5494.jpeg#pic_center