JPA概括-蒲公英云

文章目录

一. GPA介绍
- 1. 概念简介
- 1. 原理浅析
- 1. 常用注解
二. 案例实战
- 1. 定义实体类
- 1. 创建实体管理器
- 1. 执行CRUD操作
- 1. 查询
三.JPA+SpringBoot实现简单数据库增删改查
- 1. 在Spring Boot项目中添加依赖项
- 1. 创建实体类
- 1. 创建一个JpaRepository接口来访问实体类数据
- 1. 创建一个Service类来实现数据的增删改查
- 1. 在Controller中调用Service实现接口API的访问

一. GPA介绍

1. 概念简介

JPA（Java Persistence API）是一种Java EE规范，用于管理关系型数据库中的数据持久化。JPA提供了一种面向对象的API，可以方便地执行常见的CRUD（Create, Read, Update, Delete）操作，同时也支持复杂的查询操作。在JPA中，我们可以使用注解或XML配置来映射Java实体类和关系型数据库表之间的关系。JPA还支持一些高级特性，如继承、多态、联合查询等，这些特性使得开发人员能够更加灵活地处理数据持久化的问题。

2. 原理浅析

JPA的核心原理是ORM（Object-Relational Mapping），即对象关系映射。ORM将Java对象和数据库表之间进行映射，通过定义实体类、注解、配置文件等方式来描述实体类和数据库表的关系，从而实现将Java对象转换为数据库表中的记录，以及将数据库表中的记录转换为Java对象的过程。

JPA的实现是通过使用实体管理器（EntityManager）来实现的。实体管理器是一个关键的组件，它提供了一系列方法来处理实体对象，如创建、更新、删除和查询实体对象等。当我们进行实体操作时，实体管理器会根据我们定义的实体类和注解来进行映射，从而将实体对象转换为数据库表中的记录或者从数据库表中查询记录并转换为实体对象。

JPA支持多种映射方式，包括注解映射、XML配置映射等。注解映射是JPA最常用的方式，通过在实体类中添加注解来描述实体类和数据库表的映射关系。例如，@Entity注解用于标识实体类，@Table注解用于指定实体类对应的数据库表名称，@Id注解用于标识实体类的主键等。

JPA还支持多种查询方式，包括JPQL（Java Persistence Query Language）、Criteria API等。JPQL是一种基于对象的查询语言，它类似于SQL语言，但是查询的是Java对象，而不是数据库表。Criteria API是一种面向对象的查询方式，它提供了一组类型安全的API来构建查询。

总之，JPA是一个ORM框架，通过将Java对象和数据库表之间进行映射来实现数据持久化，从而简化了Java开发人员与数据库打交道的流程。JPA的原理可以通过实体管理器、实体类、注解、配置文件等方面进行解释。

3. 常用注解

JPA中常用的注解有很多，以下是一些常见的注解及其用途：
@Entity:用于标识一个类是JPA实体类，对应数据库中的表。
@Table:指定实体对应的数据库表的名称。
@Id:用于标识实体类中唯一的标识符属性，对应数据库表的主键。
@GeneratedValue:指定主键生成策略，常用的有自增长、UUID等。
@Column用于指定属性对应的数据库列的名称、类型、长度等。
@Temporal:用于指定日期/时间属性的类型，包括DATE、TIME、TIMESTAMP等。
@OneToMany:表示实体类与其他实体类之间的一对多关系，需要在关系的维护端（多的一方）上使用该注解。
@ManyToOne:表示实体类与其他实体类之间的多对一关系，需要在关系的被维护端（一的一方）上使用该注解。
@OneToOne:表示实体类与其他实体类之间的一对一关系，需要在关系的任意一端上使用该注解。
@JoinColumn:用于指定关系维护端与被维护端之间的外键关系，包括外键名称、引用的实体类等。
@NamedQuery:用于定义命名查询，可以在实体管理器中使用该名称来执行查询操作。
@NamedQueries:用于定义多个命名查询。
@Transient:用于指定一个属性不会被持久化到数据库中。
这些注解是JPA中使用频率比较高的一些注解，掌握它们的用法可以帮助开发者更方便地进行对象关系映射操作。

二. 案例实战

以下是一个简单的JPA示例，其中包括实体类、实体管理器、查询等核心概念的使用

1. 定义实体类

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

上述代码定义了一个名为User的实体类，其中使用了@Entity注解表示该类是一个实体类，@Table注解表示对应的数据库表名为”users”。实体类中包含了id、name、email等属性，并使用@Id和@GeneratedValue注解表示id属性是实体的唯一标识符，并使用自增策略生成。

2. 创建实体管理器

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
public class Main {
    public static void main(String[] args) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("jpa-example");
        EntityManager em = emf.createEntityManager();
        // 执行CRUD操作
        em.close();
        emf.close();
    }
}

上述代码创建了一个实体管理器工厂EntityManagerFactory实例，并使用它创建了一个实体管理器EntityManager实例。其中，”jpa-example”是一个持久化单元的名称，对应的是一个META-INF/persistence.xml文件中的配置

3. 执行CRUD操作

// 新增一个用户
User user = new User();
user.setName("Tom");
user.setEmail("tom@example.com");
em.getTransaction().begin();
em.persist(user);
em.getTransaction().commit();
// 查询所有用户
TypedQuery<User> query = em.createQuery("SELECT u FROM User u", User.class);
List<User> userList = query.getResultList();
// 更新一个用户
User user = em.find(User.class, 1L);
user.setName("Jerry");
em.getTransaction().begin();
em.merge(user);
em.getTransaction().commit();
// 删除一个用户
User user = em.find(User.class, 1L);
em.getTransaction().begin();
em.remove(user);
em.getTransaction().commit();

上述代码演示了如何执行CRUD操作。首先使用persist方法将一个新的用户持久化到数据库中，然后使用createQuery方法查询所有用户，使用find方法查找一个用户并使用merge方法更新它，最后使用remove方法删除一个用户。

4. 查询

// 使用JPQL查询所有用户
TypedQuery<User> query = em.createQuery("SELECT u FROM User u WHERE u.name = :name", User.class);
query.setParameter("name", "Tom");
List<User> userList = query.getResultList();
// 使用Criteria API查询所有用户
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<User> cq = cb.createQuery(User.class);
Root<User> root = cq.from(User.class);
cq.select(root).where(cb.equal(root.get("name"), "Tom"));
TypedQuery<User> query = em.createQuery(cq);
List<User> userList = query.getResultList();

上述代码演示了如何使用JPQL和Criteria API进行查询操作。其中，JPQL使用了参数绑定的方式，Criteria API使用了Root、CriteriaBuilder和CriteriaQuery等对象来构建查询语句

三.JPA+SpringBoot实现简单数据库增删改查

1. 在Spring Boot项目中添加依赖项

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

2. 创建实体类

使用JPA注解进行实体类的映射，例如，假设我们要创建一个名为”User”的实体类，它有一个名为”id”的唯一标识符，一个名为”username”的字符串类型属性和一个名为”password”的字符串类型属性：

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String username;
    private String password;
    // getters and setters
}

3. 创建一个JpaRepository接口来访问实体类数据

例如，我们要创建一个名为”UserRepository”的JpaRepository接口来访问”User”实体类的数据：

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

4. 创建一个Service类来实现数据的增删改查

例如，我们要创建一个名为”UserService”的Service类来实现”User”实体类数据的增删改查：

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    public User save(User user) {
        return userRepository.save(user);
    }
    public void delete(Long id) {
        userRepository.deleteById(id);
    }
    public User update(User user) {
        return userRepository.save(user);
    }
    public User findById(Long id) {
        Optional<User> user = userRepository.findById(id);
        return user.isPresent() ? user.get() : null;
    }
    public List<User> findAll() {
        return userRepository.findAll();
    }
}

5. 在Controller中调用Service实现接口API的访问

例如，我们要创建一个名为”UserController”的Controller来调用”UserService”来实现”User”实体类数据的增删改查接口API：

@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;
    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.save(user);
    }
    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userService.delete(id);
    }
    @PutMapping
    public User updateUser(@RequestBody User user) {
        return userService.update(user);
    }
    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.findById(id);
    }
    @GetMapping
    public List<User> getUsers() {
        return userService.findAll();
    }
}