一、 Spring Data JPA概述

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

1、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的具体操作：参考博客：https://blog.csdn.net/weixin_44385486/article/details/123046499?spm=1001.2014.3001.5501

2、SpringData 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都可以依赖于它来实现,在实际的工作工程中，推荐使用Spring Data JPA + ORM（如：hibernate）完成操作，这样在切换不同的ORM框架时提供了极大的方便，同时也使数据库层操作更加简单，方便解耦

3、Spring Data JPA的特性

SpringData Jpa 极大简化了数据库访问层代码。如何简化的呢？

使用了SpringDataJpa，我们的dao层中只需要写接口，就自动具有了增删改查、分页查询等方法。

4、Spring Data JPA 与 JPA和hibernate之间的关系

JPA是一套规范，内部是有接口和抽象类组成的。

hibernate是一套成熟的ORM框架，而且Hibernate实现了JPA规范，所以也可以称hibernate为JPA的一种实现方式，我们使用JPA的API编程，意味着站在更高的角度上看待问题（面向接口编程）

Spring Data JPA是Spring提供的一套对JPA操作更加高级的封装，是在JPA规范下的专门用来进行数据持久化的解决方案。

二、Spring Data JPA快速入门

1、需求说明

SpringDataJPA完成客户的增删改查

2、引入Spring Data JPA的依赖

使用Spring Data JPA，需要整合Spring与Spring Data JPA，并且需要提供JPA的服务提供者hibernate，所以需要导入spring相关坐标，hibernate坐标，数据库驱动坐标等

<properties>
        <spring.version>5.0.2.RELEASE</spring.version>
        <hibernate.version>5.0.7.Final</hibernate.version>
        <slf4j.version>1.6.6</slf4j.version>
        <log4j.version>1.2.12</log4j.version>
        <c3p0.version>0.9.1.2</c3p0.version>
        <mysql.version>8.0.27</mysql.version>
    </properties>
    <dependencies>
        <!-- junit单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- spring beg -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.8</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- spring对orm框架的支持包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- spring end -->
        <!-- hibernate beg -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>5.2.1.Final</version>
        </dependency>
        <!-- hibernate end -->
        <!-- c3p0 beg -->
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>${c3p0.version}</version>
        </dependency>
        <!-- c3p0 end -->
        <!-- log end -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <!-- log end -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
        <!-- spring data jpa 的坐标-->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>1.9.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- el beg 使用spring data jpa 必须引入 -->
        <dependency>
            <groupId>javax.el</groupId>
            <artifactId>javax.el-api</artifactId>
            <version>2.2.4</version>
        </dependency>
        <dependency>
            <groupId>org.glassfish.web</groupId>
            <artifactId>javax.el</artifactId>
            <version>2.2.4</version>
        </dependency>
        <!-- el end -->
    </dependencies>

3、整合Spring Data JPA与Spring

ApplicationContext.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jpa="http://www.springframework.org/schema/data/jpa"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!--spring 和 spring data jpa的配置-->
    <!-- 1.创建entityManagerFactory对象交给spring容器管理-->
    <bean id="entityManagerFactoty" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!--配置的扫描的包（实体类所在的包） -->
        <property name="packagesToScan" value="com.tjcu.entity" />
        <!-- jpa的实现厂家 -->
        <property name="persistenceProvider">
            <bean class="org.hibernate.jpa.HibernatePersistenceProvider"/>
        </property>
        <!--jpa的供应商适配器 -->
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <!--配置是否自动创建数据库表 -->
                <property name="generateDdl" value="false" />
                <!--指定数据库类型 -->
                <property name="database" value="MYSQL" />
                <!--数据库方言：支持的特有语法 -->
                <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />
                <!--是否显示sql -->
                <property name="showSql" value="true" />
            </bean>
        </property>
        <!--jpa的方言 ：高级的特性 -->
        <property name="jpaDialect" >
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect" />
        </property>
    </bean>
    <!--2.创建数据库连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/customer?serverTimezone=UTC" ></property>
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
    </bean>
    <!--3.整合spring dataJpa-->
    <jpa:repositories base-package="com.tjcu.dao" transaction-manager-ref="transactionManager"
                      entity-manager-factory-ref="entityManagerFactoty" ></jpa:repositories>
    <!--4.配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactoty"></property>
    </bean>
    <!-- 4.txAdvice-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="save*" propagation="REQUIRED"/>
            <tx:method name="insert*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="delete*" propagation="REQUIRED"/>
            <tx:method name="get*" read-only="true"/>
            <tx:method name="find*" read-only="true"/>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>
    <!-- 5.aop-->
    <aop:config>
        <aop:pointcut id="pointcut" expression="execution(* com.tjcu.service.*.*(..))" />
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut" />
    </aop:config>
    <!--5.声明式事务 -->
    <!-- 6. 配置包扫描-->
    <context:component-scan base-package="com.tjcu" ></context:component-scan>
</beans>

4、使用JPA注解配置映射关系

/**
 * @author 王恒杰
 * @date 2022/2/21 9:47
 * @Description:
 */
@Entity     //声明实体类
@Table(name = "cust_customer")    //建立实体类和表的映射关系
public class Customer implements Serializable {
    @Id  //声明私有属性为主键
    @GeneratedValue(strategy= GenerationType.IDENTITY) //配置主键的生成策略
    @Column(name = "cust_id")
    private Long custId;
    @Column(name = "cust_name")
    private String custName;
    @Column(name = "cust_Source")
    private String custSource;
    @Column(name = "cust_industry")
    private String custIndustry;
    @Column(name = "cust_level")
    private String custLevel;
    @Column(name="cust_Address")
    private String custAddress;
    @Column(name="cust_phone")
    private String custPhone;
    public Customer() {
    }
    public Customer(Long custId, String custName, String custSource, String custIndustry, String custLevel, String custAddress, String custPhone) {
        this.custId = custId;
        this.custName = custName;
        this.custSource = custSource;
        this.custIndustry = custIndustry;
        this.custLevel = custLevel;
        this.custAddress = custAddress;
        this.custPhone = custPhone;
    }
    public Long getCustId() {
        return custId;
    }
    public void setCustId(Long custId) {
        this.custId = custId;
    }
    public String getCustName() {
        return custName;
    }
    public void setCustName(String custName) {
        this.custName = custName;
    }
    public String getCustSource() {
        return custSource;
    }
    public void setCustSource(String custSource) {
        this.custSource = custSource;
    }
    public String getCustIndustry() {
        return custIndustry;
    }
    public void setCustIndustry(String custIndustry) {
        this.custIndustry = custIndustry;
    }
    public String getCustLevel() {
        return custLevel;
    }
    public void setCustLevel(String custLevel) {
        this.custLevel = custLevel;
    }
    public String getCustAddress() {
        return custAddress;
    }
    public void setCustAddress(String custAddress) {
        this.custAddress = custAddress;
    }
    public String getCustPhone() {
        return custPhone;
    }
    public void setCustPhone(String custPhone) {
        this.custPhone = custPhone;
    }
    @Override
    public String toString() {
        return "com.tjcu.entity.Customer{" +
                "custId=" + custId +
                ", custName='" + custName + '\'' +
                ", custSource='" + custSource + '\'' +
                ", custIndustry='" + custIndustry + '\'' +
                ", custLevel='" + custLevel + '\'' +
                ", custAddress='" + custAddress + '\'' +
                ", custPhone='" + custPhone + '\'' +
                '}';
    }
}

5、使用Spring Data JPA完成需求

（1）编写符合Spring Data JPA规范的Dao层接口

Spring Data JPA是spring提供的一款对于数据访问层（Dao层）的框架，使用Spring Data JPA，只需要按照框架的规范提供dao接口，不需要实现类就可以完成数据库的增删改查、分页查询等方法的定义，极大的简化了我们的开发过程。

在Spring Data JPA中，对于定义符合规范的Dao层接口，我们只需要遵循以下几点就可以了：

创建一个Dao层接口，并实现JpaRepository(仓库)和JpaSpecificationExecutor(规格执行程序)

提供相应的泛型

/**
 * @author 王恒杰
 * @date 2022/2/21 15:51
 * @Description:
 * JpaRepository<实体类类型，主键类型>  用来完成基本增删改查
 * JpaSpecificationExecutor<实体类型>  用于复杂查询，分页等复杂操作
 */
public interface CustomerDao extends JpaRepository<Customer, Long>, JpaSpecificationExecutor<Customer> {
}

这样我们就定义好了一个符合Spring Data JPA规范的Dao层接口

（2）完成基本CRUD操作

添加用户

   @Autowired
    private CustomerDao customerDao;
    /**
     * 添加客户 用save() 方法
     */
    @Test
    public void testAdd() {
        Customer customer = new Customer(null, "王家糍粑", "抖音", "美食", "4级别", "贵州省遵义市", "6666666666");
        //添加客户
        customerDao.save(customer);
    }

修改用户

注意：如果执行此方法是对象中存在id属性，即为更新操作会先根据id查询，再更新，如果执行此方法中对象中不存在id属性，即为保存操作

 @Autowired
    private CustomerDao customerDao;
    /**
     * 修改客户
     * 调用save方法
     * 对于save方法的解释：如果执行此方法是对象中存在id属性，即为更新操作会先根据id查询，再更新
     * 如果执行此方法中对象中不存在id属性，即为保存操作
     */
    @Test
    public void testUpdate() {
        //根据id查询id为7的客户
        Customer customer1 = customerDao.findOne(7L);
        customer1.setCustAddress("北京石景山创业古城大厦");
        //对于save方法的解释：如果执行此方法是对象中存在id属性，即为更新操作会先根据id查询，再更新
        customerDao.save(customer1);
    }

查询id=6的用户

    /**
     * 根据id查询：调用findOne(id)方法
     */
    @Test
    public void testSelect() {
        Customer customer = customerDao.findOne(7L);
        System.out.println("id=7的用户"+customer);
    }

删除id=7的用户

  /**
     * 根据id删除：调用delete(id)方法
     */
    @Test
    public void testFindById() {

三、Spring Data JPA的内部原理剖析

1、Spring Data JPA的常用接口分析

在客户的案例中，我们发现在自定义的CustomerDao中，并没有提供任何方法就可以使用其中的很多方法，那么这些方法究竟是怎么来的呢？答案很简单，对于我们自定义的Dao接口，由于继承了JpaRepository和JpaSpecificationExecutor，所以我们可以使用这两个接口的所有方法。

查看继承关系图：ctrl+alt+u

JpaRepository源代码

@NoRepositoryBean
public interface JpaRepository<T, ID extends Serializable> extends PagingAndSortingRepository<T, ID> {
    List<T> findAll();
    List<T> findAll(Sort var1);
    List<T> findAll(Iterable<ID> var1);
    <S extends T> List<S> save(Iterable<S> var1);
    void flush();
    <S extends T> S saveAndFlush(S var1);
    void deleteInBatch(Iterable<T> var1);
    void deleteAllInBatch();
    T getOne(ID var1);
}

JpaSpecificationExecutor源代码

public interface JpaSpecificationExecutor<T> {
    T findOne(Specification<T> var1);
    List<T> findAll(Specification<T> var1);
    Page<T> findAll(Specification<T> var1, Pageable var2);
    List<T> findAll(Specification<T> var1, Sort var2);
    long count(Specification<T> var1);
}

在使用Spring Data JPA时，一般实现JpaRepository和JpaSpecificationExecutor接口，这样就可以使用这些接口中定义的方法，但是这些方法都只是一些声明，没有具体的实现方式

2、 Spring Data JPA的实现过程

通过对客户案例，以debug断点调试的方式，通过分析Spring Data JPA的原来来分析程序的执行过程

我们以findOne方法为例进行分析

当程序执行的时候，会通过JdkDynamicAopProxy的invoke方法，对customerDao对象生成动态代理对象。根据对Spring Data JPA介绍而知，要想进行findOne查询方法，最终还是会出现JPA规范的API完成操作，那么这些底层代码存在于何处呢？答案很简单，都隐藏在通过JdkDynamicAopProxy生成的动态代理对象当中，而这个动态代理对象就是SimpleJpaRepository

实现原理图

3、Spring Data JPA完整的调用过程分析

四、 Spring Data JPA的查询方式

1、使用Spring Data JPA中接口定义的方法进行查询

继承JpaRepository后的方法列表

继承JpaSpecificationExecutor的方法列表

2、使用JPQL的方式查询

使用Spring Data JPA提供的查询方法已经可以解决大部分的应用场景，但是对于某些业务来说，我们还需要灵活的构造查询条件，这时就可以使用@Query注解，结合JPQL的语句方式完成查询

@Query 注解的使用非常简单，只需在方法上面标注该注解，同时提供一个JPQL查询语句即可

public interface CustomerDao extends JpaRepository<Customer, Long>,JpaSpecificationExecutor<Customer>{
    /**
     * 使用jpql的方式查询。
     * @return
     */
    @Query(value = "from Customer")
    public List<Customer> queryAll();
    /**
     * 通过姓名查询顾客信息
     * @param custName
     * @return
     */
    @Query(value = "from Customer  where custName=?1")
    public Customer queryCustomer(String custName);
    /**
     * 也可以通过使用 @Query 来执行一个更新操作，
     * 为此，我们需要在使用 @Query 的同时，用 @Modifying 来将该操作标识为修改查询，
     * 这样框架最终会生成一个更新的操作，而非查询
     */
    @Query(value = "from Customer  where custName=?1 and  custId=?2")
    @Modifying
    public Customer queryNameAndId(String custName,Long custId);
}

也可以通过使用 @Query 来执行一个更新操作，为此，我们需要在使用 @Query 的同时，用 @Modifying 来将该操作标识为修改查询，这样框架最终会生成一个更新的操作，而非查询

public interface CustomerDao extends JpaRepository<Customer, Long>,JpaSpecificationExecutor<Customer>{
/**
     * 也可以通过使用 @Query 来执行一个更新操作，
     * 为此，我们需要在使用 @Query 的同时，用 @Modifying 来将该操作标识为修改查询，
     * 这样框架最终会生成一个更新的操作，而非查询
     */
    @Query(value = "from Customer  where custName=?1 and  custId=?2")
    @Modifying
    public Customer queryNameAndId(String custName,Long custId);
}

3、使用SQL语句查询

Spring Data JPA同样也支持sql语句的查询，如下：

    /**
     *  nativeQuery : 使用本地sql的方式查询
     */
    @Query(value = "select * from cust_customer",nativeQuery = true)
    public Customer queryNative();

4、方法命名规则查询

顾名思义，方法命名规则查询就是根据方法的名字，就能创建查询。只需要按照Spring Data JPA提供的方法命名规则定义方法的名称，就可以完成查询工作。Spring Data JPA在程序执行的时候会根据方法名称进行解析，并自动生成查询语句进行查询

按照Spring Data JPA 定义的规则，查询方法以findBy开头，涉及条件查询时，条件的属性用条件关键字连接，要注意的是：条件属性首字母需大写。框架在进行方法名解析时，会先把方法名多余的前缀截取掉，然后对剩下部分进行解析。

/**
     * 方法命名方式查询（根据客户名称查询客户）
     * @return
     */
    public Customer findByCustName();

SpringData JPA（提升篇）

一、 Spring Data JPA概述

1、JPA 由来

2、SpringData JPA

3、Spring Data JPA的特性

4、Spring Data JPA 与 JPA和hibernate之间的关系

二、Spring Data JPA快速入门

1、需求说明

2、引入Spring Data JPA的依赖

3、整合Spring Data JPA与Spring

4、使用JPA注解配置映射关系

5、使用Spring Data JPA完成需求

三、Spring Data JPA的内部原理剖析

1、Spring Data JPA的常用接口分析

2、 Spring Data JPA的实现过程

3、Spring Data JPA完整的调用过程分析

四、 Spring Data JPA的查询方式

1、使用Spring Data JPA中接口定义的方法进行查询

2、使用JPQL的方式查询

3、使用SQL语句查询

4、方法命名规则查询

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

SpringData JPA（提升篇）

一、 Spring Data JPA概述

1、JPA 由来

2、SpringData JPA

3、Spring Data JPA的特性

4、Spring Data JPA 与 JPA和hibernate之间的关系

二、Spring Data JPA快速入门

1、需求说明

2、引入Spring Data JPA的依赖

3、整合Spring Data JPA与Spring

4、使用JPA注解配置映射关系

5、使用Spring Data JPA完成需求

三、Spring Data JPA的内部原理剖析

1、Spring Data JPA的常用接口分析

2、 Spring Data JPA的实现过程

3、Spring Data JPA完整的调用过程分析

四、 Spring Data JPA的查询方式

1、使用Spring Data JPA中接口定义的方法进行查询

2、使用JPQL的方式查询

3、使用SQL语句查询

4、方法命名规则查询

热门文章

最新文章

相关电子书