#后端 #数据库 #JPA #ORM ## JPA框架 ![image-20230720230734488](https://s2.loli.net/2023/07/20/mq4Ut7BMI5XTDoN.png) ### 认识SpringData JPA > JPA（Java Persistence API）和JDBC类似，也是官方定义的一组接口，但是它相比传统的JDBC，它是为了实现ORM而生的，即Object-Relationl Mapping，它的作用是在关系型数据库和对象之间形成一个映射，这样，我们在具体的操作数据库的时候，就不需要再去和复杂的SQL语句打交道，只要像平时操作对象一样操作它就可以了。 > > 其中比较常见的JPA实现有： > > 1. Hibernate：Hibernate是JPA规范的一个具体实现，也是目前使用最广泛的JPA实现框架之一。它提供了强大的对象关系映射功能，可以将Java对象映射到数据库表中，并提供了丰富的查询语言和缓存机制。 > 2. EclipseLink：EclipseLink是另一个流行的JPA实现框架，由Eclipse基金会开发和维护。它提供了丰富的特性，如对象关系映射、缓存、查询语言和连接池管理等，并具有较高的性能和可扩展性。 > 3. OpenJPA：OpenJPA是Apache基金会的一个开源项目，也是JPA规范的一个实现。它提供了高性能的JPA实现和丰富的特性，如延迟加载、缓存和分布式事务等。 > 4. TopLink：TopLink是Oracle公司开发的一个对象关系映射框架，也是JPA规范的一个实现。虽然EclipseLink已经取代了TopLink成为Oracle推荐的JPA实现，但TopLink仍然得到广泛使用。在之前，我们使用JDBC或是Mybatis来操作数据，通过直接编写对应的SQL语句来实现数据访问，但是我们发现实际上我们在Java中大部分操作数据库的情况都是读取数据并封装为一个实体类，因此，为什么不直接将实体类直接对应到一个数据库表呢？也就是说，一张表里面有什么属性，那么我们的对象就有什么属性，所有属性跟数据库里面的字段一一对应，而读取数据时，只需要读取一行的数据并封装为我们定义好的实体类既可以，而具体的SQL语句执行，完全可以交给框架根据我们定义的映射关系去生成，不再由我们去编写，因为这些SQL实际上都是千篇一律的。而实现JPA规范的框架一般最常用的就是`Hibernate`，它是一个重量级框架，学习难度相比Mybatis也更高一些，而SpringDataJPA也是采用Hibernate框架作为底层实现，并对其加以封装。官网：[Spring Data JPA 官方教程](https://spring.io/projects/spring-data-jpa) ### 使用JPA快速上手同样的，我们只需要导入stater依赖即可： ```xml org.springframework.boot spring-boot-starter-data-jpa ``` 接着我们可以直接创建一个类，比如用户类，我们只需要把一个账号对应的属性全部定义好即可： ```java @Data public class Account { int id; String username; String password; } ``` 接着，我们可以通过注解形式，在属性上添加数据库映射关系，这样就能够让JPA知道我们的实体类对应的数据库表长啥样，这里用到了很多注解： ```java @Data @Entity //表示这个类是一个实体类 @Table(name = "account") //对应的数据库中表名称 public class Account { @GeneratedValue(strategy = GenerationType.IDENTITY) //生成策略，这里配置为自增 @Column(name = "id") //对应表中id这一列 @Id //此属性为主键 int id; @Column(name = "username") //对应表中username这一列 String username; @Column(name = "password") //对应表中password这一列 String password; } ``` 接着我们来修改一下配置文件，把日志打印给打开： ```yaml spring: jpa: #开启SQL语句执行日志信息 show-sql: true hibernate: #配置为检查数据库表结构，没有时会自动创建 ddl-auto: update ``` `ddl-auto`属性用于设置自动表定义，可以实现自动在数据库中为我们创建一个表，表的结构会根据我们定义的实体类决定，它有以下几种： - `none`: 不执行任何操作，数据库表结构需要手动创建。 - `create`: 框架在每次运行时都会删除所有表，并重新创建。 - `create-drop`: 框架在每次运行时都会删除所有表，然后再创建，但在程序结束时会再次删除所有表。 - `update`: 框架会检查数据库表结构，如果与实体类定义不匹配，则会做相应的修改，以保持它们的一致性。 - `validate`: 框架会检查数据库表结构与实体类定义是否匹配，如果不匹配，则会抛出异常。这个配置项的作用是为了避免手动管理数据库表结构，使开发者可以更方便地进行开发和测试，但在生产环境中，更推荐使用数据库迁移工具来管理表结构的变更。我们可以在日志中发现，在启动时执行了如下SQL语句： ![image-20230720235136506](https://s2.loli.net/2023/07/20/kABZVhJ8vjKSqzT.png) 我们的数据库中对应的表已经自动创建好了。我们接着来看如何访问我们的表，我们需要创建一个Repository实现类： ```java @Repository public interface AccountRepository extends JpaRepository { } ``` 注意JpaRepository有两个泛型，前者是具体操作的对象实体，也就是对应的表，后者是ID的类型，接口中已经定义了比较常用的数据库操作。编写接口继承即可，我们可以直接注入此接口获得实现类： ```java @Resource AccountRepository repository; @Test void contextLoads() { Account account = new Account(); account.setUsername("小红"); account.setPassword("1234567"); System.out.println(repository.save(account).getId()); //使用save来快速插入数据，并且会返回插入的对象，如果存在自增ID，对象的自增id属性会自动被赋值，这就很方便了 } ``` 执行结果如下： ![image-20230720235640148](https://s2.loli.net/2023/07/20/ksI3J5eidzTrvyL.png) 同时，查询操作也很方便： ```java @Test void contextLoads() { //默认通过通过ID查找的方法，并且返回的结果是Optional包装的对象，非常人性化 repository.findById(1).ifPresent(System.out::println); } ``` 得到结果为： ![image-20230720235949290](https://s2.loli.net/2023/07/20/TRHOWbop267Al4Q.png) 包括常见的一些计数、删除操作等都包含在里面，仅仅配置应该接口就能完美实现增删改查： ![image-20230721000050875](https://s2.loli.net/2023/07/21/uIBciLqFsH5tdDR.png) 我们发现，使用了JPA之后，整个项目的代码中没有出现任何的SQL语句，可以说是非常方便了，JPA依靠我们提供的注解信息自动完成了所有信息的映射和关联。相比Mybatis，JPA几乎就是一个全自动的ORM框架，而Mybatis则顶多算是半自动ORM框架。 ### 方法名称拼接自定义SQL 虽然接口预置的方法使用起来非常方便，但是如果我们需要进行条件查询等操作或是一些判断，就需要自定义一些方法来实现，同样的，我们不需要编写SQL语句，而是通过方法名称的拼接来实现条件判断，这里列出了所有支持的条件判断名称： | 属性 | 拼接方法名称示例 | 执行的语句 | | ------------------ | ----------------------------------------------------------- | ------------------------------------------------------------ | | Distinct | findDistinctByLastnameAndFirstname | select distinct … where x.lastname = ?1 and x.firstname = ?2 | | And | findByLastnameAndFirstname | … where x.lastname = ?1 and x.firstname = ?2 | | Or | findByLastnameOrFirstname | … where x.lastname = ?1 or x.firstname = ?2 | | Is，Equals | findByFirstname`,`findByFirstnameIs`,`findByFirstnameEquals | … where x.firstname = ?1 | | Between | findByStartDateBetween | … where x.startDate between ?1 and ?2 | | LessThan | findByAgeLessThan | … where x.age < ?1 | | LessThanEqual | findByAgeLessThanEqual | … where x.age <= ?1 | | GreaterThan | findByAgeGreaterThan | … where x.age > ?1 | | GreaterThanEqual | findByAgeGreaterThanEqual | … where x.age >= ?1 | | After | findByStartDateAfter | … where x.startDate > ?1 | | Before | findByStartDateBefore | … where x.startDate < ?1 | | IsNull，Null | findByAge(Is)Null | … where x.age is null | | IsNotNull，NotNull | findByAge(Is)NotNull | … where x.age not null | | Like | findByFirstnameLike | … where x.firstname like ?1 | | NotLike | findByFirstnameNotLike | … where x.firstname not like ?1 | | StartingWith | findByFirstnameStartingWith | … where x.firstname like ?1（参数与附加`%`绑定） | | EndingWith | findByFirstnameEndingWith | … where x.firstname like ?1（参数与前缀`%`绑定） | | Containing | findByFirstnameContaining | … where x.firstname like ?1（参数绑定以`%`包装） | | OrderBy | findByAgeOrderByLastnameDesc | … where x.age = ?1 order by x.lastname desc | | Not | findByLastnameNot | … where x.lastname <> ?1 | | In | findByAgeIn(Collection ages) | … where x.age in ?1 | | NotIn | findByAgeNotIn(Collection ages) | … where x.age not in ?1 | | True | findByActiveTrue | … where x.active = true | | False | findByActiveFalse | … where x.active = false | | IgnoreCase | findByFirstnameIgnoreCase | … where UPPER(x.firstname) = UPPER(?1) | 比如我们想要实现根据用户名模糊匹配查找用户： ```java @Repository public interface AccountRepository extends JpaRepository { //按照表中的规则进行名称拼接，不用刻意去记，IDEA会有提示 List findAllByUsernameLike(String str); } ``` 我们来测试一下： ```java @Test void contextLoads() { repository.findAllByUsernameLike("%明%").forEach(System.out::println); } ``` ![image-20230721001035279](https://s2.loli.net/2023/07/21/mioZaUk7Yj3QDxb.png) 又比如我们想同时根据用户名和ID一起查询： ```java @Repository public interface AccountRepository extends JpaRepository { List findAllByUsernameLike(String str); Account findByIdAndUsername(int id, String username); //也可以使用Optional类进行包装，Optional findByIdAndUsername(int id, String username); } ``` ```java @Test void contextLoads() { System.out.println(repository.findByIdAndUsername(1, "小明")); } ``` 比如我们想判断数据库中是否存在某个ID的用户： ```java @Repository public interface AccountRepository extends JpaRepository { List findAllByUsernameLike(String str); Account findByIdAndUsername(int id, String username); //使用exists判断是否存在 boolean existsAccountById(int id); } ``` 注意自定义条件操作的方法名称一定要遵循规则，不然会出现异常： ```sh Caused by: org.springframework.data.repository.query.QueryCreationException: Could not create query for public abstract ... ``` 有了这些操作，我们在编写一些简单SQL的时候就很方便了，用久了甚至直接忘记SQL怎么写。 ### 关联查询在数据库中，我们常常会用到关联查询，比如我们想要查询订单时，获取这个订单的用户信息，这时就需要将订单表和用户表建立关联。首先我们来看看实体类之间的关系： 1. 一对一关系：比如一个用户对应一个用户信息 2. 一对多关系：比如一个用户对应多个订单 3. 多对多关系：比如一个用户对应多个角色，一个角色也可以对应多个用户我们来尝试实现一下，首先创建用户实体类： ```java @Data @Entity @Table(name = "users") public class User { @GeneratedValue(strategy = GenerationType.IDENTITY) @Column(name = "id") @Id int id; @Column(name = "username") String username; @Column(name = "password") String password; } ``` 接着创建用户信息实体类： ```java @Data @Entity @Table(name = "user_details") public class UserDetail { @GeneratedValue(strategy = GenerationType.IDENTITY) @Column(name = "id") @Id int id; @Column(name = "address") String address; @Column(name = "phone") String phone; @Column(name = "email") String email; } ``` 然后我们需要在用户类中添加用户信息属性，建立关联关系： ```java @Data @Entity @Table(name = "users") public class User { @GeneratedValue(strategy = GenerationType.IDENTITY) @Column(name = "id") @Id int id; @Column(name = "username") String username; @Column(name = "password") String password; @OneToOne //声明为一对一关系 @JoinColumn(name = "detail_id") //指定关联的外键字段 UserDetail detail; //关联的实体类型 } ``` 在测试之前，我们需要先创建用户信息，再创建用户： ```java @Test void contextLoads() { UserDetail detail = new UserDetail(); detail.setAddress("重庆市渝中区解放碑"); detail.setPhone("1234567890"); detail.setEmail("73281937@qq.com"); detailRepository.save(detail); //先保存用户信息 User user = new User(); user.setUsername("admin"); user.setPassword("123456"); user.setDetail(detail); //设置用户信息 userRepository.save(user); //保存用户 } ``` 最后，我们可以通过用户Repository来查询用户信息： ```java @Test void contextLoads() { userRepository.findById(1).ifPresent(user -> { System.out.println("用户名称："+user.getUsername()); System.out.println("用户地址："+user.getDetail().getAddress()); System.out.println("用户电话："+user.getDetail().getPhone()); }); } ``` 这样，我们就实现了一对一关联查询。 ### 一对多关联我们接着来看一对多关联，比如用户的订单信息，一个用户可以发多个订单，首先创建订单实体类： ```java @Data @Entity @Table(name = "orders") public class Order { @GeneratedValue(strategy = GenerationType.IDENTITY) @Column(name = "id") @Id int id; @Column(name = "detail") String detail; @ManyToOne(fetch = FetchType.LAZY) //多对一，fetch = FetchType.LAZY表示懒加载 @JoinColumn(name = "user_id") //关联的字段 User user; //关联的实体 } ``` 接着在用户类中添加订单集合： ```java @Data @Entity @Table(name = "users") public class User { @GeneratedValue(strategy = GenerationType.IDENTITY) @Column(name = "id") @Id int id; @Column(name = "username") String username; @Column(name = "password") String password; @OneToOne @JoinColumn(name = "detail_id") UserDetail detail; @OneToMany(mappedBy = "user") //一对多，一个用户可以对应多个订单 List orderList; //订单列表 } ``` 我们来测试一下： ```java @Test void contextLoads() { User user = new User(); user.setUsername("admin"); user.setPassword("123456"); user = userRepository.save(user); //保存用户，获取用户ID Order order = new Order(); order.setDetail("订单1"); order.setUser(user); //设置订单所属的用户 orderRepository.save(order); //保存订单 Order order2 = new Order(); order2.setDetail("订单2"); order2.setUser(user); //设置订单所属的用户 orderRepository.save(order2); //保存订单 } ``` 最后，我们来查询用户，并获取用户的所有订单信息： ```java @Test void contextLoads() { userRepository.findById(1).ifPresent(user -> { System.out.println("用户名称："+user.getUsername()); user.getOrderList().forEach(order -> { System.out.println("订单编号："+order.getId()); System.out.println("订单详情："+order.getDetail()); }); }); } ``` 这样，我们就实现了一对多关联查询。 ### 多对多关联最后我们来看多对多关联，比如用户和角色，一个用户可以有多个角色，一个角色也可以被多个用户使用。首先创建角色实体类： ```java @Data @Entity @Table(name = "roles") public class Role { @GeneratedValue(strategy = GenerationType.IDENTITY) @Column(name = "id") @Id int id; @Column(name = "name") String name; @ManyToMany(mappedBy = "roleList") List userList; } ``` 接着在用户类中添加角色集合： ```java @Data @Entity @Table(name = "users") public class User { @GeneratedValue(strategy = GenerationType.IDENTITY) @Column(name = "id") @Id int id; @Column(name = "username") String username; @Column(name = "password") String password; @OneToOne @JoinColumn(name = "detail_id") UserDetail detail; @OneToMany(mappedBy = "user") List orderList; @ManyToMany //多对多 @JoinTable(name = "user_role", //多对多中间关联表 joinColumns = @JoinColumn(name = "user_id"), //当前实体在关联表中的外键字段 inverseJoinColumns = @JoinColumn(name = "role_id") //对方实体在关联表中的外键字段 ) List roleList; } ``` 我们来测试一下： ```java @Test void contextLoads() { User user = new User(); user.setUsername("admin"); user.setPassword("123456"); user = userRepository.save(user); //保存用户，获取用户ID Role role = new Role(); role.setName("管理员"); role = roleRepository.save(role); //保存角色，获取角色ID Role role2 = new Role(); role2.setName("用户"); role2 = roleRepository.save(role2); //保存角色，获取角色ID user.getRoleList().add(role); //添加角色 user.getRoleList().add(role2); //添加角色 userRepository.save(user); //保存用户 } ``` 最后，我们来查询用户，并获取用户的所有角色信息： ```java @Test void contextLoads() { userRepository.findById(1).ifPresent(user -> { System.out.println("用户名称："+user.getUsername()); user.getRoleList().forEach(role -> { System.out.println("角色名称："+role.getName()); }); }); } ``` 这样，我们就实现了多对多关联查询。 ### 总结 JPA 是一个强大的 ORM 框架，它可以帮助我们简化数据库操作，提高开发效率。通过使用 JPA，我们可以： 1. 通过注解定义实体类和数据库表的映射关系 2. 使用 Repository 接口快速实现增删改查操作 3. 通过方法名称拼接实现条件查询 4. 实现一对一、一对多、多对多等关联查询虽然 JPA 的学习曲线相对较高，但是一旦掌握，可以大大提高开发效率。在实际开发中，我们可以根据项目需求选择使用 JPA 或其他 ORM 框架。

JPA 学习