第 3-4 课： Spring Data JPA 的基本使⽤

秒速五厘米 2023-06-27 05:34 12阅读 0赞

Spring Data JPA  是  Spring Boot  体系中约定优于配置的最佳实现，⼤⼤简化了项⽬中数据库的操作。从本课

开始将会从  JPA  的由来开始讲解，什么是  JPA 、 Spring Boot JPA  的实现，以及如何使⽤。

### 概念 ###

### **JPA** 由来  ###

ORM  框架能够将  Java  对象映射到关系数据库中，能够直接持久化复杂的  Java  对象。 ORM  框架的出现，可

以让开发者从数据库编程中解脱出来，把更多的精⼒放在了业务模型与业务逻辑上。⽬前⽐较流⾏的  ORM

框架有  Hibernate 、 MyBatis 、 TopLink 、 Spring JDBC  等。

在  JPA  规范之前，由于没有官⽅的标准，使得各  ORM  框架之间的  API  差别很⼤，使⽤了某种  ORM  框架的

系统会严重受制于该  ORM  的标准。基于此， Sun  引⼊新的  JPA ORM ，主要的原因有：其⼀，简化现有

Java EE  和  Java SE  应⽤开发⼯作；其⼆， Sun  希望整合  ORM  技术，实现统⼀的  API  调⽤接⼝。

### **JPA** 是什么 ###

JPA （ Java Persistence API ）是  Sun  官⽅提出的  Java  持久化规范。它为  Java  开发⼈员提供了⼀种对象  /

关联映射⼯具来管理  Java  应⽤中的关系数据。它的出现主要是为了简化现有的持久化开发⼯作和整合  ORM

技术，结束现在  Hibernate 、 TopLink 、 JDO  等  ORM  框架各⾃为营的局⾯。

值得注意的是， JPA  是在充分吸收了现有的  Hibernate 、 TopLink 、 JDO  等  ORM  框架的基础上发展⽽来的，

具有易于使⽤、伸缩性强等优点。从⽬前的开发社区的反应上看， JPA  受到了极⼤的⽀持和赞扬，其中就包

括了  Spring  与  EJB 3.0  的开发团队。

注意： JPA  是⼀套规范，不是⼀套产品，那么像  Hibernate 、 TopLink 、 JDO  它们是⼀套产品，如果说

这些产品实现了这个  JPA  规范，那么我们就可以称他们为  JPA  的实现产品。

### **Spring Data JPA**  ###

Spring Data JPA  是  Spring  基于  ORM  框架、 JPA  规范的基础上封装的⼀套  JPA  应⽤框架，可以让开发者⽤

极简的代码即可实现对数据的访问和操作。它提供了包括增、删、改、查等在内的常⽤功能，且易于扩展，

学习并使⽤  Spring Data JPA  可以极⼤提⾼开发效率。 Spring Data JPA  其实就是  Spring  基于  Hibernate  之

上构建的  JPA  使⽤解决⽅案，⽅便在  Spring Boot  项⽬中使⽤  JPA  技术。

Spring Data JPA  让我们解脱了  DAO  层的操作，基本上所有  CRUD  都可以依赖于它实现。

### 快速上⼿ ###

### 添加依赖 ###

<dependency>
 <groupId>org.Springframework.boot</groupId>
 <artifactId>spring-boot-starter-data-jpa</artifactId>
 </dependency>
 <dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
 </dependency>

### 添加配置⽂件 ###

spring.datasource.url=jdbc:mysql://localhost:3306/test?serverTimezone=UTC&useUnico
    de=true&characterEncoding=utf-8&useSSL=true
    spring.datasource.username=root
    spring.datasource.password=root
    spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
    spring.jpa.properties.hibernate.hbm2ddl.auto=create
    spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
    #SQL 输出
    spring.jpa.show-sql=true
    #format ⼀下 SQL 进⾏输出
    spring.jpa.properties.hibernate.format_sql=true

hibernate.hbm2ddl.auto  参数的作⽤主要⽤于：⾃动创建、更新、验证数据库表结构，有四个值。

*  create：每次加载 Hibernate 时都会删除上⼀次⽣成的表，然后根据 model 类再重新来⽣成新表，哪怕 两次没有任何改变也要这样执⾏，这就是导致数据库表数据丢失的⼀个重要原因。 
 *  create-drop：每次加载 Hibernate 时根据 model 类⽣成表，但是 sessionFactory ⼀关闭，表就⾃动删 除。 
 *  update：最常⽤的属性，第⼀次加载 Hibernate 时根据 model 类会⾃动建⽴起表的结构（前提是先建⽴ 好数据库），以后加载 Hibernate 时根据 model 类⾃动更新表结构，即使表结构改变了，但表中的⾏仍 然存在，不会删除以前的⾏。要注意的是当部署到服务器后，表结构是不会被⻢上建⽴起来的，是要等 应⽤第⼀次运⾏起来后才会。 
 *  validate ：每次加载 Hibernate 时，验证创建数据库表结构，只会和数据库中的表进⾏⽐较，不会创建 新表，但是会插⼊新值。

其中：

*  dialect 主要是指定⽣成表名的存储引擎为 InneoDB 
 *  show-sql 是否在⽇志中打印出⾃动⽣成的 SQL，⽅便调试的时候查看

实体类

@Entity
    public class User {
     @Id
     @GeneratedValue
     private Long id;
     @Column(nullable = false， unique = true)
     private String userName;
     @Column(nullable = false)
     private String passWord;
     @Column(nullable = false， unique = true)
     private String email;
     @Column(nullable = true， unique = true)
     private String nickName;
     @Column(nullable = false)
     private String regTime;
     //省略getter settet⽅法、构造⽅法
    }

下⾯对上⾯⽤的注解做⼀个解释。

*  @Entity(name="EntityName") 必须，⽤来标注⼀个数据库对应的实体，数据库中创建的表名默 认和类名⼀致。其中，name 为可选，对应数据库中⼀个表，使⽤此注解标记 Pojo 是⼀个 JPA 实体。 
 *  @Table(name=""，catalog=""，schema="") 可选，⽤来标注⼀个数据库对应的实体，数据库 中创建的表名默认和类名⼀致。通常和 @Entity 配合使⽤，只能标注在实体的 class 定义处，表示实体 对应的数据库表的信息。 
 *  @Id 必须，@Id 定义了映射到数据库表的主键的属性，⼀个实体只能有⼀个属性被映射为主键。 
 *  @GeneratedValue(strategy=GenerationType，generator="") 可选，strategy: 表示主键 ⽣成策略，有 AUTO、INDENTITY、SEQUENCE 和 TABLE 4 种，分别表示让 ORM 框架⾃动选择， generator: 表示主键⽣成器的名称。 
 *  @Column(name = "user\_code"， nullable = false， length=32) 可选，@Column 描 述了数据库表中该字段的详细定义，这对于根据 JPA 注解⽣成数据库表结构的⼯具。name: 表示数据库 表中该字段的名称，默认情形属性名称⼀致；nullable: 表示该字段是否允许为 null，默认为 true； unique: 表示该字段是否是唯⼀标识，默认为 false；length: 表示该字段的⼤⼩，仅对 String 类型的字段 有效。 
 *  @Transient 可选，@Transient 表示该属性并⾮⼀个到数据库表的字段的映射，ORM 框架将忽略该 属性。 
 *  @Enumerated 可选，使⽤枚举的时候，我们希望数据库中存储的是枚举对应的 String 类型，⽽不是 枚举的索引值，需要在属性上⾯添加 @Enumerated(EnumType.STRING) 注解。

### **Repository** 构建 ###

创建的  Repository  只要继承  JpaRepository  即可，就会帮我们⾃动⽣成很多内置⽅法。另外还有⼀个功能⾮ GitChat

常实⽤，可以根据⽅法名⾃动⽣产  SQL ，⽐如  fifindByUserName  会⾃动⽣产⼀个以  userName  为参数的查询

⽅法，⽐如  fifindAll  会⾃动查询表⾥⾯的所有数据等。

public interface UserRepository extends JpaRepository<User， Long> {
 User findByUserName(String userName);
 User findByUserNameOrEmail(String username,String email);
 }

我们只需要在对应的  Repository  中创建好⽅法，使⽤的时候直接将接⼝注⼊到类中调⽤即可。在  IDEA  中打

开类  UserRepository ，在这个类的⼤括号内的区域右键单击，选择  Diagrams | Show Diagram  选项，即可打

开类图，如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MjI3ODk2_size_16_color_FFFFFF_t_70][]

通过上图我们发现  JpaRepository  继承  PagingAndSortingRepository  和  QueryByExampleExecutor ，

PagingAndSortingRepository  类主要负责排序和分⻚内容， QueryByExampleExecutor  提供了很多示例的查

询⽅法，如下：

public interface QueryByExampleExecutor<T> { 
 <S extends T> S findOne(Example<S> example); //根据“实例”查找⼀个对象
 <S extends T> Iterable<S> findAll(Example<S> example); //根据“实例”查找⼀批对
 象
 <S extends T> Iterable<S> findAll(Example<S> example, Sort sort); //根据“实例”
 查找⼀批对象，且排序
 <S extends T> Page<S> findAll(Example<S> example, Pageable pageable); //根据“
 实例”查找⼀批对象，且排序和分⻚
 <S extends T> long count(Example<S> example); //根据“实例”查找，返回符合条件的对象
 个数
 <S extends T> boolean exists(Example<S> example); //根据“实例”判断是否有符合条件的
 对象
 }

因此，继承  JpaRepository  的会⾃动拥有上述这些⽅法和排序、分⻚功能。查看源码我们发现

PagingAndSortingRepository  ⼜继承了  CrudRepository 。 CrudRepository  的源码如下：

@NoRepositoryBean
 public interface CrudRepository<T, ID> extends Repository<T, ID> {
 <S extends T> S save(S entity);
 <S extends T> Iterable<S> saveAll(Iterable<S> entities);
 Optional<T> findById(ID id);
 boolean existsById(ID id);
 Iterable<T> findAll();
 Iterable<T> findAllById(Iterable<ID> ids);
 long count();
 void deleteById(ID id);
 void delete(T entity);
 void deleteAll(Iterable<? extends T> entities);
 void deleteAll();
 }

从  CrudRepository  的源码可以看出  CrudRepository  内置了我们最常⽤的增、删、改、查的⽅法，⽅便我们

去使⽤，因为  JpaRepository  继承了  PagingAndSortingRepository ， PagingAndSortingRepository  继承了

CrudRepository ，所以继承  JpaRepository  的类也默认拥有了上述⽅法。

因此使⽤  JPA  操作数据库时，只需要构建的  Repository  继承了  JpaRepository ，就会拥有了很多常⽤的数据

库操作⽅法。

### 测试 ###

创建好  UserRepository  之后，当业务代码中需要使⽤时直接将此接⼝注⼊到对应的类中，在  Spring Boot  启

动时，会⾃动根据注解内容创建实现类并注⼊到⽬标类中。

@RunWith(SpringRunner.class)
    @SpringBootTest
    public class UserRepositoryTests {
     @Resource
     private UserRepository userRepository;
     @Test
     public void test() {
     Date date = new Date();
     DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.LONG， Da
    teFormat.LONG); 
     String formattedDate = dateFormat.format(date);
     
     userRepository.save(new User("aa"， "aa@126.com"， "aa"， "aa123456"，format
    tedDate));
     userRepository.save(new User("bb"， "bb@126.com"， "bb"， "bb123456"，format
    tedDate));
     userRepository.save(new User("cc"， "cc@126.com"， "cc"， "cc123456"，format
    tedDate));
     Assert.assertEquals(9， userRepository.findAll().size());
     Assert.assertEquals("bb"， userRepository.findByUserNameOrEmail("bb"， "cc@
    126.com").getNickName());
     userRepository.delete(userRepository.findByUserName("aa1"));
     }
    }

上述测试⽅法简单测试了  JPA  的报错和查询功能，测试⽤例执⾏成功表示  JPA  的增、删、改成功。

### 基本查询  ###

我们可以将  Spring Data JPA  查询分为两种，⼀种是  Spring Data JPA  默认实现的，另⼀种是需要根据查询的

情况来⾃⾏构建。

### 预⽣成⽅法  ###

预⽣成⽅法就是我们上⾯看到的那些⽅法，因为继承了  JpaRepository  ⽽拥有了⽗类的这些内容。

（ 1 ）继承  JpaRepository

public interface UserRepository extends JpaRepository<User， Long> {
 }

（ 2 ）使⽤默认⽅法

@Test
    public void testBaseQuery() {
     userRepository.findAll();
     userRepository.findById(1l);
     userRepository.save(user);
     userRepository.delete(user);
     userRepository.count();
     userRepository.existsById(1l);
     // ...
    }

所有⽗类拥有的⽅法都可以直接调⽤，根据⽅法名也可以看出它的含义。

### ⾃定义查询 ###

Spring Data JPA  可以根据接⼝⽅法名来实现数据库操作，主要的语法是  fifindXXBy 、 readAXXBy 、

queryXXBy 、 countXXBy 、 getXXBy  后⾯跟属性名称，利⽤这个功能仅需要在定义的  Repository  中添加对应

的⽅法名即可，使⽤时  Spring Boot  会⾃动帮我们实现，示例如下。

根据⽤户名查询⽤户：

User findByUserName(String userName);

也可以加⼀些关键字  And 、 or ：

User findByUserNameOrEmail(String username， String email);

修改、删除、统计也是类似语法：

Long deleteById(Long id);
    Long countByUserName(String userName)

基本上  SQL  体系中的关键词都可以使⽤，如  LIKE  、 IgnoreCase 、 OrderBy ：

List<User> findByEmailLike(String email);
 User findByUserNameIgnoreCase(String userName);
 
 List<User> findByUserNameOrderByEmailDesc(String email);

可以根据查询的条件不断地添加和拼接， Spring Boot  都可以正确解析和执⾏，其他使⽤示例可以参考下表。

具体的关键字，使⽤⽅法和⽣产成  **SQL**  如下表所示:

<table style="margin-left:11.8pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:113.7pt;"> Keyword </td> 
 <td style="vertical-align:top;width:189.8pt;"> Sample </td> 
 <td style="vertical-align:top;width:229.85pt;"> JPQL snippet </td> 
 </tr> 
 </tbody> 
</table>

<table style="margin-left:11.8pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:113.7pt;"> &nbsp; And </td> 
 <td style="vertical-align:top;width:189.8pt;"> &nbsp; findByLastnameAndFirstname </td> 
 <td style="vertical-align:top;width:229.85pt;"> … where x.lastname = ?1 and x.firstname = ?2 </td> 
 </tr> 
 <tr> 
 <td style="width:113.7pt;"> &nbsp; Or </td> 
 <td style="width:189.8pt;"> &nbsp; findByLastnameOrFirstname </td> 
 <td style="width:229.85pt;"> … where x.lastname = ?1 or x.firstname = ?2 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:113.7pt;"> &nbsp; Is，Equals </td> 
 <td style="vertical-align:top;width:189.8pt;"> findByFirstnameIs， findByFirstnameEquals </td> 
 <td style="vertical-align:top;width:229.85pt;"> &nbsp; … where x.firstname = ?1 </td> 
 </tr> 
 <tr> 
 <td style="width:113.7pt;"> Between </td> 
 <td style="width:189.8pt;"> findByStartDateBetween </td> 
 <td style="width:229.85pt;"> … where x.startDate between ?1 and ?2 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:113.7pt;"> LessThan </td> 
 <td style="vertical-align:top;width:189.8pt;"> findByAgeLessThan </td> 
 <td style="vertical-align:top;width:229.85pt;"> … where x.age &lt; ?1 </td> 
 </tr> 
 <tr> 
 <td style="width:113.7pt;"> LessThanEqual </td> 
 <td style="width:189.8pt;"> findByAgeLessThanEqual </td> 
 <td style="width:229.85pt;"> … where x.age ⇐ ?1 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:113.7pt;"> GreaterThan </td> 
 <td style="vertical-align:top;width:189.8pt;"> findByAgeGreaterThan </td> 
 <td style="vertical-align:top;width:229.85pt;"> … where x.age &gt; ?1 </td> 
 </tr> 
 <tr> 
 <td style="width:113.7pt;"> GreaterThanEqual </td> 
 <td style="width:189.8pt;"> findByAgeGreaterThanEqual </td> 
 <td style="width:229.85pt;"> … where x.age &gt;= ?1 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:113.7pt;"> After </td> 
 <td style="vertical-align:top;width:189.8pt;"> findByStartDateAfter </td> 
 <td style="vertical-align:top;width:229.85pt;"> … where x.startDate &gt; ?1 </td> 
 </tr> 
 <tr> 
 <td style="width:113.7pt;"> Before </td> 
 <td style="width:189.8pt;"> findByStartDateBefore </td> 
 <td style="width:229.85pt;"> … where x.startDate &lt; ?1 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:113.7pt;"> IsNull </td> 
 <td style="vertical-align:top;width:189.8pt;"> findByAgeIsNull </td> 
 <td style="vertical-align:top;width:229.85pt;"> … where x.age is null </td> 
 </tr> 
 <tr> 
 <td style="width:113.7pt;"> IsNotNull， NotNull </td> 
 <td style="width:189.8pt;"> &nbsp; findByAge(Is)NotNull </td> 
 <td style="width:229.85pt;"> &nbsp; … where x.age not null </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:113.7pt;"> Like </td> 
 <td style="vertical-align:top;width:189.8pt;"> findByFirstnameLike </td> 
 <td style="vertical-align:top;width:229.85pt;"> … where x.firstname like ?1 </td> 
 </tr> 
 <tr> 
 <td style="width:113.7pt;"> NotLike </td> 
 <td style="width:189.8pt;"> findByFirstnameNotLike </td> 
 <td style="width:229.85pt;"> … where x.firstname not like ?1 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:113.7pt;"> &nbsp; StartingWith </td> 
 <td style="vertical-align:top;width:189.8pt;"> &nbsp; findByFirstnameStartingWith </td> 
 <td style="vertical-align:top;width:229.85pt;"> … where x.firstname like ?1 (parameter bound with appended %) </td> 
 </tr> 
 <tr> 
 <td style="width:113.7pt;"> &nbsp; EndingWith </td> 
 <td style="width:189.8pt;"> &nbsp; findByFirstnameEndingWith </td> 
 <td style="width:229.85pt;"> … where x.firstname like ?1 (parameter bound with prepended %) </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:113.7pt;"> &nbsp; Containing </td> 
 <td style="vertical-align:top;width:189.8pt;"> &nbsp; findByFirstnameContaining </td> 
 <td style="vertical-align:top;width:229.85pt;"> … where x.firstname like ?1 (parameter bound wrapped in %) </td> 
 </tr> 
 <tr> 
 <td style="width:113.7pt;"> &nbsp; OrderBy </td> 
 <td style="width:189.8pt;"> &nbsp; findByAgeOrderByLastnameDesc </td> 
 <td style="width:229.85pt;"> … where x.age = ?1 order by x.lastname desc </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:113.7pt;"> Not </td> 
 <td style="vertical-align:top;width:189.8pt;"> findByLastnameNot </td> 
 <td style="vertical-align:top;width:229.85pt;"> … where x.lastname &lt;&gt; ?1 </td> 
 </tr> 
 <tr> 
 <td style="width:113.7pt;"> In </td> 
 <td style="width:189.8pt;"> findByAgeIn(Collection ages) </td> 
 <td style="width:229.85pt;"> … where x.age in ?1 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:113.7pt;"> NotIn </td> 
 <td style="vertical-align:top;width:189.8pt;"> findByAgeNotIn(Collection age) </td> 
 <td style="vertical-align:top;width:229.85pt;"> … where x.age not in ?1 </td> 
 </tr> 
 <tr> 
 <td style="width:113.7pt;"> &nbsp; </td> 
 <td style="width:189.8pt;"> &nbsp; </td> 
 <td style="width:229.85pt;"> &nbsp; </td> 
 </tr> 
 </tbody> 
</table>

### 总结 ###

通过这节课的学习发现使⽤  JPA  ⼤⼤解放了我们对数据库的操作，经常使⽤的  SQL  ⼤部分都已经被预⽣

成，直接使⽤即可。另外  JPA  还有⼀个特点，那就是再也不⽤关⼼数据库的表结构了，需要更改的时候只需

要修改对应  Model  的属性即可。在微服务架构中，因为服务拆分得越来越⼩，微服务内部只关⼼⾃⼰的业

务，需要复杂查询的场景会越来越少，在微服务架构中更推荐使⽤  JPA  技术。

[点击这⾥下载源码][Link 1]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MjI3ODk2_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200103155039757.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MjI3ODk2,size_16,color_FFFFFF,t_70
[Link 1]: https://github.com/ityouknow/spring-boot-leaning/tree/gitbook_column2.0