Spring Data JPA——入门

1.背景

1.1概述

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

Spring Data JPA 让我们解脱了DAO层的操作，基本上所有CRUD都可以依赖于它来实现,在实际的工作工程中，推荐使用Spring Data JPA + ORM（如：hibernate）完成操作，这样在切换不同的ORM框架时提供了极大的方便，同时也使数据库层操作更加简单，方便解耦。

1.2 Spring Data JPA与JPA和hibernate之间的关系

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

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

2.实验

2.1 实验需求说明

Spring Data JPA 完成客户的基本的CRUD操作。

2.2 搭建Spring Data JPA的开发环境

2.2.1 引入Spring Data JPA的坐标

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

    4.0.0

    com.test
    JpaSpec
    1.0-SNAPSHOT
    
        5.0.2.RELEASE
        5.0.7.Final
        1.6.6
        1.2.12
        0.9.1.2
        5.1.6
    

    
        
        
            junit
            junit
            4.12
            test
        

        
        
            org.aspectj
            aspectjweaver
            1.6.8
        

        
            org.springframework
            spring-aop
            ${spring.version}
        

        
            org.springframework
            spring-context
            ${spring.version}
        

        
            org.springframework
            spring-context-support
            ${spring.version}
        

        
        
            org.springframework
            spring-orm
            ${spring.version}
        

        
            org.springframework
            spring-beans
            ${spring.version}
        

        
            org.springframework
            spring-core
            ${spring.version}
        

        

        
        
            org.hibernate
            hibernate-core
            ${hibernate.version}
        
        
            org.hibernate
            hibernate-entitymanager
            ${hibernate.version}
        
        
            org.hibernate
            hibernate-validator
            5.2.1.Final
        
        

        
        
            c3p0
            c3p0
            ${c3p0.version}
        
        

        
        
            log4j
            log4j
            ${log4j.version}
        

        
            org.slf4j
            slf4j-api
            ${slf4j.version}
        

        
            org.slf4j
            slf4j-log4j12
            ${slf4j.version}
        
        


        
            mysql
            mysql-connector-java
            5.1.46
        

        
        
            org.springframework.data
            spring-data-jpa
            1.9.0.RELEASE
        

        
            org.springframework
            spring-test
            ${spring.version}
        

        
        
            javax.el
            javax.el-api
            2.2.4
        

        
            org.glassfish.web
            javax.el
            2.2.4
        
        
    

2.2.2 整合Spring Data JPA与Spring

配置spring的配置文件，在这个配置文件中进行整合。在resource目录下创建applicationContext.xml,这个配置文件将完成下面的事情：

（1）创建数据库连接池

（2）配置entityManagerFactory对象

（3）整合spring data jpa

（4）配置事务管理器

（5）声明式事务

（6）配置包扫描

2.2.3使用JPA注解配置映射关系

这个注解的使用在JPA入门文章进行了详细讲解。

package com.test.domain;

import javax.persistence.*;

/**
 * 实体类和表的关系
 * 类中属性和表中字段的属性关系
 */
@Entity
@Table(name = "cst_customer")
public class Customer {
    @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_level")
    private String custLevel;  //级别

    @Column(name = "cust_industry")
    private String custIndustry;  //所属行业

    @Column(name = "cust_phone")
    private String custPhone;  //联系方式

    @Column(name = "cust_address")
    private String custAddress;  //地址


    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 getCustLevel() {
        return custLevel;
    }

    public void setCustLevel(String custLevel) {
        this.custLevel = custLevel;
    }

    public String getCustIndustry() {
        return custIndustry;
    }

    public void setCustIndustry(String custIndustry) {
        this.custIndustry = custIndustry;
    }

    public String getCustPhone() {
        return custPhone;
    }

    public void setCustPhone(String custPhone) {
        this.custPhone = custPhone;
    }

    public String getCustAddress() {
        return custAddress;
    }

    public void setCustAddress(String custAddress) {
        this.custAddress = custAddress;
    }

    @Override
    public String toString() {
        return "Customer{" +
                "custId=" + custId +
                ", custName='" + custName + '\'' +
                ", custSource='" + custSource + '\'' +
                ", custLevel='" + custLevel + '\'' +
                ", custIndustry='" + custIndustry + '\'' +
                ", custPhone='" + custPhone + '\'' +
                ", custAddress='" + custAddress + '\'' +
                '}';
    }


}

2.3 使用Spring Data JPA完成需求

2.3.1 编写符合Spring Data JPA规范的Dao接口

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

在Spring Data Jpa中，对于定义符合规范的dao层接口，只需要遵循以下几点：

（1）创建一个Dao层接口，并实现JpaRepository和JpaSpecificationExecuter

（2）提供相应的泛型

/**
 * JpaRepository<实体类型，主键类型> 用来完成基本的CRUD操作
 * JpaSpecificationExecutor<实体类型> 用于复杂查询（分页查询等）
 */
public interface CustomerDao extends JpaRepository, JpaSpecificationExecutor {
}

2.3.2 完成基本的CRUD操作

完成了Spring Data JPA的环境搭建，并且编写了符合Spring Data JPA 规范的Dao层接口之后，就可以使用定义好的Dao层接口进行客户的基本CRUD操作

@RunWith(SpringJUnit4ClassRunner.class)//声明Spring提供的单元测试环境
@ContextConfiguration(locations = "classpath:applicationContext.xml") //指定Spring容器中的配置信息
public class CustomerTest {
    @Autowired
    private CustomerDao customerDao;

    /**
     * 根据ID查询
     */
    @Test
    public void testFindOne(){
        Customer one = customerDao.findOne(2l);
        System.out.println(one);
    }

    /**
     * save:保存或者更新
     *      根据传递的对象是否存在主键ID，如果没有主键ID，则保存
     *      存在ID主键属性，根据ID查询数据，更新数据
     */
    @Test
    public void testSave(){
        Customer customer=new Customer();
        customer.setCustName("hh");
        customer.setCustLevel("VIP");
        customer.setCustIndustry("IT");
        customerDao.save(customer);
    }

    @Test
    public void testUpdate(){
        Customer customer=new Customer();
        customer.setCustId(4l);
        customer.setCustIndustry("测试");
        customerDao.save(customer);
    }

    /**
     * 删除
     */

    @Test
    public void testDele(){
        customerDao.delete(4l);
    }
    /**
     * 查询所有
     */

    @Test
    public void testFindALL(){
        List all = customerDao.findAll();
        for(Customer c:all)
            System.out.println(c);
    }
}

3.Spring Data JPA的内部原理剖析

3.1 常用的接口分析

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

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

3.2 实现过程

通过对客户案例，以debug断点调试。

以findOne方法为例进行分析。

• 代理子类的实现过程

断点执行到方法上时，可以发现注入的customerDao对象，本质上通过JdkDynamicAopPoxy生成的一个代理对象。

• 代理对象中的方法调用

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

通过SimpleJpaRepository的源码分析，定位到了findOne方法。在此方法中，返回em.find（）的返回结果，那么em又是什么呢？

em就是EntityManager对象，而这个是JPA原生的实现方式。所以得到的结论是Spring Data JPA只是对标准的JPA操作进行了进一步封装，简化了Dao层代码的开发。

3.3 完整的调用过程

4.Spring Data JPA的查询方式

有以下几种查询方式：

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

（1）继承JpaRepository后的方法列表

（2）继承JpaSpecificationExecutor的方法列表

 

4.2 使用JPQL的方式查询

使用@Query注解，结合JPQL的语句方式完成查询。

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

public interface CustomerDao extends JpaRepository, JpaSpecificationExecutor {

    /**
     * 需要将JPQL语句配置到接口方法上
     * 			1.特有的查询：需要在dao接口上配置方法
     * 			2.在新添加的方法上，使用注解的形式配置jpql查询语句
     * 			3.注解 ： @Query
     */

    /**
     * 根据客户名称查询
     * jpql: from customer where custName=?
     * 配置JPQL语句，使用的是@Query注解
     */
    @Query(value="from Customer where custName = ?")
    public Customer findJpql(String custName);

    /**
     * 根据客户名称和客户ID查询
     * jpql: from Customer where custName= ?  and custId= ?
     *
     * 对于多个占位符参数：
     *     赋值的时候，默认的情况下，占位符的位置需要和方法参数中的位置保持一致
     *     可以指定占位符参数的位置：？索引的方式，指定此位置的的取值来源
     */
    @Query("from Customer where custName= ?1 and custId= ?2")
    public Customer findCustNameAndId(String name, long id);

    /**
     * 使用JPQL更新，根据ID，更新客户的名称
     * sql：update cst_customer set cust_name=? where cust_id=?
     * jpql: update Customer set custName=? where custId=?
     *
     *  @Query:进行查询
     *     声明此方法是用来进行更新操作
     *  @Modifying
     *     当前执行的是一个更新操作
     */

    @Query("update Customer set custName=?2 where custId=?1")
    @Modifying
    public void updateCustomer(long id,String name);

也可以使用@Query来执行一个更新操作，为此，我们需要在使用@Query的同时，用@Modifying来讲该操作标识为修改查询。

4.3 使用SQL语句进行查询

注意要在@Query注解中配置nativeQuery为true,表示使用本地SQL的方式进行查询。

 /**
     * sql语句的查询
     * 			1.特有的查询：需要在dao接口上配置方法
     * 			2.在新添加的方法上，使用注解的形式配置sql查询语句
     * 			3.注解 ： @Query
     * 				value ：jpql语句 | sql语句
     * 				nativeQuery ：false（使用jpql查询） | true（使用本地查询：sql查询）
     * 					是否使用本地查询
     *
     */
    /**
     * 查询全部客户
     * select * from cst_customer
     */
    //@Query(value = "select * from cst_customer",nativeQuery = true)
    @Query(value = "select * from  cst_customer where cust_name like ?",nativeQuery = true)
    public List