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坐标，数据库驱动坐标。
<?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>com.test</groupId>
<artifactId>JpaSpec</artifactId>
<version>1.0-SNAPSHOT</version>
<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>5.1.6</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>5.1.46</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>
</project>2.2.2 整合Spring Data JPA与Spring
配置spring的配置文件，在这个配置文件中进行整合。在resource目录下创建applicationContext.xml,这个配置文件将完成下面的事情：
（1）创建数据库连接池
（2）配置entityManagerFactory对象
（3）整合spring data jpa
（4）配置事务管理器
（5）声明式事务
（6）配置包扫描
<?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:context="http://www.springframework.org/schema/context"
xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xmlns:jpa="http://www.springframework.org/schema/data/jpa"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
http://www.springframework.org/schema/data/jpa
http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">
<!--spring和Spring data JPA的配置-->
<!--1.创建数据库连接池-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver" />
<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/jpa" />
<property name="user" value="root" />
<property name="password" value="password" />
</bean>
<!-- 2.需要创建entityManagerFactory对象交给Spring容器管理
配置entityManagerFactory -->
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="packagesToScan" value="com.test.domain" />
<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" />
<property name="showSql" value="true" />
</bean>
</property>
<property name="jpaDialect">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect" />
</property>
</bean>
<!--3.整合Spring Data JPA-->
<!-- <jpa:repositories base-package="com.test.dao" transaction-manager-ref="transactionManager"-->
<!-- entity-manager-factory-ref="entityManagerFactory"></jpa:repositories>-->
<!-- 整合spring data jpa-->
<jpa:repositories base-package="com.test.dao"
transaction-manager-ref="transactionManager"
entity-manager-factory-ref="entityManagerFactory"></jpa:repositories>
<!--4.配置事务管理器-->
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>
<!--5.声明式事务-->
<!--6.配置包扫描-->
<context:component-scan base-package="com.test"></context:component-scan>
</beans>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<Customer,Long>, JpaSpecificationExecutor<Customer> {
}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<Customer> 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<Customer, Long>, JpaSpecificationExecutor<Customer> {
/**
* 需要将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<Object []> findsql(String name);4.4 方法命名规则查询
方法命名规则查询就是根据方法的名字，就能创建查询。只需要按照Spring Data JPA提供的方法命名规则定义方法的名称，就可以完成查询工作。Spring Data JPA在程序执行的时候会根据方法名称进行解析，并自动生成查询语句进行查询
按照Spring Data JPA 定义的规则，查询方法以findBy开头，涉及条件查询时，条件的属性用条件关键字连接，要注意的是：条件属性首字母需大写。框架在进行方法名解析时，会先把方法名多余的前缀截取掉，然后对剩下部分进行解析。
/**
* 方法名称规则查询：是对JPQL查询，更加深入的一层封装，
* 只需要按照SpringDataJpa提供 的方法规则名称定义方法，不需要再去配置JPQL语句完成查询
*
* 方法名的约定：
* findBy:查询
* 对象中的属性名（首字母大写）,查询的条件
* findByCustName --根据客户名称查询
* 在SpringData JPA的运行阶段
* 会根据方法名称进行解析，findBy from xxx(实体类）
* 属性名称 where custName=
* 默认情况下，使用等于的方式进行查询
* 1. findBy +属性名称（根据属性名称完成匹配查询）
* 2. findBy +属性名称+“查询方式（Like | isNull)”
* findByCustNameLike
* 3. 多条件查询
* findBy + 属性名 +“查询方式“ + “多条件的连接符（and|or) +属性名 + "查询方式"
*
*/
public Customer findByCustName(String name);
public List<Customer> findByCustNameLike(String name);
//使用客户名称模糊匹配和客户所属行业的精准匹配
public Customer findByCustNameLikeAndCustIndustry(String custName,String custIndustry);5.Specifications动态查询
5.1 简介
有时我们在查询某个实体的时候，给定的条件是不固定的，这时就需要动态构建相应的查询语句，在Spring Data JPA中可以通过JpaSpecificationExecutor接口查询。相比JPQL,其优势是类型安全,更加的面向对象。
import java.util.List;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
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);
}对于JpaSpecificationExecutor，这个接口围绕Speicfication接口来定义的， 简单来理解，这个接口就是查询条件。
Specification接口只定义了如下一个方法：
//构造查询条件
//root:Root接口，代表查询的根对象，可以通过root获取实体类中的属性
//CriteriaQuery:代表一个顶层查询对象，用于自定义查询
//CriteriaBuilder :用于构建查询，此对象中拥有很多条件方法
public interface Specification<T> {
Predicate toPredicate(Root<T> var1, CriteriaQuery<?> var2, CriteriaBuilder var3);
}
5.2 实验
5.2.1 条件查询
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class SpecTest {
@Autowired
private CustomerDao customerDao;
/**
* 根据条件：查询单个对象
*/
@Test
public void testSpec(){
//匿名内部类
/**
* 自定义查询条件
* 1.实现Specification接口（提供泛型，查询的对象类型）
* 2.实现toPredicate方法（构造查询条件）
* 3.借助方法参数中的两个参数（root：需要获取查询的对象属性，
* CriteriaBuilder：构造查询条件的，内部封装了很多的查询条件（模糊匹配，精准匹配）
*/
//根据客户名称查询
/**
* 查询条件：
* 1.查询方式 cd对象
* 2.比较的属性名称 root对象
*/
Specification<Customer> spec=new Specification<Customer>() {
public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
//1.获取比较的属性
Path<Object> custName = root.get("custName");
//2.构造查询 select * from cst_customer where cust_name=?
Predicate p = criteriaBuilder.equal(custName, "黑娜");//进行精准匹配（比较的属性名，比较的属性取值）
return p;
}
};
Customer one = customerDao.findOne(spec);
System.out.println(one);
}
/**
* 多条件查询：根据客户名和和客户所属行业
*/
@Test
public void testSpec1(){
/**
* root 获取属性
* 客户名
* 所属行业
* cb 构造查询
* 1.构造客户名的精准匹配查询
* 2.构造所属行业精准匹配查询
* 3.将两个查询联系起来
*/
Specification<Customer> specification=new Specification<Customer>() {
public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
Path<Object> custName = root.get("custName");
Path<Object> custIndustry = root.get("custIndustry");
//构造查询
Predicate p1 = criteriaBuilder.equal(custName, "黑娜");//第一个参数，path(属性），第二个参数：属性的取值
Predicate p2 = criteriaBuilder.equal(custIndustry, "互联网");
//将多个查询条件组合到一起，组合（满足条件一并满足条件二，满足条件一或满足条件二）
Predicate and = criteriaBuilder.and(p1, p2);//以与的形式拼接多个查询条件
return and;
}
};
customerDao.findOne(specification);
}
/**
* 完成根据客户名称的模糊匹配：返回列表
*
* equal：直接得到path对象，然后进行比较即可
* gt,lt,le,ge,like:得到path对象，根据Path对象指定比较的参数类型，再去进行比较
* 指定参数类型：path.as(类型的字节码对象）
*/
@Test
public void testSpec2(){
Specification<Customer> specification=new Specification<Customer>() {
public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
//查询名称
Path<Object> custName = root.get("custName");
//查询条件
Predicate c = criteriaBuilder.like(custName.as(String.class), "黑娜");
return c;
}
};
// List<Customer> all = customerDao.findAll(specification);
// for(Customer c:all){
// System.out.println(c);
// }
//添加排序
//创建排序对象,需要调用构造方法实例化对象
//第一个参数：排序的顺序（正序，倒序）
//第二个参数：排序的属性名称
Sort sort=new Sort(Sort.Direction.ASC,"custId");
List<Customer> all = customerDao.findAll(specification, sort);
for (Customer c:all)
{
System.out.println(c);
}
}
5.2.2 分页查询
/**
* 分页查询
* findall(Specification,Pageable) 带有条件的分页
* Specification 查询条件
* Pageable 分页的参数，查询的条码，每页查询的条数
* findall(Specification） 没有条件的分页
* 返回 Page,SpringDataJpa为我们封装好的PageBean对象，数据列表，共条数
*
*/
@Test
public void testSpec3(){
Specification s=null;
//PageRequest是Pageable的实现类
/**
* 创建PageRequest的过程中，需要调用他的构造方法传入两个参数
* 第一个参数：当前查询的页数，从0开始
* 第二个参数：每页查询的数量
*/
Pageable pageable=new PageRequest(0,2);
//分页查询
Page<Customer> all = customerDao.findAll(s, pageable);
System.out.println(all.getContent()); //得到数据集合列表
System.out.println(all.getTotalPages()); //得到总页数
System.out.println(all.getTotalElements()); //得到总条数
}6.多表设计
6.1 表之间的关系划分
数据库中多表存在着三种关系，如图所示：
6.2 在JPA框架中表关系的分析步骤
在实际开发中，我们数据库的表难免会有相互的关联关系，在操作表的时候就有可能会涉及到多张表的操作。而在这种实现了ORM思想的框架中（如JPA），可以让我们通过操作实体类就实现对数据库表的操作。所以今天我们的学习重点是：掌握配置实体之间的关联关系。
1.首先确定两张表之间的关系
2.在数据库中实现两张表的关系
3.在实体类中描述两个实体的关系
4.配置出实体类和数据库表的关系映射
6.3 一对多
6.3.1 示例
客户：指的是一家公司，记为A
联系人：指的是A公司中的员工
在不考虑兼职的情况下，公司和员工的关系为一对多。
创建表的SQL语句如下：
6.3.2 表关系的建立
在一对多关系中，我们习惯把一的一方称之为主表，把多的一方称之为从表。在数据库中建立一对多的关系，需要使用数据库的外键约束。
一对多数据库关系的建立，如下图所示：
6.3.3 实体类关系建立以及映射关系配置
在实体类中，由于客户是少的一方，它应该包含多个联系人，所以实体类中要出现多个联系人的信息 ，代码如下：
/**
* 客户的实体类
* 明确使用的注解都是JPA规范的
* 所以导包都要导入javax.persistence包下的
*/
@Entity//表示当前类是一个实体类
@Table(name="cst_customer")//建立当前实体类和表之间的对应关系
public class Customer implements Serializable {
@Id//表明当前私有属性是主键
@GeneratedValue(strategy=GenerationType.IDENTITY)//指定主键的生成策略
@Column(name="cust_id")//指定和数据库表中的cust_id列对应
private Long custId;
@Column(name="cust_name")//指定和数据库表中的cust_name列对应
private String custName;
@Column(name="cust_source")//指定和数据库表中的cust_source列对应
private String custSource;
@Column(name="cust_industry")//指定和数据库表中的cust_industry列对应
private String custIndustry;
@Column(name="cust_level")//指定和数据库表中的cust_level列对应
private String custLevel;
@Column(name="cust_address")//指定和数据库表中的cust_address列对应
private String custAddress;
@Column(name="cust_phone")//指定和数据库表中的cust_phone列对应
private String custPhone;
//配置客户和联系人的一对多关系
@OneToMany(targetEntity=LinkMan.class)
@JoinColumn(name="lkm_cust_id",referencedColumnName="cust_id")
private Set<LinkMan> linkmans = new HashSet<LinkMan>(0);
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;
}
public Set<LinkMan> getLinkmans() {
return linkmans;
}
public void setLinkmans(Set<LinkMan> linkmans) {
this.linkmans = linkmans;
}
@Override
public String toString() {
return "Customer [custId=" + custId + ", custName=" + custName + ", custSource=" + custSource
+ ", custIndustry=" + custIndustry + ", custLevel=" + custLevel + ", custAddress=" + custAddress
+ ", custPhone=" + custPhone + "]";
}
}由于联系人是多的一方，在实体类中要体现出，每个联系人只能对应一个客户，代码如下：
/**
* 联系人的实体类（数据模型）
*/
@Entity
@Table(name="cst_linkman")
public class LinkMan implements Serializable {
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
@Column(name="lkm_id")
private Long lkmId;
@Column(name="lkm_name")
private String lkmName;
@Column(name="lkm_gender")
private String lkmGender;
@Column(name="lkm_phone")
private String lkmPhone;
@Column(name="lkm_mobile")
private String lkmMobile;
@Column(name="lkm_email")
private String lkmEmail;
@Column(name="lkm_position")
private String lkmPosition;
@Column(name="lkm_memo")
private String lkmMemo;
//多对一关系映射：多个联系人对应客户
@ManyToOne(targetEntity=Customer.class)
@JoinColumn(name="lkm_cust_id",referencedColumnName="cust_id")
private Customer customer;//用它的主键，对应联系人表中的外键
public Long getLkmId() {
return lkmId;
}
public void setLkmId(Long lkmId) {
this.lkmId = lkmId;
}
public String getLkmName() {
return lkmName;
}
public void setLkmName(String lkmName) {
this.lkmName = lkmName;
}
public String getLkmGender() {
return lkmGender;
}
public void setLkmGender(String lkmGender) {
this.lkmGender = lkmGender;
}
public String getLkmPhone() {
return lkmPhone;
}
public void setLkmPhone(String lkmPhone) {
this.lkmPhone = lkmPhone;
}
public String getLkmMobile() {
return lkmMobile;
}
public void setLkmMobile(String lkmMobile) {
this.lkmMobile = lkmMobile;
}
public String getLkmEmail() {
return lkmEmail;
}
public void setLkmEmail(String lkmEmail) {
this.lkmEmail = lkmEmail;
}
public String getLkmPosition() {
return lkmPosition;
}
public void setLkmPosition(String lkmPosition) {
this.lkmPosition = lkmPosition;
}
public String getLkmMemo() {
return lkmMemo;
}
public void setLkmMemo(String lkmMemo) {
this.lkmMemo = lkmMemo;
}
public Customer getCustomer() {
return customer;
}
public void setCustomer(Customer customer) {
this.customer = customer;
}
@Override
public String toString() {
return "LinkMan [lkmId=" + lkmId + ", lkmName=" + lkmName + ", lkmGender=" + lkmGender + ", lkmPhone="
+ lkmPhone + ", lkmMobile=" + lkmMobile + ", lkmEmail=" + lkmEmail + ", lkmPosition=" + lkmPosition
+ ", lkmMemo=" + lkmMemo + "]";
}
}6.3.4 注解说明
@OneToMany：建立一对多的关系映射，属性如下：
-
targetEntityClass：指定多的多方的类的字节码
-
mappedBy：指定从表实体类中引用主表对象的名称
-
cascade：指定要使用的级联操作
-
fetch：指定是否采用延迟加载
-
orphanRemoval：是否使用孤儿删除
@ManyToOne：建立多对一的关系映射，属性如下：
-
targetEntityClass：指定一的一方的类的字节码
-
cascade：指定是否采用延迟加载
-
fetch：指定是否采用延迟加载
-
optional：关联是否可选。如果设置为false,则必须始终存在非空关系。
@JoinColumn:用于定义主键字段和外键字段的对应关系，属性如下：
- name：指定外键字段的名称
- referencedColumnName：指定引用主表的主键字段名称
- unique：是否唯一，默认值不唯一
- nullable：是否允许为空，默认值允许
- insertable：是否允许插入，默认值允许
- updatable：是否允许更新，默认值允许
- columnDefinition：列的定义信息
6.3.5 一对多的操作
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class OneToManyTest {
@Autowired
private CustomerDao customerDao;
@Autowired
private LinkManDao linkManDao;
/**
* 保存一个客户，保存一个联系人
* 效果，客户和联系人作为独立的数据保存到数据库中
* 联系人的外键为空，原因？实体类中没有配置关系
*/
@Test
@Transactional //配置事务
@Rollback(value = false) //设置不自动回滚
public void testAdd1(){
//创建一个客户，创建一个联系人
Customer customer=new Customer();
customer.setCustName("百度");
LinkMan linkMan=new LinkMan();
linkMan.setLkmName("小李");
/**
* 配置客户到联系人的关系
* 从客户的 角度上:发送两条insert语句，发送有一条更新语句更新数据库（更新外键）
* 由于我们配置客户到联系人的关系，客户可以对外键进行维护
*/
customer.getLinkMans().add(linkMan);
customerDao.save(customer);
linkManDao.save(linkMan);
}
@Test
@Transactional //配置事务
@Rollback(value = false) //设置不自动回滚
public void testAdd2(){
//创建一个客户，创建一个联系人
Customer customer=new Customer();
customer.setCustName("百度");
LinkMan linkMan=new LinkMan();
linkMan.setLkmName("小李");
/**
* 配置联系人到客户的关系
* 只发送两条insert语句
* 由于配置了联系人到客户的映射关系（多对一）
*/
linkMan.setCustomer(customer);
customerDao.save(customer);
linkManDao.save(linkMan);
}
/**
* 会有一条多余的update语句
* 由于一的一方可以维护外键，会发送update语句
* 解决此问题，只需要在一的一方放弃维护权即可
*/
@Test
@Transactional //配置事务
@Rollback(value = false) //设置不自动回滚
public void testAdd3(){
//创建一个客户，创建一个联系人
Customer customer=new Customer();
customer.setCustName("百度");
LinkMan linkMan=new LinkMan();
linkMan.setLkmName("小李");
linkMan.setCustomer(customer);//由于配置了多的一方到一的一方的关联关系（当保存的时候，就已经对外键赋值）
customer.getLinkMans().add(linkMan); //由于一的一方到多的一方的关联关系，发送一条update语句
customerDao.save(customer);
linkManDao.save(linkMan);
}
/**
* 级联添加:保存一个客户的同时，保存客户的所有联系人
*
* 需要在操作主体的实体类上，配置casacde属性(在Customer类的多对一注解）
*/
@Test
@Transactional //配置事务
@Rollback(value = false) //设置不自动回滚
public void testCascadeAdd(){
//创建一个客户，创建一个联系人
Customer customer=new Customer();
customer.setCustName("百度");
LinkMan linkMan=new LinkMan();
linkMan.setLkmName("小李");
linkMan.setCustomer(customer);//由于配置了多的一方到一的一方的关联关系（当保存的时候，就已经对外键赋值）
customer.getLinkMans().add(linkMan); //由于一的一方到多的一方的关联关系，发送一条update语句
customerDao.save(customer);
}
/**
* 级联删除
* 删除1号客户的同时，删除1号客户的所有联系人
*/
@Test
@Transactional //配置事务
@Rollback(value = false) //设置不自动回滚
public void testCascadeDelete(){
//1.查询1号客户
Customer one = customerDao.findOne(1l);
//2.删除
customerDao.delete(one);
}
}
（1）在保存testAdd3的测试中，可以发现设置了双向关系，会发送两条insert语句，一条多余的update语句，解决的思路很简单，就是一的一方放弃维护权。
/**
* 放弃外键维护权
* mappedBy 对方配置关系的属性名称
* cascade配置级联（可以配置到设置多表映射关系的注解上)
* CascadeType.ALL 所有 推荐配置
* MERGE 更新
* PERSIST 保存
* REMOVE 删除
* fetch 配置关联对象的加载方式
* EAGER 立即加载
* LAZY 延迟加载
*/
@OneToMany(mappedBy = "customer",cascade = CascadeType.ALL,fetch = FetchType.EAGER)
private Set<LinkMan> linkMans=new HashSet<LinkMan>();（2）删除的说明如下：
删除从表的数据，可以随时任意删除。
删除主表数据：
有从表的数据：在默认情况下，它会把外键字段置为null，然后删除主表数据。如果在数据库的表结构上，外键字段有非空约束，默认情况就会报错了；如果配置了放弃维护关联关系的权利，则不能删除（与外键字段是否允许为null， 没有关系）因为在删除时，它根本不会去更新从表的外键字段了；如果还想删除，使用级联删除引用。
没有从表的数据，随便删除。
6.4 多对多
6.4.1 示例
我们采用的示例为用户和角色。
用户：指的是咱们班的每一个同学。
角色：指的是咱们班同学的身份信息。
比如A同学，它是我的学生，其中有个身份就是学生，还是家里的孩子，那么他还有个身份是子女。同时B同学，它也具有学生和子女的身份。 那么任何一个同学都可能具有多个身份。同时学生这个身份可以被多个同学所具有。所以我们说，用户和角色之间的关系是多对多。
6.4.2 表关系的建立
多对多的表关系建立靠的是中间表，其中用户表和中间表的关系是一对多，角色表和中间表的关系也是一对多，如下图所示：
6.4.3 实体类关系建立以及映射配置
一个用户可以拥有多个角色，所以在用户实体类中应该包含多个角色的信息，代码如下：
@Entity
@Table(name = "sys_user")
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "user_id")
private Long userId;
@Column(name = "user_name")
private String userName;
@Column(name = "user_age")
private Integer age;
public Set<Role> getRoles() {
return roles;
}
public void setRoles(Set<Role> roles) {
this.roles = roles;
}
/**
* 配置用户到角色的多对多关系
* 配置多对多映射关系
* 1 声明表关系
* @ManyToMany(targetEntity = Role.class) 配置多对多
* 2.配置中间表（包含两个外键）
* @JoinTable
* name:中间表的名称
* joinColumns 配置当前对象在中间表中的外键
* @JoinColumn数组
* inverseJoinColumns 配置对方对象在中间表中的外键
*/
@ManyToMany(targetEntity = Role.class,cascade = CascadeType.ALL)
@JoinTable(name = "sys_user_role",
//joinColumns 配置当前对象在中间表中的外键
joinColumns = {@JoinColumn(name = "sys_user_id",referencedColumnName = "user_id")},
//inverseJoinColumns 配置对方对象在中间表中的外键
inverseJoinColumns = {@JoinColumn(name = "sys_role_id",referencedColumnName = "role_id")}
)
private Set<Role> roles=new HashSet<Role>();
public Long getUserId() {
return userId;
}
public void setUserId(Long userId) {
this.userId = userId;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"userId=" + userId +
", userName='" + userName + '\'' +
", age=" + age +
'}';
}
}
一个角色可以赋予多个用户，所以在角色实体类中应该包含多个用户的信息，代码如下：
@Entity
@Table(name = "sys_role")
public class Role {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name="role_id")
private Long roleId;
@Column(name="role_name")
private String roleName;
//配置多对多
@ManyToMany(mappedBy = "roles")
private Set<User> users=new HashSet<User>();
public Set<User> getUsers() {
return users;
}
public void setUsers(Set<User> users) {
this.users = users;
}
@Override
public String toString() {
return "Role{" +
"roleId=" + roleId +
", roleName='" + roleName + '\'' +
'}';
}
public Long getRoleId() {
return roleId;
}
public void setRoleId(Long roleId) {
this.roleId = roleId;
}
public String getRoleName() {
return roleName;
}
public void setRoleName(String roleName) {
this.roleName = roleName;
}
}
6.4.4 注解说明
@ManyToMany：用于映射多对多的关系，属性如下：
- cascade：配置级联操作
- fetch：配置是否使用延迟加载
- targetEntityClass：配置目标的实体类，映射多对多的时候不用写。
@JoinTable：针对中间表的配置
- nam：配置中间表的名称
- joinColumns：中间表的外键字段关联当前实体类所对应表的主键字段
- inverseJoinColumn：中间表的外键字段关联对方表的主键字段
@JoinColumn：用于定义主键字段和外键字段的对应关系，属性如下：
- name：指定外键字段的名称
- referencedColumnName：指定引用主表的主键字段名称
- unique：是否唯一。默认值不唯一
- nullable：是否允许为空。默认值允许。
- insertable：是否允许插入。默认值允许。
- updatable：是否允许更新。默认值允许。
- columnDefinition：列的定义信息
6.4.5 多对多的操作
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class ManyToManyTest {
@Autowired
private UserDao userDao;
@Autowired
private RoleDao roleDao;
/**
* 保存一个用户，保存一个角色
* 多对多放弃维护权，被动的一方放弃维护权(role被选择）
*/
@Test
@Transactional
@Rollback(value = false)
public void testAdd(){
User user=new User();
user.setUserName("小李");
Role role=new Role();
role.setRoleName("程序员");
user.getRoles().add(role); //配置用户到角色的关系，可以对中间表中的数据进行维护
role.getUsers().add(user); //配置角色到用户的关系，可以对中间表中的数据进行维护
userDao.save(user);
roleDao.save(role);
}
/**
* 测试级联添加， 保存一个用户，同时保存用户关联的角色
*/
@Test
@Transactional
@Rollback(value = false)
public void testCasCodedAdd(){
User user=new User();
user.setUserName("小李");
Role role=new Role();
role.setRoleName("程序员");
user.getRoles().add(role); //配置用户到角色的关系，可以对中间表中的数据进行维护
role.getUsers().add(user); //配置角色到用户的关系，可以对中间表中的数据进行维护
userDao.save(user);
}
}
在多对多的（保存中），如果双向都设置关系，意味着双方都维护中间表，都会往中间表插入数据，中间表的两个字段又作为联合主键。所以报错，主键重复。解决保存失败的问题：只需要在任意一方放弃对中间表的维护权即可，推荐在被动的一方放弃，配置去下：
//配置多对多
@ManyToMany(mappedBy = "roles")
private Set<User> users=new HashSet<User>();7.多表查询
7.1 对象导航查询
对象图导航检索方式是根据已经加载的对象，导航到他的关联对象。它利用类与类之间的关系来检索对象。例如：我们通过ID查询方式查出一个客户，可以调用Customer类中的getLinkMans()方法来获取该客户的所有联系人。对象导航查询的使用要求是：两个对象之间必须存在关联关系。
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class ObjectQueryTest {
@Autowired
private LinkManDao linkManDao;
@Autowired
private CustomerDao customerDao;
//对象导航查询(查询一个对象的时候，通过此对象查询所有的关联对象）
/**
* 默认使用的是延迟加载的形式来查询
* 调用get方法并不会立即发送查询，而是在使用关联对象的时候才会发送查询
* 修改配置，将延迟加载改为立即加载
* fetch：需要配置到多表映射关系的注解上
*
*/
@Test
@Transactional //解决Java中no session问题
@Rollback
public void testQuery(){
Customer one = customerDao.getOne(1L);
//对象导航查询，此客户下的所有联系人;此客户下的所有联系人
Set<LinkMan> linkMans = one.getLinkMans();
for(LinkMan l:linkMans){
System.out.println(l);
}
}
}
900
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
