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

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 选项，即可打

开类图，如下：

通过上图我们发现 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 如下表所示:

Keyword

Sample

JPQL snippet

And	findByLastnameAndFirstname	… where x.lastname = ?1 and x.firstname = ?2
Or	findByLastnameOrFirstname	… where x.lastname = ?1 or x.firstname = ?2
Is，Equals	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	findByAgeIsNull	… 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 (parameter bound with appended %)
EndingWith	findByFirstnameEndingWith	… where x.firstname like ?1 (parameter bound with prepended %)
Containing	findByFirstnameContaining	… where x.firstname like ?1 (parameter bound wrapped in %)
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 age)	… where x.age not in ?1

 

总结

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

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

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

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

 

点击这⾥下载源码