Spring Data JPA 原理与实战第一天 JPA初识

开篇词 勇敢走出舒适区，突破自己的技术瓶颈

你好，我是张振华，在 Java 领域从业已有十几年，也算是一个“Java 老兵”，我曾先后在驴妈妈、携程等互联公司分别担任 Java 架构师、开发主管等职务。在电商公司工作期间，我负责过后端服务的平台架构、实现过微服务的升级，同时写过公司的很多核心框架，经历了很多人都会遇到的一些常见问题，积累并总结了一些可以复用和迁移的经验。

我是如何学习 Spring Data JPA 的？

大概 4、5 年前，公司入职了一些架构师，引入了 Spring Data JPA 框架，起初接触时我很排斥，心想：这么复杂的框架真不如 MyBatis 简单，我写个简单的 SQL 就好了，为什么要学习 JPA 呢？

而且还要学习一大堆相关联的东西（比如要了解 Session 原理），这么复杂，它有什么好处呀？加上那时候我对框架 JPA 的理解还不是很深入，没有研究背后原理，写的代码会遇见各种 Bug……

但当我冷静下来，意识到其实是自己的舒适区在作怪，既然公司的一些资深架构师引入了这门技术，它肯定是有好处的，不如我先用着，详细掌握了才能知道它到底好不好。做技术的嘛，总要有点追求，有点极客的精神，否则就容易跟不上技术发展的速度。

于是，我决心研究一番。而那时候，大神们只负责引入 Spring Data JPA 技术，不负责讲解原因，所以自己摸索着用起来比较吃力，确实走了不少弯路。我在一开始只掌握了 Spring Data JPA 的基本用法时遇到了一些问题（比如一个最常见的动态 SQL 问题），由于研究得不太多，用起来别手别脚的，虽然功能实现了，但总感觉不是最佳实践，反而降低了开发效率。

后来我通过参考官方文档、网上搜索零星的资料，逐渐掌握了一些高级用法。但遇到一些复杂的场景，比如在多线程、高并发情况下发现问题时，还是不知道怎么回事。这时我发现 JPA 协议的最佳实现者是 Hibernate，于是我又读了 Hibernate 的文档，发现 Hibernate 已经发展好几代了，远不像我们之前想得那么复杂，这才了解了一些基本原理。懂了原理后，就基本可以套用来解决很多异常问题了，同时发生的怪异问题也可以轻松解决了。

随着自己对 JPA 使用得越来越熟练，Bug 没有那么多了，开发效率确实提升了，我明显感觉自己的技术能力也提升了很多，如对 Session、事务、连接池理解得更深入了。并且我发现 Spring Data JPA 框架里面有很多优秀的思想，比如乐观锁的处理、分页和排序统一处理、语义化的方法名、动态代理、策略模式等，这些可以为我们自己写框架的时候做知识储备，这些思想和方法都是值得去学习和借鉴的。

为了让自己更加熟悉这门技术，也为避免在工作中给别人讲解的时候误导他人，后来我抽时间看了官方的 Java Persistence API 约定和规范，又找了一些业内的大牛沟通讨论，知道了哪些 Hibernate 设计得比较好、哪些设计得不好，以及我们在实际开发中最好避免使用的技术点。

再后来我为了一探究竟，抽空写文章、写书，利用简单的案例去 Debug Spring Data JPA 的源码，去思考为什么会有这种语法，具体是怎么写的。通过这一系列动作，我又收获了运行原理和用法的最佳实践。

这些经验都让我得到了一些技术层面的提升，通过公司内部分享也让身边的同事眼前一亮，并顺利实现了公司框架的升级，从而也顺利地升职和加薪。因为我在其中真正受益了，所以如今我想把自己的这份经历和经验系统整理后分享给你，希望可以帮助你少走一些弯路。

Spring Data JPA 有啥优势？

至今，我所在公司的大部分项目都在用 Spring Data JPA，究其原因，我认为主要缘于它具有以下 4 点优势。

第一，大势所趋，大厂必备技能。 近两年由于 Spring Cloud、Spring Boot 逐渐统一 Java 的框架江湖，而与 Spring Boot 天然集成的 Spring Data JPA 也逐渐走进了 Java 开发者的视野，大量尝鲜者享受到了这门技术带来的便利与功能。JPA 可以使团队在框架约定下进行开发，几乎很难出现有性能瓶颈的 SQL。因此你会发现很多大厂，如阿里、腾讯、抖音等公司，近几年在招聘的时候写明了要熟悉 JPA，这些大厂以及业内很多开源的新项目都在使用 JPA。

第二，提升开发效率。现在有很多人知道什么是 Spring Data JPA，但是却觉得 JPA 很难用，使用中发现 Bug 不知道原因，本来用 JPA 是为了提升开发效率的，不会使用反倒踩了很多坑，所以我们需要体系化地学习。当你遇到复杂问题，比如平时你可能要花几个小时去想方法名、SQL 逻辑，如果你可以熟练使用 JPA，那么半小时甚至几分钟就可以写好查询方法了；再配合测试用例，你的开发质量也会明显提高很多，系统地学习可以让你少走很多弯路。

第三，提高技术水平。 Spring Data 对数据操作进行了大统一，统一了抽象关系型数据库和非关系型数据的接口、公共的部分，你会发现当掌握了 Spring Data JPA 框架后，你的开发水平几乎可以达到——轻易实现 Redis、MongoDB 等 NoSQL 的操作，因为它们都有统一的 Spring Data Common。如下图所示，从中你可以看到 Spring Data 和 JPA 的全景位置关系，这样一来，你可以清楚地知道 JPA 的重要作用，方便你了解 JPA 的脉络，从而更好地学习。

第四，求职加分项。如果简历中突出 Spring Data JPA 框架的使用，面试官会眼前一亮。因为掌握了 JPA，就意味着掌握了很多原理，比如 Session 原理、事务原理、PersistenceContext 原理等，而掌握了底层原理对于技术人员来说可以在开发中解决很多问题。因此，公司可以由此更好地过滤和筛选人才，也能从侧面看出求职者是否对技术足够感兴趣、有追求。我认为未来 3~5 年使用 Spring Data JPA 的人会越来越多，你可以在拉勾招聘网站上看到，很多招聘信息都要求熟练掌握 Spring Data JPA。

为什么写作这门课？

不仅是因为我经历了上述那些曲折的实践，还因为我看到不少朋友在学习 Spring Data JPA 的过程中，存在不同的困惑和难点，这让我有了分享自身经验，给人帮助的想法。

当我们刚开始学习 Spring Data JPA 的时候，往往都会想到直接去看它的官方文档，但是发现其描述得太简单，经常会“知其然而不知其所以然”。有时候照着官方例子来操作，发现有问题又不知道错在哪里，这是因为不了解其精髓和背后原理，所以不容易上手。

而 Spring Data JPA 是对 Hibernate 的封装和增强，但由于之前国内用 Hibernate 的人不是特别多，导致中文资料特别少，大部分都是直接翻译过来的，比较散且不太系统，没办法纵览全局，导致我们对原理掌握不是特别清楚。

所以，当我们遇到比如 Session、事务、Lazy 异常等各种问题时，发现官方没有详细介绍，只能自己 Debug、硬啃源码才能解决问题，这时就需要花费大量时间来研究源码，但又找不到可以参考的资料，而且不是每个公司都有大神愿意教你，此时多么希望有点经验可以参考呀。

于是我带着多年的实战经验来了，在这里我想告诉你，其实 Spring Data JPA 不难，只要你静下心来，花时间研究，跟着我的节奏，把这门课程按顺序都看完，你就会觉得这门技术原来如此简单，在解决实际问题的时候就会游刃有余，你会觉得 JPA 真的被行业低估了！

课程设计

本课程即我多年来的经验总结，我以“语法 + 源码 + 原理 + 实战经验”的形式全面介绍 Spring Data JPA，可以帮助你节省 3 年左右自己研究的时间。当你深入研究和理解了之后，就会发现这真是个好东西，从而真正掌握和发掘出 Spring Data JPA 的实践价值。

课程主要分为 4 个模块，共 31 课时。

模块一：基础知识，主要从基本语法的视角，来详细介绍 Spring Data JPA 的语法糖有哪些，包括相关的源码剖析、实际工作中的经验分享等。内容涵盖你在工作中会用到的 Repository、Defining Query Methods、@Query 的语法，以及实体（Entity）的注解等内容，让你全面掌握 JPA 的基本用法。

模块二：高级用法与实战，从实际工作中的复杂应用场景开始，为你讲解 Repository 自定义场景，MVC 参数的扩展，以及数据源、事务、连接之间的关系等，帮助你解决实践中可能会遇到的问题，让你学会独立思考、稳妥解决。

模块三：原理与问题排查，掌握了基础知识和复杂使用场景后，再来了解其背后的原理： Entity 如何判断 Dirty、Entity 什么时机提交到数据库、Lazy 发生的原因是什么、N+1 SQL 如何优化等。针对实际工作中踩过的坑，为你讲解我的解决思路和方法。

模块四：思路扩展，课程的最后我从 Spring Data Rest、测试用例、Spring Data ES 的角度来带你扩展下思路，了解一下发展方向，因为这三块内容深挖了一下生态关系，可以为你打开思路，更好地帮助你掌握前面所学，做到举一反三，同时也会大大提高你的开发效率，使你的代码质量更有保障。当你掌握了之后，就不是天天忙着“救火”，而是想着如何排除失火的隐患。

讲师寄语

希望你能节省一顿饭的钱，来学习这门课程，因为这门专栏不仅告诉你这是什么、怎么用的，还会教会你学习步骤、学习方法，希望你能成为技术极客。

相信能把整个课程认认真真看完的同学，你的技术和思考方式一定会达到质的飞越。也欢迎你在留言区发表你的学习感悟以及遇到的困难和挑战，大家一起讨论学习，共同进步。

最后希望你在学习本课程的时候，保持空杯心态（不只是这门课程，在看其他技术文章时也一样），因为只有空杯，我们才能装下更多的东西。接下来，让我们开始吧！

---

01 Spring Data JPA 初识

课程正式开始了，这里我会以一个案例的形式来和你讲解如何通过 Spring Boot 结合 Spring Data JPA 快速启动一个项目、如何使用 UserRepository 完成对 User 表的操作、如何写测试用例等几个知识点，同时带你体验一下 Spring Data JPA 的优势。通过这个课时，希望你能够对 JPA 建立一个整体的认识。

提示：在本课程中如果没有特殊说明，JPA 就是指 Spring Data JPA。

话不多说，我们先来看一个案例。

Spring Boot 和 Spring Data JPA 的 Demo演示

我们利用 JPA + Spring Boot 简单做一个 RESTful API 接口，方便你来了解 Spring Data JPA 是干什么用的，具体步骤如下。

第一步：利用 IDEA 和 SpringBoot 2.3.3 快速创建一个案例项目。

点击“菜单” | New Project 命令，选择 Spring Initializr 选项，如下图所示。

这里我们利用 Spring 官方的 Start 来创建一个项目，接下来选择 Spring Boot 的依赖：

• Lombok：帮我们创建一个简单的 Entity 的 POJO，主要用来省去创建 GET 和 SET 方法；

• Spring Web：MVC 必备组件；

• Spring Data JPA：重头戏，这是本课时的重点内容；

• H2 Database：内存数据库；

• Spring Boot Actuator：监控我们项目状态使用。

然后通过下图操作界面选择上面提到的这些依赖，如下图所示：

第二步：通过 IDEA 的图形化界面，一路单击 Next 按钮，然后单击 Finsh 按钮，得到一个工程，完成后结构如下图所示：

现在我们已经可以创建一个 Spring Boot + JPA 的项目了，那么接下来我们看看怎么对 User 表进行增删改查操作。

第三步：新增 3 个类来完成对 User 的 CURD。

第一个类：新增 User.java，它是一个实体类，用来做 User 表的映射的，如下所示：

package com.example.jpa.example1;
import lombok.Data;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
@Entity
@Data
public class User {
   @Id
   @GeneratedValue(strategy= GenerationType.AUTO)
   private Long id;
   private String name;
   private String email;
}

第二个类：新增 UserRepository，它是我们的 DAO 层，用来操作实体 User 进行增删改成操作，如下所示：

package com.example.jpa.example1;
import org.springframework.data.jpa.repository.JpaRepository;
public interface UserRepository extends JpaRepository<User,Long> {
}

第三个类：新增 UserController，它是 Controller，用来创建 Rest 的 API 的接口的，如下所示：

package com.example.jpa.example1;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping(path = "/api/v1")
public class UserController {
   @Autowired
   private UserRepository userRepository;
   /**
    * 保存用户
    * @param user
    * @return
    */
   @PostMapping(path = "user",consumes = {MediaType.APPLICATION_JSON_VALUE})
   public User addNewUser(@RequestBody User user) {
      return userRepository.save(user);
   }
   /**
    * 根据分页信息查询用户
    * @param request
    * @return
    */
   @GetMapping(path = "users")
   @ResponseBody
   public Page<User> getAllUsers(Pageable request) {
      return userRepository.findAll(request);
   }
}

最终，我们的项目结构变成如下图所示的模样：

上图中，appliaction.properties 里面的内容是空的，到现在三步搞定，其他什么都不需要配置，直接点击 JpaApplication 这个类，就可启动我们的项目了。

第四步：调用项目里面的 User 相关的 API 接口测试一下。

我们再新增一个 JpaApplication.http 文件，内容如下：

POST /api/v1/user HTTP/1.1
Host: 127.0.0.1:8080
Content-Type: application/json
Cache-Control: no-cache
{"name":"jack","email":"123@126.com"}
#######
GET http://127.0.0.1:8080/api/v1/users?size=3&page=0
###

点击“运行”按钮，效果如下图所示：

运行结果如下：

POST http://127.0.0.1:8080/api/v1/user
HTTP/1.1 200 
Content-Type: application/json
Transfer-Encoding: chunked
Date: Sat, 22 Aug 2020 02:48:43 GMT
Keep-Alive: timeout=60
Connection: keep-alive
{
  "id": 4,
  "name": "jack",
  "email": "123@126.com"
}
Response code: 200; Time: 30ms; Content length: 44 bytes
GET http://127.0.0.1:8080/api/v1/users?size=3&page=0
HTTP/1.1 200 
Content-Type: application/json
Transfer-Encoding: chunked
Date: Sat, 22 Aug 2020 02:50:20 GMT
Keep-Alive: timeout=60
Connection: keep-alive
{
  "content": [
    {
      "id": 1,
      "name": "jack",
      "email": "123@126.com"
    },
    {
      "id": 2,
      "name": "jack",
      "email": "123@126.com"
    },
    {
      "id": 3,
      "name": "jack",
      "email": "123@126.com"
    }
  ],
  "pageable": {
    "sort": {
      "sorted": false,
      "unsorted": true,
      "empty": true
    },
    "offset": 0,
    "pageNumber": 0,
    "pageSize": 3,
    "unpaged": false,
    "paged": true
  },
  "totalPages": 2,
  "last": false,
  "totalElements": 4,
  "size": 3,
  "number": 0,
  "numberOfElements": 3,
  "sort": {
    "sorted": false,
    "unsorted": true,
    "empty": true
  },
  "first": true,
  "empty": false
}
Response code: 200; Time: 59ms; Content length: 449 bytes

关于 IDEA 运行 Gradle 项目的小技巧： 在实际工作中，我们启动运行或者是跑测试用例的时候，经常以 Gradle 的方式运行，或者用 Application 的方式运行，两种方式进行随意切换，需要设置的地方如下图所示：

通过以上案例，我们知道了 Spring Data JPA 可以帮我们做数据的 CRUD 操作，掌握到了JPA + Spring Boot 如何启动和集成 JPA，以及对如何创建一个数据库操作也有了一定的了解。那么接下来，我们看下是如何切换默认数据源的，如切换成 MySQL。

JPA 如何整合 MySQL 数据库？

关于 JPA 与 MySQL 的集成我们分为两部分来展开：如何切换 MySQL 数据源、如何写测试用例进行测试。

1. 切换 MySQL 数据源

上面的例子，我们采用的是默认 H2 数据源的方式，这个时候你肯定会问：“H2 重启，数据丢失了怎么办？”那么我们调整一下上面的代码，以 MySQL 作为数据源，看看需要改动哪些。

第一处改动，application.properties 内容如下：

spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=root
spring.jpa.generate-ddl=true

第二处改动，删除 H2 数据源，新增 MySQL 数据库驱动：

调整完毕之后，我们重启这个项目，以同样的方式测试上面的两个接口依然 OK。

其实这个时候可以发现一件事情，那就是我没有手动去创建任何表，而 JPA 自动帮我创建了数据库的 DDL，并新增了 User 表，所以当我们用 JPA 之后创建表的工作就不会那么复杂了，我们只需要把实体写好就可以了。

以上是切换 MySQL 数据源需要进行的操作，接下来看看测试用例怎么写，在修改代码的时候我们就不需要频繁重启项目了，当你掌握 JUnit 之后，可以提升开发效率。

2. Spring Data JPA 测试用例的写法

我们这里只关注 Repository 的测试用例的写法，Controller 和 Service 等更复杂的测试我们在测试课时再详细介绍，这里我们先快速体验一下。

第一步，在 Test 目录里增加 UserRepositoryTest 类：

package com.example.jpa.example1;
import org.junit.Assert;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import java.util.List;
@DataJpaTest
public class UserRepositoryTest {
    @Autowired
    private UserRepository userRepository;
    @Test
    public void testSaveUser() {
        User user = userRepository.save(User.builder().name("jackxx").email("123456@126.com").build());
        Assert.assertNotNull(user);
        List<User> users= userRepository.findAll();
        System.out.println(users);
        Assert.assertNotNull(users);
    }
}

第二步，我们可直接运行测试用例，进行真实的 DB 操作，通过控制台来看下我们的测试用例是否能够跑通，如下图所示：

通过上图可以看到，测试的时候执行的 SQL 有哪些，那么我们到底是连接的 MySQL 做的测试用例，还是连接的 H2 做的测试呢？在后面的第 30 课时（单元测试和集成测试）的时候我会为你详细揭晓，到时你会发现测试用例写起来也是如此简单。

整体认识 JPA

通过上面的两个例子我们已经快速入门了，知道了 Spring Boot 结合 Spring Data JPA 怎么配置和启动一个项目 ，之后当你熟悉了 JPA 之后，你还会发现 Spring Boot JPA 要比我们配置 MyBatis 简单很多。下面我们来整体认识一下 Java Persistence API 究竟是什么。

介绍 JPA 协议之前，我们先来对比了解下市面上的 ORM 框架有哪些，分别有哪些优缺点，做到心里有数。

1. 市场上 ORM 框架比对

下表是市场上比较流行的 ORM 框架，这里我罗列了 MyBatis、Hibernate、Spring Data JPA 等，并对比了下它们的优缺点。

经过对比，你可以看到我们正在学习的 Spring Data JPA 还是比较前卫的，很受欢迎，继承了 Hibernate 的很多优点，上手又比较简单。所以，我非常建议你好好学习一下。

2. Java Persistence API 介绍和开源实现

JPA 是 JDK 5.0 新增的协议，通过相关持久层注解（@Entity 里面的各种注解）来描述对象和关系型数据里面的表映射关系，并将 Java 项目运行期的实体对象，通过一种Session持久化到数据库中。

想象一下，一旦协议有了，大家都遵守了此种协议进行开发，那么周边开源产品就会大量出现，比如我们在后面要介绍的第 29 课时（Spring Data Rest 是什么？和 JPA 是什么关系？）就可以基于这套标准，进而对 Entity 的操作再进行封装，从而可以得到更加全面的 Rest 协议的 API接口。

再比如 JSON API（https://jsonapi.org/）协议，就是雅虎的大牛基于 JPA 的协议的基础，封装制定的一套 RESTful 风格、JSON 格式的 API 协议，那么一旦 JSON API 协议成了标准，就会有很多周边开源产品出现。比如很多 JSON API 的客户端、现在比较流行的 Ember 前端框架，就是基于 Entity 这套 JPA 服务端的协议，在前端解析 API 协议，从而可以对普通 JSON 和 JSON API 的操作进行再封装。

所以规范是一件很有意思的事情，突然之间世界大变样，很多东西都一样了，我们的思路就需要转换了。

JPA 的内容分类

• 一套 API 标准定义了一套接口，在 javax.persistence 的包下面，用来操作实体对象，执行 CRUD 操作，而实现的框架（Hibernate）替代我们完成所有的事情，让开发者从烦琐的 JDBC 和 SQL 代码中解脱出来，更加聚焦自己的业务代码，并且使架构师架构出来的代码更加可控。

• 定义了一套基于对象的 SQL：Java Persistence Query Language（JPQL），像 Hibernate 一样，我们通过写面向对象（JPQL）而非面向数据库的查询语言（SQL）查询数据，避免了程序与数据库 SQL 语句耦合严重，比较适合跨数据源的场景（一会儿 MySQL，一会儿 Oracle 等）。

• ORM（Object/Relational Metadata）对象注解映射关系，JPA 直接通过注解的方式来表示 Java 的实体对象及元数据对象和数据表之间的映射关系，框架将实体对象与 Session 进行关联，通过操作 Session 中不通实体的状态，从而实现数据库的操作，并实现持久化到数据库表中的操作，与 DB 实现同步。

详细的协议内容你感兴趣的话也可以看一下官方的文档。

JPA 的开源实现

JPA 的宗旨是为 POJO 提供持久化标准规范，可以集成在 Spring 的全家桶使用，也可以直接写独立 application 使用，任何用到 DB 操作的场景，都可以使用，极大地方便开发和测试，所以 JPA 的理念已经深入人心了。Spring Data JPA、Hibernate 3.2+、TopLink 10.1.3 以及 OpenJPA、QueryDSL 都是实现 JPA 协议的框架，他们之间的关系结构如下图所示：

俗话说得好：“未来已经来临，只是尚未流行”，大神资深开发用 Spring Data JPA，编程极客者用 JPA；而普通 Java 开发者，不想去挑战的 Java“搬砖者”用 Mybatis。

到这里，相信你已经对 JPA 有了一定的认识，接下来我们了解一下 Spring Data，看看它都有哪些子项目。

Spring Data 认识

1. Spring Data 介绍

Spring Data 项目是从 2010 年开发发展起来的，Spring Data 利用一个大家熟悉的、一致的、基于“注解”的数据访问编程模型，做一些公共操作的封装，它可以轻松地让开发者使用数据库访问技术，包括关系数据库、非关系数据库（NoSQL）。同时又有不同的数据框架的实现，保留了每个底层数据存储结构的特殊特性。

Spring Data Common 是 Spring Data 所有模块的公共部分，该项目提供了基于 Spring 的共享基础设施，它提供了基于 repository 接口以 DB 操作的一些封装，以及一个坚持在 Java 实体类上标注元数据的模型。

Spring Data 不仅对传统的数据库访问技术如 JDBC、Hibernate、JDO、TopLick、JPA、MyBatis 做了很好的支持和扩展、抽象、提供方便的操作方法，还对 MongoDb、KeyValue、Redis、LDAP、Cassandra 等非关系数据的 NoSQL 做了不同的实现版本，方便我们开发者触类旁通。

其实这种接口型的编程模式可以让我们很好地学习 Java 的封装思想，实现对操作的进一步抽象，我们也可以把这种思想运用在自己公司写的 Framework 上面。

下面来看一下 Spring Data 的子项目都有哪些。

2. Spring Data 的子项目有哪些

下图为目前 Spring Data 的框架分类结构图，里面都有哪些模块可以一目了然，也可以知道哪些是我们需要关心的项目。

主要项目（Main Modules）：

• Spring Data Commons，相当于定义了一套抽象的接口，下一课时我们会具体介绍

• Spring Data Gemfire

• Spring Data JPA，我们关注的重点，对 Spring Data Common 的接口的 JPA 协议的实现

• Spring Data KeyValue

• Spring Data LDAP

• Spring Data MongoDB

• Spring Data REST

• Spring Data Redis

• Spring Data for Apache Cassandra

• Spring Data for Apache Solr

社区支持的项目（Community Modules）：

• Spring Data Aerospike

• Spring Data Couchbase

• Spring Data DynamoDB

• Spring Data Elasticsearch

• Spring Data Hazelcast

• Spring Data Jest

• Spring Data Neo4j

• Spring Data Vault

其他（Related Modules）：

• Spring Data JDBC Extensions

• Spring for Apache Hadoop

• Spring Content

关于 Spring Data 的子项目，除了上面这些，还有很多开源社区版本，比如 Spring Data、MyBatis 等，这里就不一一介绍了，感兴趣的同学可以到 Spring 社区，或者 GitHub 上进行查阅。

总结

本课时的主要目的是带领你快速入门，从 H2 数据源和 Mysql 数据源两个方面为你介绍了 Spring Data JPA 数据操作的概念，了解了 Repository 的写法，快速体验一把 Spring Data JPA 的便捷之处。

希望你通过本节课的学习可以对 Spring Data JPA + Spring Boot 有一个整体的认识，为以后的技术进阶打下良好的基础。在掌握了基本知识以后，你会发现 Spring Data JPA 是 ORM 的效率利器，后面课程我会一一揭开 Spring Data JPA 的神秘面纱，带你掌握其实现原理和实战经验，让你在实际开发中游刃有余。

对于本课时所讲的知识点，欢迎你在下方留言区表达自己的学习感悟，大家一起讨论，共同进步。

补充一个TIPS：课程中的案例是依赖 lombok 插件的，如下图所示：

并开启 annotation processing。

点击下方链接查看源码（不定时更新）
https://github.com/zhangzhenhuajack/spring-boot-guide/tree/master/spring-data/spring-data-jpa

---