SpringData - SpringData JPA 入门小 demo

基与上一篇文章 JPA 入门小 demo , 我们继续深入了解 SpringData JPA.

 

Spring Data JPA概述

Spring Data JPA 是 Spring 基于 ORM 框架、JPA 规范的基础上封装的一套 JPA 应用框架，可使开发者用极简的代码即可实现对数据库的访问和操作。它提供了包括增删改查等在内的常用功能，且易于扩展！学习并使用 Spring Data JPA 可以极大提高开发效率！   Spring Data JPA 让我们解脱了 DAO 层的操作，基本上所有 CRUD 都可以依赖于它来实现,在实际的工作工程中，推荐使用 Spring Data JPA + ORM（如：Hibernate）完成操作，这样在切换不同的 ORM 框架时提供了极大的方便，同时也使数据库层操作更加简单，方便解耦.   SpringData Jpa 极大简化了数据库访问层代码。 如何简化的呢？ 使用了 SpringDataJpa，我们的 dao 层中只需要写接口，就自动具有了增删改查、分页查询等方法。

Spring Data JPA 与 JPA 和 Hibernate 之间的关系

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

 

一. 搭建 Spring Data JPA 的开发环境

1. 创建工程, 导入依赖坐标

    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
        ${mysql.version}
    

    
    
        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. 整合 Spring Data JPA 与 Spring 的配置文件

在 resources 文件夹下创建 applicationContext.xml:

3. 创建数据库中客户表的实体类

package com.cast.domain;

import java.io.Serializable;
import javax.persistence.*;

/**
 * 封装数据库中表的实体类
 */
@Entity    //该类是一个数据库表实体封装类
@Table(name = "cst_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_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;     //客户地址

    // getter setter 方法....

    // toString() 方法....

}

二. 使用 Spring Data JPA 完成需求

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

* 符合 Spring Data JPA 规范的 Dao 层接口
*      JpaRepository<操作的实体类类型，实体类中主键属性的类型>
*          * 封装了基本 CRUD 操作
*      JpaSpecificationExecutor<操作的实体类类型>
*          * 封装了复杂查询（分页）

public interface CustomerDao extends JpaRepository, JpaSpecificationExecutor {

}

2. 建立测试类框架

@RunWith(SpringJUnit4ClassRunner.class)   //声明spring提供的单元测试环境
@ContextConfiguration(locations = "classpath:applicationContext.xml")   //指定spring容器的配置信息
public class CustomerDaoTest {

    @Autowired
    private CustomerDao customerDao;


}

三. 测试类中完成基本操作

1. 增 - save(Customer customer);

@Test
public void testSave() {
    Customer customer = new Customer();
    customer.setCustName("张三");
    customer.setCustLevel("三级");
    customer.setCustIndustry("it行业");
    customer.setCustSource("广告");
    customer.setCustPhone("1303030303");
    customer.setCustAddress("武汉市汉阳区");
    customerDao.save(customer);
}

2.删 - delete(Long id);

@Test
public void testDelete() {
    customerDao.delete(1L);
}

3.改 - save(Customer newCustomer);

@Test
public void testUpdate() {
    Customer customer = customerDao.findOne(1L);
    customer.setCustAddress("湖北省武汉市");
    customerDao.save(customer);
}

4. 根据 id 查 - findOne(Long id);

@Test
public void testFindOne() {
    Customer customer = customerDao.findOne(1L);
    System.out.println(customer);
}

5. 查询所有列表 - findAll();

@Test
public void testFindAll() {
    List list = customerDao.findAll();
    for (Customer customer : list) {
        System.out.println(customer);
    }
}

6. 查询总条数 - count();

@Test
public void testCount() {
    long count = customerDao.count();
    System.out.println("表中数据条数: " + count);
}

7. 查询该 id 的数据是否存在 - exists(Long id);

@Test
public void testExists() {
    boolean exists = customerDao.exists(1L);
    System.out.println("此 id 的客户是否存在：" + exists);
}

8. 延迟加载 - getOne(Long id);

@Test
@Transactional
public void testGetOne() {
    Customer customer = customerDao.getOne(1L);
    System.out.println(customer);
}

三. 使用 Spring Data JPA 中接口定义的方法(JPQL)进行查询

1. 在 Spring Data JPA 规范的 Dao 层接口中定义相关方法

/**
  * 根据客户名称查询客户
  */
@Query(value="from Customer where custName = ?")
public Customer findJpql(String custName);

/**
  * 根据客户名称和客户 id 查询客户
  */
@Query(value = "from Customer where custName = ?2 and custId = ?1")
public Customer findCustNameAndId(Long id, String name);

/**
  * 使用jpql完成更新操作
  */
@Query(value = "update Customer set custName = ?2 where custId = ?1")
@Modifying
public void updateCustomer(long custId, String custName);


/**
  * 使用sql的形式查询：
  *     根据姓名模糊查询客户
  */
//@Query(value = "select * from cst_customer", nativeQuery = true)
@Query(value="select * from cst_customer where cust_name like ?1", nativeQuery = true)
public List