SpringData JPA - ORM 框架下，打造高效数据访问层

一、SpringData JPA 概述

1.1、什么是 JPA

1.2、什么是 ORM

1.3、什么是 Hibernate

1.4、JPA 和 Hibernate 的关系

1.5、JPA 的优势

二、SpringData JPA 实战开发

2.1、依赖

2.2、配置文件

2.3、启动类

2.4、创建实体

2.5、基于 JpaRepository 的 CRUD

三、SpringDataJPA 多种查询方式

3.1、JpaRepository 查询

3.2、方法命名规则查询

3.3、JPQL 查询

3.4、SQL 查询

3.5、JpaSpecificationExecutor 动态查询

一、SpringData JPA 概述

1.1、什么是 JPA

全英文名叫 Java Persistence API，就是 java 持久化 api ，是SUN公司推出的一套基于 ORM 的规范。

1.2、什么是 ORM

ORM（Object Relational Mapping）表示对象关系映射. 简单来讲，通过 ORM，就可以把对象映射到关系型数据库中（为了不用 JDBC 那套方法来操作数据库）.

1.3、什么是 Hibernate

Hibernate 是一个对象关系映射框架，对 JDBC 进行了非常轻量级的封装，将对象与数据库简历映射关系，一个全自动的 ORM 框架. Hibernate 可以自动生成 SQL 语句，自动执行，使得 Java 程序员可以通过面向对象的思想来操纵数据库.

1.4、JPA 和 Hibernate 的关系

JPA 和 Hibernate 的关系就像 JDBC 和 JDBC驱动的关系，JPA 是规范，Hibernate 除了作为 ORM 框架之外，也是一种 JPA 实现.

简单来讲，如果使用 JPA 规范数据库操作，底层需要 Hibernate 作为其实现完成持久化.

1.5、JPA 的优势

a）标准化：

JPA 是 Java EE 标准之一，因此任何声称符合 JPA 标准的框架都需要遵循同样的框架，提供相同的 API，大大提高了可移植性性.

b）特性支持：

JPA 框架支持大数据集、事务、并发等容器级事务，在大型企业中发挥极大作用.

c）使用方便：

JPA 的主要目标之一就是提供更加简单的编程模型：在 JPA 框架下创建实体和创建 Java 类一样简单，没有任何限制和约束，只需要使用 javax.persistence.Entity 注解. 另外还提供很多基础 CRUD，避免重复造轮子

d）高级特性：

JPA 中支持面向对象的高级特性，例如类之间的继承、多态... 使得开发者最大限度的使用面向对象的模型设计企业应用.

二、SpringData JPA 实战开发

2.1、依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.49</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

2.2、配置文件

server:
  port: 9000

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/jpa?characterEncoding=utf8&useSSL=false
    username: root
    password: DJSAKOFH0*)(shdf*s*&_(fsbpf*&s)_fg*@_&fg@{!p_#*t_@!bfugiwofhg
    driver-class-name: com.mysql.jdbc.Driver
  jpa:
    database: mysql
    show-sql: true # 显示 sql 语句（项目上线后记得关闭）
    hibernate:
      ddl-auto: update
    open-in-view: false # 一般来讲，建议关闭

ddl-auto 熟悉用于设置自动表，可以实现自动在数据库中为我们创建一个表，表的结构会根据我们定义的实体类决定，具体有 4 种值：

create：启动时删除数据库中表，然后创建，退出时不删除数据表.
create-drop：启动时删除数据库中表，然后创建，退出时删除数据表，并且如果不存在就报错.
update：如果启动时表格式不一致则更新表，原有数据保留
validate：项目启动时，表结构进行校验，不一致则报错.
none：不采取任何措施.

Ps：表可以是自动创建的，但是数据库必须我们手动创建.

2.3、启动类

@EnableJpaAuditing //用来开启 JPA 审计功能
@SpringBootApplication
class JpaApplication

fun main(args: Array<String>) {
    runApplication<JpaApplication>(*args)
}

@EnableJpaAuditing：用来开启 JPA 审计功能，比如在建表中经常会加入版本号、创建时间、修改时间、创建者、修改者这五个字段. 为了简化开发，可以将其交给 JPA 来自动填充.

2.4、创建实体

import com.fasterxml.jackson.annotation.JsonFormat
import org.springframework.data.annotation.CreatedBy
import org.springframework.data.annotation.CreatedDate
import org.springframework.data.annotation.LastModifiedBy
import org.springframework.data.annotation.LastModifiedDate
import org.springframework.data.jpa.domain.support.AuditingEntityListener
import java.util.*
import javax.persistence.Column
import javax.persistence.Entity
import javax.persistence.EntityListeners
import javax.persistence.GeneratedValue
import javax.persistence.GenerationType
import javax.persistence.Id
import javax.persistence.Table
import javax.persistence.Version

@Entity
@Table(name = "user_info")
@EntityListeners(AuditingEntityListener::class)
data class Userinfo(

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Long? = null,

    val username: String,

    val age: Int,

    //注意，关于审计信息，都需要使用 var 类型

    @Version
    var version: Long? = null,

    @CreatedBy
    @Column(name = "c_by")
    var cBy: String? = null,

    @LastModifiedBy
    @Column(name = "u_by")
    var uBy: String? = null,

    @CreatedDate
    @field:JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    @Column(name = "c_time")
    var cTime: Date? = null,

    @LastModifiedDate
    @field:JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    @Column(name = "u_time")
    var uTime: Date? = null,

)

注解	作用	常用属性
@Data	给实体类加get/set/toString/EqualsAndHashCode方法，是lombok的注解
@Entity	指定当前类是实体类
@Table	指定实体类和表之间的对应关系	name：指定数据库表的名称
@EntityListeners	在实体类增删改的时候监听，为创建人/创建时间等基础字段赋值	value：指定监听类
@Id	指定当前字段是主键
@SequenceGenerator	指定数据库序列别名	sequenceName：数据库序列名 name：取的别名
@GeneratedValue	指定主键的生成方式	strategy ：指定主键生成策略（一般设置为GenerationType.IDENTITY，表示自增长） generator：选择主键别名
@Column	指定实体类属性和数据库表之间的对应关系（如果成员变量名和表字段名对应一致，可以省略）	name：指定数据库表的列名称。 unique：是否唯一 nullable：是否可以为空 nserttable：是否可以插入 updateable：是否可以更新 columnDefinition: 定义建表时创建此列的DDL
@CreatedBy	自动插入创建人
@CreatedDate	自动插入创建时间
@LastModifiedBy	自动修改更新人
@LastModifiedDate	自动修改更细时间
@Version	自动更新版本号
@JsonFormat	插入/修改/读取的时间转换成想要的格式	pattern：展示格式 timezone：国际时间

解释：

a）主键策略：

SEQUENCE 策略适合拥有序列的数据库，比如 Oracle；
IDENTITY 策略适合拥有主键自增长的数据库，比如 MySQL；
TABLE 策略是通过一张序列表来维护主键插入的值的，所以适合所有数据库；
AUTO 策略是 JPA 自行判断使用上面三个中的哪一个作为主键生成策略；

开发人员应该自行判断使用的是何种数据库，而不是由 JPA 进行判断。

b）审计功能

@Version：版本号；进行 update 操作时启动乐观锁，@Version 修饰的字段值与数据库中字段值一致才能进行修改
@CreatedDate ：创建时间；进行 insert 操作时，将当前时间插入到 @CreatedDate 修饰字段中；进行 update 操作时，会随实体类中的 @CreatedDate 修饰的字段值进行修改
@CreatedBy：创建人；进行 insert 操作时，将当前用户名插入到 @CreatedBy 修饰字段中；进行update操作时，会随实体类中的 @CreatedBy 修饰的字段值进行修改
@LastModifiedDate：最后一次修改时间；进行 update 操作时，将当前时间修改进@LastModifiedDate 修饰字段中；进行 insert 操作时，将当前时间插入到 @LastModifiedDate 修饰字段中
@LastModifiedBy ：最后一次修改的修改人；进行 update 操作时，将当前修改人修改进@LastModifiedBy 修饰的字段中；进行 insert 操作时，将当前用户名插入到@LastModifiedBy修饰字段中

c）启动审计条件：

启动类上有 @EnableJpaAuditing 注解.
实体类上方加上监听注解 @EntityListeners(AuditingEntityListener::class)

完成上述两个注解后，@CreatedDate、@LastModifiedBy、@Version 就生效了，但是创建人、修改人不会生效，需要我们创建一个配置类，实现 AuditorAware<String> 接口，如下：

@Configuration
class UserAuditor: AuditorAware<String> {

    /**
     * @return 获取当前创建或修改的用户
     */
    override fun getCurrentAuditor(): Optional<String> {
        return Optional.of("我是审计者 cyk")   
    }

}

Ps：正式项目中一般会从 JWT 或者 Session 中获取当前操作该表的用户是谁.

2.5、基于 JpaRepository 的 CRUD

Spring Data JPA 操作数据库，只需要自定有接口，并继承 JpaRepository 接口，无需再接口中定义任何方法，也不需要为接口提供实现类，就能完成基本 CRUD.

a）接口：

import org.cyk.jpa.model.Userinfo
import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.stereotype.Repository

@Repository
interface UserRepoJpa: JpaRepository<Userinfo, Long>

b）测试类：

import org.cyk.jpa.model.Userinfo
import org.cyk.jpa.repo.UserRepoJpa
import org.junit.jupiter.api.Test
import org.springframework.boot.test.context.SpringBootTest
import javax.annotation.Resource

@SpringBootTest
class JpaApplicationTests {

    @Resource
    private lateinit var userRepoJpa: UserRepoJpa

    @Test
    fun test() {
        val obj = Userinfo(
            username = "cyk3",
            age = 21,
        )
        userRepoJpa.save(obj)
        val result = userRepoJpa.findAll()
        result.forEach(::println)
    }

}

执行结果：

Ps：创建人和更新人埋坑，最后会补充~

c）SpringDataJPA 的接口继承关系：

Repository  (标记接口、做标记、Repository接口的子接口的实现类对象可以自动被SpringIOC容器所识别，此接口的子接口中可以定义一些指定规范的方法)
    ||
CrudRepository  (定义了一些基本的CRUD方法)
    ||
PagingAndSortingRepository  (定义了排序和分页相关的查询方法)
    ||
JpaRepository    (重写了一些基本测CRUD方法)
    ||
ArticleDao    (自己定义的接口)

三、SpringDataJPA 多种查询方式

3.1、JpaRepository 查询

a）只需要创建一个接口，让他继承 JpaRepository<T, ID> 接口即可

T：实体类
ID：id 类型

import org.cyk.jpa.model.Userinfo
import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.stereotype.Repository

@Repository
interface UserRepoJpa: JpaRepository<Userinfo, Long>

此时，你就可以直接使用 JpaRepository<T, ID> 接口提供的方法：

b）测试：

import org.cyk.jpa.model.Userinfo
import org.cyk.jpa.repo.UserRepoJpa
import org.junit.jupiter.api.Test
import org.springframework.boot.test.context.SpringBootTest
import javax.annotation.Resource

@SpringBootTest
class JpaApplicationTests {

    @Resource
    private lateinit var userRepoJpa: UserRepoJpa

    @Test
    fun test() {
        val obj = Userinfo(
            username = "cyk3",
            age = 21,
        )
        userRepoJpa.save(obj)
        val result = userRepoJpa.findAll()
        result.forEach(::println)
    }

}

3.2、方法命名规则查询

a）创建一个接口，继承 JpaRepository 接口，此时你就可以自定义一些方法（方法名有要求），SpringDataJPA 就会再程序执行的时候根据方法名进行解析，自动生成对应的查询语句.

b）规范：

查询起始词：查询方法通常以 find、read、get、query、count、exists 等词开头。
属性引用：在起始词之后，你可以引用实体类的属性名（首字母大写）。例如，如果有一个名为 firstName 的属性，你可以通过 findByFirstName 来查询它。
条件组合：对于多个条件，你可以使用 And 或 Or 连接。例如，findByFirstNameAndLastName 会查找同时匹配 firstName 和 lastName 的记录。
排序：你可以使用 OrderBy 关键字并指定属性名和排序方向（如 Asc 或 Desc）来排序结果。
限制结果：使用 First、Top 或 Limit 可以限制返回的记录数。例如，findFirstByName 会返回按 name 排序后的第一个结果。
聚合函数：Spring Data JPA 也支持聚合函数，如 countBy、sumBy、avgBy 等。
处理特殊情况：如果属性名包含特殊字符或与 SQL 关键字冲突，可以使用 @Column 注解来明确指定字段名。对于复杂的查询，可以使用 @Query 注解来编写自定义的 SQL 或 JPQL 查询。
命名规范：属性名在方法名中通常是大写的，以符合 Java 的命名规范，即使它们在数据库或实体类中是小写的。
分页：如果需要分页查询，可以在方法参数中添加 Pageable 类型的参数。
流和迭代：除了返回列表或单个实体，方法还可以返回流（Stream）或迭代器（Iterable），以支持更高效的内存使用。

例如：

import org.cyk.jpa.model.Userinfo
import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.stereotype.Repository

@Repository
interface UserRepoName: JpaRepository<Userinfo, Long> {

    //直接查询
    fun findByUsername(username: String): List<Userinfo>

    //模糊查询
    fun findByUsernameLike(username: String): List<Userinfo>

    //and 查询
    fun findByUsernameAndAge(username: String, age: Int): List<Userinfo>

    //小于等于查询
    fun findByIdLessThanEqual(id: Long): List<Userinfo>

    //between 查询
    fun findByIdBetween(start: Long, end: Long): List<Userinfo>

    //in 查询
    fun findByIdIn(ids: List<Long>): List<Userinfo>

}

测试：

import org.cyk.jpa.repo.UserRepoName
import org.junit.jupiter.api.Test
import org.springframework.boot.test.context.SpringBootTest
import javax.annotation.Resource

@SpringBootTest
class JpaNameApplicationTests {

    @Resource
    private lateinit var userRepoName: UserRepoName

    @Test
    fun test1() {
        userRepoName.findByUsername("cyk").forEach(::println)
    }

    @Test
    fun test2() {
        userRepoName.findByUsernameLike("%y%").forEach(::println)
    }

    @Test
    fun test3() {
        userRepoName.findByUsernameAndAge("cyk", 21).forEach(::println)
    }

    @Test
    fun test4() {
        userRepoName.findByIdLessThanEqual(2).forEach(::println)
    }

    @Test
    fun test5() {
        userRepoName.findByIdBetween(1, 3).forEach(::println)
    }

    @Test
    fun test6() {
        userRepoName.findByIdIn(listOf(1,2)).forEach(::println)
    }

}

3.3、JPQL 查询

JPQL，全称是 Java 持久化查询语言，是 JPA 中定义的一种查询语言. 此种语言的用意是让开发者忽略数据库表和表中的字段，而关注实体类及实体类中的属性。

写法十分类似于SQL语句的写法，但是要把查询的表名换成实体类的名称，把表中的字段名换成实体类的属性名称。

接口：

import org.cyk.jpa.model.Userinfo
import org.springframework.data.domain.Pageable
import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.data.jpa.repository.Query
import org.springframework.data.repository.query.Param
import org.springframework.stereotype.Repository

@Repository
interface UserRepoJpql: JpaRepository<Userinfo, Long> {

    //占位符从 1 开始
    @Query("from Userinfo where username = ?1 and age <= ?2")
    fun findByCond1(username: String, age: Int): List<Userinfo>

    //参数名 ":" 绑定
    @Query("from Userinfo where username = :username and age <= :age")
    fun findByCond2(@Param("username") username: String,
                    @Param("age") age: Int): List<Userinfo>

    //模糊查询 + 排序
    @Query("from Userinfo where username like %:username% order by cTime desc")
    fun findByCond3(@Param("username") username: String): List<Userinfo>

    //模糊查询 + 分页
    @Query("from Userinfo where username like %:username%")
    fun findByCond4(pageable: Pageable, @Param("username") username: String): List<Userinfo>

    //in 查询
    @Query("from Userinfo where age in :ages")
    fun findByCond5(@Param("ages") ages: List<Int>): List<Userinfo>

    //通过对象进行查询(SPEL 表达式查询)
    @Query("from Userinfo where username = :#{#userinfo.username} and age <= :#{#userinfo.age}")
    fun findByCond6(@Param("userinfo") userinfo: Userinfo): List<Userinfo>

}

测试：

import org.cyk.jpa.model.Userinfo
import org.cyk.jpa.repo.UserRepoJpql
import org.junit.jupiter.api.Test
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.data.domain.PageRequest
import javax.annotation.Resource

@SpringBootTest
class JpaJpqlApplicationTests {

    @Resource
    private lateinit var userRepoJpql: UserRepoJpql

    @Test
    fun test1() {
        userRepoJpql.findByCond1("cyk", 21).forEach(::println)
    }

    @Test
    fun test2() {
        userRepoJpql.findByCond2("cyk", 21).forEach(::println)
    }

    @Test
    fun test3() {
        userRepoJpql.findByCond3("y").forEach(::println)
    }

    @Test
    fun test4() {
        val pg = PageRequest.of(1, 2)
        userRepoJpql.findByCond4(pg, "y").forEach(::println)
    }

    @Test
    fun test5() {
        userRepoJpql.findByCond5(listOf(21,22,23)).forEach(::println)
    }

    @Test
    fun test6() {
        userRepoJpql.findByCond6(
            Userinfo(
                username = "cyk",
                age = 21
            )
        ).forEach(::println)
    }

}

3.4、SQL 查询

在 @Query 注解中，设置属性 nativeQuery = true，表示使用 SQL 语句进行查询.

基本不会使用这种情况，除非是非常复杂的业务情况.

接口：

import org.cyk.jpa.model.Userinfo
import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.data.jpa.repository.Query

interface UserRepoSql: JpaRepository<Userinfo, Long> {

    @Query(value = "select * from user_info where username = ?1 and age = ?2", nativeQuery = true)
    fun findByCond(username: String, age: Int): List<Userinfo>

}

测试：

import org.cyk.jpa.repo.UserRepoSql
import org.junit.jupiter.api.Test
import org.springframework.boot.test.context.SpringBootTest
import javax.annotation.Resource

@SpringBootTest
class JpaSqlApplicationTests {

    @Resource
    private lateinit var userRepoSql: UserRepoSql

    @Test
    fun test() {
        userRepoSql.findByCond("cyk", 21).forEach(::println)
    }

}

3.5、JpaSpecificationExecutor 动态查询

类似我们写动态 SQL，给定的条件不是固定的，需要动态的构建查询语句.

SpringDataJPA 中，我们只需要自定义个接口，继承 JpaRepository 和 JpaSpecificationExecutor 接口即可.

接口：

import org.cyk.jpa.model.Userinfo
import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.data.jpa.repository.JpaSpecificationExecutor
import org.springframework.stereotype.Repository

@Repository
interface UserRepoJpaSpe: JpaRepository<Userinfo, Long>, JpaSpecificationExecutor<Userinfo>

测试：

import org.cyk.jpa.model.Userinfo
import org.cyk.jpa.repo.UserRepoJpaSpe
import org.junit.jupiter.api.Test
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.data.domain.PageRequest
import org.springframework.data.domain.Sort
import org.springframework.data.jpa.domain.Specification
import javax.annotation.Resource
import javax.persistence.criteria.Predicate

@SpringBootTest
class JpaSpeApplicationTests {

    @Resource
    private lateinit var userRepoJpaSpe: UserRepoJpaSpe

    //username 和 age 不为空才作为查询条件
    @Test
    fun test1() {
        //模拟外部输入
        val username: String? = ""
        val age: Int? = 21

        /**
         * 拼接查询条件
         * root: 代表实体对象，可以通过它获取属性值
         * cq: 用于生成SQL语句
         * cb: 用于拼接查询条件
         */
        val s = Specification<Userinfo> { root, cq, cb ->
            val predicates = mutableListOf<Predicate>()

            if (!username.isNullOrBlank()) {
                val p = cb.equal(root.get<String>("username"), username)
                predicates.add(p)
            }

            age?.let {
                val p = cb.equal(root.get<Int>("age"), it)
                predicates.add(p)
            }

            cb.and(*predicates.toTypedArray())
        }

        //查询
        userRepoJpaSpe.findAll(s).forEach(::println)
    }

    //查询 + 分页 + 排序（倒序）
    @Test
    fun test2() {
        //模拟外部输入
        val username: String? = ""
        val age: Int? = 21

        /**
         * 拼接查询条件
         * root: 代表实体对象，可以通过它获取属性值
         * cq: 用于生成SQL语句
         * cb: 用于拼接查询条件
         */
        val s = Specification<Userinfo> { root, cq, cb ->
            val predicates = mutableListOf<Predicate>()

            if (!username.isNullOrBlank()) {
                val p = cb.equal(root.get<String>("username"), username)
                predicates.add(p)
            }

            age?.let {
                val p = cb.equal(root.get<Int>("age"), it)
                predicates.add(p)
            }

            cb.and(*predicates.toTypedArray())
        }

        //分页 + 排序
        val pg = PageRequest.of(0, 3, Sort.by(Sort.Order.desc("cTime"))) //注意这里对应的是成员变量名(而非表中的字段名)

        val result = userRepoJpaSpe.findAll(s, pg)
        result.forEach(::println)
    }

}