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);
}
}
}