Java：113-Spring Data JPA详解

各个方面都自在

已于 2024-07-31 20:38:29 修改

阅读量3.6k

点赞数 7

分类专栏：笔记文章标签： java oracle 数据库

于 2024-06-17 16:04:27 首次发布

本文链接：https://blog.csdn.net/qq_59609098/article/details/139746621

版权

Spring Data JPA详解

Spring Data Jpa 是应用于Dao层的⼀个框架，简化数据库开发的，作用和Mybatis框架⼀样，但是在使用方式和底层机制是有所不同的，最明显的⼀个特点，Spring Data Jpa 开发Dao的时候，很多场景我们连sql语句都不需要开发，且由Spring出品

Spring Data JPA 概述：

什么是 Spring Data JPA：

Spring Data JPA 是 Spring 基于JPA 规范的基础上封装的⼀套 JPA 应用框架，可使开发者用极简的代码即可实现对数据库的访问和操作，它提供了包括增删改查等在内的常用功能，学习并使用 Spring Data JPA 可以极大提高开发效率

说明：Spring Data JPA 极大简化了数据访问层代码

如何简化呢，使用了Spring Data JPA，我们Dao层中只需要写接口，不需要写实现类，就自动具有了增删改查，分页查询等方法

使用Spring Data JPA 很多场景下不需要我们自己写sql语句

什么是JPA 规范：Java Persistence API（JPA）是一套用于管理和持久化 Java 对象与关系数据库之间数据的标准规范，JPA 主要用来将 Java 对象与数据库中的表记录相互映射，通过对象化的方式进行数据库操作，简化了数据库的访问

注意了，对应的与ORM的区别是：ORM 是一种技术，它通过将数据库表映射到对象来实现对象和关系数据之间的转换，ORM 的目标是使开发者能够以面向对象的方式与数据库交互，而不必编写大量的 SQL 语句，典型是mybatis，通常使用一些xml来对应类，而JPA规范通常是使用一些注解来进行操作，所以如果mybatis本身也可以完全使用注解来完成，那么也可以称mybatis是一种JPA规范操作的框架（虽然现实并不是）

简单来说：

JPA是一种标准规范，定义了如何通过注解和实体类进行对象关系映射（ORM），JPA 注重自动化，通过注解和标准 API（如 EntityManager）来管理实体的生命周期、关系和持久化操作

ORM侧重于映射，如MyBatis 提供了一种将 SQL 查询直接映射到 Java 方法的方式，并且允许开发者手动编写 SQL 查询，这使得它非常灵活，但与 JPA 的自动化和规范化有很大的不同，但是呢，JPA最终也是操作映射的，所以可以称JPA也是一种ORM的规范，即JPA是一个实现了ORM概念的Java规范（前提是有使用了这个规范的框架，否则只是规范）

Spring Data 家族：

在这里插入图片描述

Spring Data JPA，JPA规范和Hibernate之间的关系

Spring Data JPA 是 Spring 提供的⼀个封装了JPA 操作的框架，而JPA 仅仅是规范，单独使用规范无法具体做什么，那么Spring Data JPA 、 JPA规范以及 Hibernate （是JPA 规范的⼀种实现，了解这个即可）之间的关系是什么：

在这里插入图片描述

即：JPA 是⼀套规范，内部是由接口和抽象类组成的，Hiberanate 是⼀套成熟的 ORM 框架，而且 Hiberanate 实现了 JPA 规范，所以可以称 Hiberanate 为 JPA 的⼀种实现方式，我们使用 JPA 的 API 编程，意味着站在更高的角度去看待问题（面向接口编程）， Spring Data JPA 是 Spring 提供的⼀套对 JPA 操作更加⾼级的封装，是在 JPA 规范下的专门用来进行数据持久化的解决方案

也就是说，Spring Data JPA封装后，需要使用该jpa规范的框架，可以直接使用封装好的（也就是Spring Data JPA），而不用自行实现了（或者不用使用自身的，因为Spring Data JPA在原来的jpa基础上有所增强）

也要注意：虽然JPA定义了接口和规范，但它并没有提供实际的实现代码（因为规范并不是代码实现，只是某些定义，如接口怎么定义），因此，需要一个具体的实现来执行这些操作，Hibernate是JPA规范的一个常见实现，提供了实际的持久化逻辑，所以当Hibernate操作时，通常建议与该jpa整合，使得Hibernate也使用这个增强的规范，使得我们在这个规范下编写代码，从而不用自身的不增强的jpa了

说了这么多，其实就一句话：有jpa规范的框架，自身jpa还不够，我需要增强的jpa（Spring Data JPA）

Spring Data JPA 应用：

需求：使用 Spring Data JPA 完成对 tb_resume 表（简历表）的Dao 层操作（增删改查，排序，分页等）

创建数据库：

CREATE DATABASE wd CHARACTER SET utf8;
USE wd;
CREATE TABLE tb_resume(
 id BIGINT(20) NOT NULL AUTO_INCREMENT,
 address VARCHAR(255) DEFAULT NULL,
 NAME VARCHAR(255) DEFAULT NULL,
 phone VARCHAR(255) DEFAULT NULL,
 PRIMARY KEY (`id`)
);
INSERT INTO tb_resume VALUES (1, '北京', '张三', '131000000');
INSERT INTO tb_resume VALUES (2, '上海', '李四', '151000000');
INSERT INTO tb_resume VALUES (3, '广州', '王五', '153000000');

开发步骤：

我们这里操作的是整合Hibernate的，而不是单纯的Hibernate，所以呢，如果需要学习单纯的Hibernate，那么可以百度（使用整合的其实就够啦，这个整合其实不只是jpa规范继续增强，也与Spring整合了，类似mybatis整合spring，只不过这里多了一个jpa规范而已，或者说多几个注解）

首先创建项目，然后我们引入依赖：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>jpa</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>
    <dependencies>
        <!--单元测试jar-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <!--spring-data-jpa 需要引⼊的jar，start-->
        <dependency>
             <!--存在xml配置中的命名空间：xmlns:jpa="http://www.springframework.org/schema/data/jpa
            所以通常需要

还有对应的注解，如dao接口中的ResumeDao的@Query，在后面会知道的
            -->
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>2.1.8.RELEASE</version>
        </dependency>
        <dependency>
            <!--这个依赖，通常情况下不是必须的，也就是说，可以去掉
一般解释为：如果项目中有使用 JSP，并且页面中使用了 EL 表达式，那么 javax.el 依赖是必须的
-->
            <groupId>org.glassfish.web</groupId>
            <artifactId>javax.el</artifactId>
            <version>2.2.6</version>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.13</version>
        </dependency>
        <dependency>
            <!--Spring容器，即IOC容器的使用需要这个，比如ApplicationContext-->
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.12.RELEASE</version>
        </dependency>
        <dependency>
            <!--里面存在对于的jdbc的依赖和tx依赖，相当于是操作spring-jdbc依赖，但是他依赖自身也存在代码的
            他一般用来操作：
            -->
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>5.1.12.RELEASE</version>
        </dependency>

        <!--hibernate对jpa的实现jar-->
        <dependency>
            <!--对应的依赖，当需要指定一个框架时，如：
<property name="persistenceProvider">
            <bean class="org.hibernate.jpa.HibernatePersistenceProvider"></bean>
        </property>

那么就是需要的
还存在对应的注解：如后面实体类Resume的@Entity，在后面会知道的
-->
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>5.4.0.Final</version>
        </dependency>
        <dependency>
            <!--用于一些其他的操作，比如：
注解验证：在实体类中使用注解，如 @NotNull，@Size，@Min，@Max 等，以便在数据保存到数据库之前进行验证
当不用时，那么这个依赖可以去掉
-->
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>5.4.0.Final</version>
        </dependency>


        <!--mysql 数据库驱动jar-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.46</version>
        </dependency>
        <!--druid连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.21</version>
        </dependency>
        <!--spring-test，测试的-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.12.RELEASE</version>
        </dependency>
    </dependencies>
</project>

创建jdbc.properties文件：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/wd?characterEncoding=utf8&useSSL=false
jdbc.username=root
jdbc.password=123456

创建com.pojo包，然后创建Resume类：

package com.pojo;

import javax.persistence.*;

/**
 * 简历实体类（在类中要使⽤注解建⽴实体类和数据表之间的映射关系以及属性和字段的映射关系）
 * 实体类和数据表映射关系
 *
 * @Entity
 * @Table 实体类属性和表字段的映射关系
 * @Id 标识主键
 * @GeneratedValue 标识主键的⽣成策略
 * @Column 建⽴属性和字段映射
 */
@Entity
@Table(name = "tb_resume")
public class Resume {
   
    @Id
/**
 * ⽣成策略经常使⽤的两种：
 * GenerationType.IDENTITY：依赖数据库中主键⾃增功能 Mysql
 * GenerationType.SEQUENCE：依靠序列来产⽣主键 Oracle
 */
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Long id;
    @Column(name = "name")
    private String name;
    @Column(name = "address")
    private String address;
    @Column(name = "phone") //里面对应与数据库中的字段
    private String phone;

    public Long getId() {
   
        return id;
    }

    public void setId(Long id) {
   
        this.id = id;
    }

    public String getName() {
   
        return name;
    }

    public void setName(String name) {
   
        this.name = name;
    }

    public String getAddress() {
   
        return address;
    }

    public void setAddress(String address) {
   
        this.address = address;
    }

    public String getPhone() {
   
        return phone;
    }

    public void setPhone(String phone) {
   
        this.phone = phone;
    }

    @Override
    public String toString() {
   
        return "Resume{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", address='" + address + '\'' +
                ", phone='" + phone + '\'' +
                '}';
    }
}

创建com.dao包，然后创建ResumeDao接口：

package com.dao;

import com.pojo.Resume;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

/**
 * ⼀个符合SpringDataJpa要求的Dao层接⼝是需要继承JpaRepository和
 * JpaSpecificationExecutor
 * JpaRepository<操作的实体类类型，主键类型>
 * 封装了基本的CRUD操作
 * JpaSpecificationExecutor<操作的实体类类型>
 * 封装了复杂的查询（分⻚、排序等）
 */
public interface ResumeDao extends JpaRepository<Resume, Long>,
        JpaSpecificationExecutor<Resume> {
   


}

配置 Spring 的配置文件，spring.xml：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:jpa="http://www.springframework.org/schema/data/jpa"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/data/jpa
        https://www.springframework.org/schema/data/jpa/spring-jpa.xsd">

    <!--配置spring包扫描-->
    <context:component-scan base-package="com"/>

    <!--对Spring和SpringDataJPA进⾏配置-->
    <!--创建数据库连接池druid-->
    <!--引⼊外部资源⽂件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!--第三⽅jar中的bean定义在xml中-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!--配置⼀个JPA中⾮常重要的对象，entityManagerFactory，entityManager类似于mybatis中的SqlSession
    entityManagerFactory类似于Mybatis中的SqlSessionFactory

    当然，这里的配置有点像对应的mybatis与spring整合的处理，即：
      <bean id="sessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">

    -->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <!--配置⼀些细节-->
        <!--配置数据源-->
        <property name="dataSource" ref="dataSource"/>
        <!--配置包扫描（pojo实体类所在的包，名称处理）-->
        <property name="packagesToScan" value="com.pojo"/>
        <!--指定jpa的具体实现，也就是hibernate，如果你不显式地指定persistenceProvider，Spring会尝试根据类路径上的依赖自动检测一个合适的JPA提供者（如果你已经在项目中引入了Hibernate的相关依赖，Spring会自动选择Hibernate作为JPA提供者），如果没有，那么可能会出现异常
这里是需要一个实现的，前面说明了，可以搜索"需要一个具体的实现来执行这些操作"

注意了：hibernate自身就有jpa规范，所以可以单独的使用hibernate，而不用进行整合，只不过Spring Data JPA是对JPA的一层抽象和增强，提供了一些方便的功能和工具，所以这里整合一下
换言之，这里的配置相当于替换了hibernate自身的jpa规范，也或者是对应的spring data jpa使用hibernate的实现
        -->
        <property name="persistenceProvider">
            <bean class="org.hibernate.jpa.HibernatePersistenceProvide