JAVA框架08 -- Spring Data JPA

Spring Data JPA

Spring Data JPA概述

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

Spring Data JPA的特性

  • 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的快速入门

需求

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

搭建Spring Data JPA的开发环境

引入Spring Data JPA的坐标

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

整合Spring Data JPA与Spring

  • applicationContext.xml



"entityManagerFactoty" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
"dataSource" ref="dataSource" />

"packagesToScan" value="cn.itcast.domain" />

"persistenceProvider">
class="org.hibernate.jpa.HibernatePersistenceProvider"/>



"jpaVendorAdapter">
class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">

"generateDdl" value="false" />

"database" value="MYSQL" />

"databasePlatform" value="org.hibernate.dialect.MySQLDialect" />

"showSql" value="true" />




"jpaDialect" >
class="org.springframework.orm.jpa.vendor.HibernateJpaDialect" />





"dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">







package="cn.itcast.dao" transaction-manager-ref="transactionManager"
entity-manager-factory-ref="entityManagerFactoty" >


"transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">




"txAdvice" transaction-manager="transactionManager">

"save*" propagation="REQUIRED"/>
"insert*" propagation="REQUIRED"/>
"update*" propagation="REQUIRED"/>
"delete*" propagation="REQUIRED"/>
"get*" read-only="true"/>
"find*" read-only="true"/>
"*" propagation="REQUIRED"/>





"pointcut" expression="execution(* cn.itcast.service.*.*(..))" />
"txAdvice" pointcut-ref="pointcut" />







使用JPA注解配置映射关系(编写一个实体类使用注解)

  • 所有注解使用jpa的规范提供的注解(都在javax下的引用)

使用Spring Data JPA完成需求

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

  • Spring Data JPA是spring提供的一款对于数据访问层(Dao层)的框架,使用Spring Data JPA,只需要按照框架的规范提供dao接口,不需要实现类就可以完成数据库的增删改查、分页查询等方法的定义,极大的简化了我们的开发过程
  • 在Spring Data JPA中,对于定义符合规范的Dao层接口,我们只需要遵循以下几点就可以了:
    1. 创建一个Dao层接口,并实现JpaRepository和JpaSpecificationExecutor
    2. 提供相应的泛型
package cn.itcast.dao;
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import cn.itcast.entity.Customer;
/**
* JpaRepository<实体类类型,主键类型>:用来完成基本CRUD操作
* JpaSpecificationExecutor<实体类类型>:用于复杂查询(分页等查询操作)
*/
public interface CustomerDao extends JpaRepository<Customer, Long>, JpaSpecificationExecutor<Customer> {
}

完成基本CRUD操作

方法

  • findOne(id) :根据id查询
  • save(customer):保存或者更新(依据:传递的实体类对象中,是否包含id属性)
  • delete(id) :根据id删除
  • findAll() : 查询全部

使用

  • 完成了Spring Data JPA的环境搭建,并且编写了符合Spring Data JPA 规范的Dao层接口之后,就可以使用定义好的Dao层接口进行客户的基本CRUD操作
@RunWith(SpringJUnit4ClassRunner.class). //声明spring提供的单元测试环境
@ContextConfiguration(locations="classpath:applicationContext.xml") //指定spring容器的配置信息
public class CustomerDaoTest {

@Autowired
private CustomerDao customerDao;

/**
* 保存客户:调用save(obj)方法
*/
@Test
public void testSave() {
Customer c = new Customer();
c.setCustName("传智");
customerDao.save(c);
}

/**
* 修改客户:调用save(obj)方法
* 对于save方法的解释:如果执行此方法是对象中存在id属性,即为更新操作会先根据id查询,再更新
* 如果执行此方法中对象中不存在id属性,即为保存操作
*
*/
@Test
public void testUpdate() {
//根据id查询id为1的客户
Customer customer = customerDao.findOne(1l);
//修改客户名称
customer.setCustName("aa");
//更新
customerDao.save(customer);
}

/**
* 根据id删除:调用delete(id)方法
*/
@Test
public void testDelete() {
customerDao.delete(1l);
}

/**
* 根据id从数据库查询
* @Transactional : 保证getOne正常运行
*
* findOne:
* em.find() :立即加载
* getOne:
* em.getReference :延迟加载
* * 返回的是一个客户的动态代理对象
* * 什么时候用,什么时候查询
*/
@Test
@Transactional
public void testGetOne() {
Customer customer = customerDao.getOne(4l);
System.out.println(customer);
}

/**
* 查询所有
*/
@Test
public void testFindAll() {
List list = customerDao.findAll();
for(Customer customer : list) {
System.out.println(customer);
}
}

/**
* 测试统计查询:查询客户的总数量
* count:统计总条数
*/
@Test
public void testCount() {
long count = customerDao.count();//查询全部的客户数量
System.out.println(count);
}

/**
* 测试:判断id为4的客户是否存在
* 1. 可以查询以下id为4的客户
* 如果值为空,代表不存在,如果不为空,代表存在
* 2. 判断数据库中id为4的客户的数量
* 如果数量为0,代表不存在,如果大于0,代表存在
*/
@Test
public void testExists() {
boolean exists = customerDao.exists(4l);
System.out.println("id为4的客户 是否存在:"+exists);
}
}

springDataJpa的运行过程和原理剖析

  1. 通过JdkDynamicAopProxy的invoke方法创建了一个动态代理对象
  2. SimpleJpaRepository当中封装了JPA的操作(借助JPA的api完成数据库的CRUD)
  3. 通过hibernate完成数据库操作(封装了jdbc)

复杂查询

借助接口中的定义好的方法完成查询

  • 在继承JpaRepository,和JpaRepository接口后,我们就可以使用接口中定义的方法进行查询

继承JpaRepository后的方法列表

继承JpaSpecificationExecutor的方法列表

jpql的查询方式

  • 使用Spring Data JPA提供的查询方法已经可以解决大部分的应用场景,但是对于某些业务来说,我们还需要灵活的构造查询条件,这时就可以使用@Query注解,结合JPQL的语句方式完成查询
  • @Query 注解的使用非常简单,只需在方法上面标注该注解,同时提供一个JPQL查询语句即可
public interface CustomerDao extends JpaRepository<Customer, Long>,JpaSpecificationExecutor<Customer> {    
//@Query 使用jpql的方式查询。
@Query(value="from Customer")
public List findAllCustomer();

//@Query 使用jpql的方式查询。?1代表参数的占位符,其中1对应方法中的参数索引
@Query(value="from Customer where custName = ?1")
public Customer findCustomer(String custName);
}
  • 此外,也可以通过使用 @Query 来执行一个更新操作,为此,我们需要在使用 @Query 的同时,用 @Modifying 来将该操作标识为修改查询,这样框架最终会生成一个更新的操作,而非查询
@Query(value="update Customer set custName = ?1 where custId = ?2")
@Modifying
public void updateCustomer(String custName,Long custId);"

使用SQL语句查询

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

方法命名规则查询

  • 方法命名规则查询就是根据方法的名字,就能创建查询。只需要按照Spring Data JPA提供的方法命名规则定义方法的名称,就可以完成查询工作。Spring Data JPA在程序执行的时候会根据方法名称进行解析,并自动生成查询语句进行查询
  • 按照Spring Data JPA 定义的规则,查询方法以findBy开头,涉及条件查询时,条件的属性用条件关键字连接,要注意的是:条件属性首字母需大写。框架在进行方法名解析时,会先把方法名多余的前缀截取掉,然后对剩下部分进行解析。
//方法命名方式查询(根据客户名称查询客户)
public Customer findByCustName(String custName);

具体的关键字,使用方法和生产成SQL如下表所示

总代码

dao

public interface CustomerDao extends JpaRepository<Customer,Long> ,JpaSpecificationExecutor<Customer> {

/**
* 案例:根据客户名称查询客户
* 使用jpql的形式查询
* 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(value = "from Customer where custName = ?2 and custId = ?1")
public Customer findCustNameAndId(Long id,String name);

/**
* 使用jpql完成更新操作
* 案例 : 根据id更新,客户的名称
* 更新4号客户的名称,将名称改为“aaa”
*
* sql :update cst_customer set cust_name = ? where cust_id = ?
* jpql : update Customer set custName = ? where custId = ?
*
* @Query : 代表的是进行查询
* * 声明此方法是用来进行更新操作
* @Modifying
* * 当前执行的是一个更新操作
*
*/
@Query(value = " update Customer set custName = ?2 where custId = ?1 ")
@Modifying
public void updateCustomer(long custId,String custName);


/**
* 使用sql的形式查询:
* 查询全部的客户
* sql : select * from cst_customer;
* Query : 配置sql查询
* value : sql语句
* nativeQuery : 查询方式
* true : sql查询
* false:jpql查询
*
*/
//@Query(value = " select * from cst_customer" ,nativeQuery = true)
@Query(value="select * from cst_customer where cust_name like ?1",nativeQuery = true)
public List findSql(String name);


/**
* 方法名的约定:
* findBy : 查询
* 对象中的属性名(首字母大写) : 查询的条件
* CustName
* * 默认情况 : 使用 等于的方式查询
* 特殊的查询方式
*
* findByCustName -- 根据客户名称查询
*
* 再springdataJpa的运行阶段
* 会根据方法名称进行解析 findBy from xxx(实体类)
* 属性名称 where custName =
*
* 1.findBy + 属性名称 (根据属性名称进行完成匹配的查询=)
* 2.findBy + 属性名称 + “查询方式(Like | isnull)”
* findByCustNameLike
* 3.多条件查询
* findBy + 属性名 + “查询方式” + “多条件的连接符(and|or)” + 属性名 + “查询方式”
*/
public Customer findByCustName(String custName);


public List findByCustNameLike(String custName);

//使用客户名称模糊匹配和客户所属行业精准匹配的查询
public Customer findByCustNameLikeAndCustIndustry(String custName,String custIndustry);
}

test

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

@Test
public void testFindJPQL() {
Customer customer = customerDao.findJpql("aaa");
System.out.println(customer);
}


@Test
public void testFindCustNameAndId() {
// Customer customer = customerDao.findCustNameAndId("aaa",1l);
Customer customer = customerDao.findCustNameAndId(1l,"aaa");
System.out.println(customer);
}

/**
* 测试jpql的更新操作
* * springDataJpa中使用jpql完成 更新/删除操作
* * 需要手动添加事务的支持
* * 默认会执行结束之后,回滚事务
* @Rollback : 设置是否自动回滚
* false | true
*/
@Test
@Transactional //添加事务的支持
@Rollback(value = false)
public void testUpdateCustomer() {
customerDao.updateCustomer(4l,"aaa");
}

//测试sql查询
@Test
public void testFindSql() {
List list = customerDao.findSql("aaa%");
for(Object [] obj : list) {
System.out.println(Arrays.toString(obj));
}
}


//测试方法命名规则的查询
@Test
public void testNaming() {
Customer customer = customerDao.findByCustName("aaa");
System.out.println(customer);
}


//测试方法命名规则的查询
@Test
public void testFindByCustNameLike() {
List list = customerDao.findByCustNameLike("aaa%");
for (Customer customer : list) {
System.out.println(customer);
}
}


//测试方法命名规则的查询
@Test
public void testFindByCustNameLikeAndCustIndustry() {
Customer customer = customerDao.findByCustNameLikeAndCustIndustry("aaa1%", "it");
System.out.println(customer);
}
}

Specifications动态查询

  • 有时我们在查询某个实体的时候,给定的条件是不固定的,这时就需要动态构建相应的查询语句,在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;

/**
* JpaSpecificationExecutor中定义的方法
**/
public interface JpaSpecificationExecutor<T> {
//根据条件查询一个对象
T findOne(Specification spec);
//根据条件查询集合
List findAll(Specification spec);
//根据条件分页查询
//Pageable:分页参数对象
Page findAll(Specification spec, Pageable pageable);
//排序查询查询
List findAll(Specification spec, Sort sort);
//统计查询
long count(Specification spec);
}
  • 对于JpaSpecificationExecutor,这个接口基本是围绕着Specification接口来定义的。我们可以简单的理解为,Specification构造的就是查询条件。

  • Specification接口中只定义了如下一个方法

//构造查询条件
/**
* root :Root接口,代表查询的根对象,可以通过root获取实体中的属性 (查询的任何属性都可以从根对象中获取)
* query :代表一个顶层查询对象,用来自定义查询(一般不用)
* cb :用来构建查询,此对象里有很多查询条件方法
**/
public Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder cb);

使用Specifications完成条件查询

@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.查询方式
* cb对象
* 2.比较的属性名称
* root对象
*
*/
Specification spec = new Specification() {
@Override
public Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder cb) {
//1.获取比较的属性
Path custName = root.get("custId");
//2.构造查询条件 : select * from cst_customer where cust_name = '传智播客'
/**
* 第一个参数:需要比较的属性(path对象)
* 第二个参数:当前需要比较的取值
*/
Predicate predicate = cb.equal(custName, "aaa");//进行精准的匹配 (比较的属性,比较的属性的取值)
return predicate;
}
};
Customer customer = customerDao.findOne(spec);
System.out.println(customer);
}

/**
* 多条件查询
* 案例:根据客户名(aaa)和客户所属行业查询(it)
*
*/
@Test
public void testSpec1() {
/**
* root:获取属性
* 客户名
* 所属行业
* cb:构造查询
* 1.构造客户名的精准匹配查询
* 2.构造所属行业的精准匹配查询
* 3.将以上两个查询联系起来
*/
Specification spec = new Specification() {
@Override
public Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder cb) {
Path custName = root.get("custName");//客户名
Path custIndustry = root.get("custIndustry");//所属行业

//构造查询
//1.构造客户名的精准匹配查询
Predicate p1 = cb.equal(custName, "aaa");//第一个参数,path(属性),第二个参数,属性的取值
//2..构造所属行业的精准匹配查询
Predicate p2 = cb.equal(custIndustry, "it");
//3.将多个查询条件组合到一起:组合(满足条件一并且满足条件二:与关系,满足条件一或满足条件二即可:或关系)
Predicate and = cb.and(p1, p2);//以与的形式拼接多个查询条件
// cb.or();//以或的形式拼接多个查询条件
return and;
}
};
Customer customer = customerDao.findOne(spec);
System.out.println(customer);
}


/**
* 案例:完成根据客户名称的模糊匹配,返回客户列表
* 客户名称以 ’aaa‘ 开头
*
* equal :直接得到path对象(属性),然后进行比较即可
* gt,lt,ge,le,like : 得到path对象,根据path指定比较的参数类型,再去进行比较
* 指定参数类型:path.as(类型的字节码对象)
*/
@Test
public void testSpec3() {
//构造查询条件
Specification spec = new Specification() {
@Override
public Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder cb) {
//查询属性:客户名
Path custName = root.get("custName");
//查询方式:模糊匹配
Predicate like = cb.like(custName.as(String.class), "aaa%");
return like;
}
};
// List list = customerDao.findAll(spec);
// for (Customer customer : list) {
// System.out.println(customer);
// }
//添加排序
//创建排序对象,需要调用构造方法实例化sort对象
//第一个参数:排序的顺序(倒序,正序)
// Sort.Direction.DESC:倒序
// Sort.Direction.ASC : 升序
//第二个参数:排序的属性名称
Sort sort = new Sort(Sort.Direction.DESC,"custId");
List list = customerDao.findAll(spec, sort);
for (Customer customer : list) {
System.out.println(customer);
}
}

/**
* 分页查询
* Specification: 查询条件
* Pageable:分页参数
* 分页参数:查询的页码,每页查询的条数
* findAll(Specification,Pageable):带有条件的分页
* findAll(Pageable):没有条件的分页
* 返回:Page(springDataJpa为我们封装好的pageBean对象,数据列表,总条数)
*/
@Test
public void testSpec4() {

Specification spec = null;
//PageRequest对象是Pageable接口的实现类
/**
* 创建PageRequest的过程中,需要调用他的构造方法传入两个参数
* 第一个参数:当前查询的页数(从0开始)
* 第二个参数:每页查询的数量
*/
Pageable pageable = new PageRequest(0,2);
//分页查询
Page page = customerDao.findAll(null, pageable);
System.out.println(page.getContent()); //得到数据集合列表
System.out.println(page.getTotalElements());//得到总条数
System.out.println(page.getTotalPages());//得到总页数
}
}

基于Specifications的分页查询

@Test
public void testPage() {
//构造查询条件
Specification spec = new Specification() {
public Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder cb) {
return cb.like(root.get("custName").as(String.class), "a%");
}
};

/**
* 构造分页参数
* Pageable : 接口
* PageRequest实现了Pageable接口,调用构造方法的形式构造
* 第一个参数:页码(从0开始)
* 第二个参数:每页查询条数
*/
Pageable pageable = new PageRequest(0, 5);

/**
* 分页查询,封装为Spring Data Jpa 内部的page bean
* 此重载的findAll方法为分页方法需要两个参数
* 第一个参数:查询条件Specification
* 第二个参数:分页参数
*/
Page page = customerDao.findAll(spec,pageable);

}
  • 对于Spring Data JPA中的分页查询,是其内部自动实现的封装过程,返回的是一个Spring Data JPA提供的pageBean对象
 //获取总页数
int getTotalPages();
//获取总记录数
long getTotalElements();
//获取列表数据
List getContent();

方法对应关系

方法名称 Sql对应关系
equle filed = value
gt(greaterThan ) filed > value
lt(lessThan ) filed < value
ge(greaterThanOrEqualTo ) filed >= value
le( lessThanOrEqualTo) filed <= value
notEqule filed != value
like filed like value
notLike filed not like value

JPA中的一对多

在JPA框架中表关系的分析步骤

  • 第一步:首先确定两张表之间的关系。
    • 如果关系确定错了,后面做的所有操作就都不可能正确。
  • 第二步:在数据库中实现两张表的关系(外键|中间表)
  • 第三步:在实体类中描述出两个实体的关系(包含关系)
  • 第四步:配置出实体类和数据库表的关系映射

实体类关系建立以及映射配置

  • 例如:在实体类中,由于客户是少的一方,它应该包含多个联系人,所以实体类要体现出客户中有多个联系人的信息,代码如下:

domain和dao

### customer.java

@Entity
@Table(name="cst_customer")
public class Customer {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name="cust_id")
private Long custId;
@Column(name="cust_address")
private String custAddress;
...

//配置客户和联系人之间的关系(一对多关系)
/**
* 使用注解的形式配置多表关系
* 1.声明关系
* @OneToMany : 配置一对多关系
* targetEntity :对方对象的字节码对象
* 2.配置外键(中间表)
* @JoinColumn : 配置外键
* name:外键字段名称
* referencedColumnName:参照的主表的主键字段名称
*
* * 在客户实体类上(一的一方)添加了外键了配置,所以对于客户而言,也具备了维护外键的作用
*
*/

@OneToMany(targetEntity = LinkMan.class)
@JoinColumn(name = "lkm_cust_id",referencedColumnName = "cust_id")

@OneToMany(mappedBy = "customer",cascade = CascadeType.ALL)
private Set linkMans = new HashSet<>();



### linkman.java

@Entity
@Table(name = "cst_linkman")
public class LinkMan {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "lkm_id")
private Long lkmId; //联系人编号(主键)
@Column(name = "lkm_name")
private String lkmName;//联系人姓名
...

/**
* 配置联系人到客户的多对一关系
* 使用注解的形式配置多对一关系
* 1.配置表关系
* @ManyToOne : 配置多对一关系
* targetEntity:对方的实体类字节码
* 2.配置外键(中间表)
*
* * 配置外键的过程,配置到了多的一方,就会在多的一方维护外键
*
*/
@ManyToOne(targetEntity = Customer.class,fetch = FetchType.LAZY)
@JoinColumn(name = "lkm_cust_id",referencedColumnName = "cust_id")
private Customer customer;
/**
* 联系人的dao接口
*/
public interface LinkManDao extends JpaRepository<LinkMan,Long>, JpaSpecificationExecutor<LinkMan> {
}

...

application.xml添加代码


"jpaProperties" >

update


映射的注解说明

@OneToMany:

  • 作用:建立一对多的关系映射
  • 属性:
    • targetEntityClass:指定多的多方的类的字节码
    • mappedBy:指定从表实体类中引用主表对象的名称。
    • cascade:指定要使用的级联操作
    • fetch:指定是否采用延迟加载
    • orphanRemoval:是否使用孤儿删除

@ManyToOne

  • 作用:建立多对一的关系
  • 属性:
    • targetEntityClass:指定一的一方实体类字节码
    • cascade:指定要使用的级联操作
    • fetch:指定是否采用延迟加载
    • optional:关联是否可选。如果设置为false,则必须始终存在非空关系。

@JoinColumn

  • 作用:用于定义主键字段和外键字段的对应关系。
  • 属性:
    • name:指定外键字段的名称
    • referencedColumnName:指定引用主表的主键字段名称
    • unique:是否唯一。默认值不唯一
    • nullable:是否允许为空。默认值允许。
    • insertable:是否允许插入。默认值允许。
    • updatable:是否允许更新。默认值允许。
    • columnDefinition:列的定义信息。

删除

  • 从表数据:可以随时任意删除。

  • 主表数据:

  • 有从表数据

    1. 在默认情况下,它会把外键字段置为null,然后删除主表数据。如果在数据库的表 结构上,外键字段有非空约束,默认情况就会报错了。
    2. 如果配置了放弃维护关联关系的权利,则不能删除(与外键字段是否允许为null,没有关系)因为在删除时,它根本不会去更新从表的外键字段了。
    3. 如果还想删除,使用级联删除引用
  • 没有从表数据引用:随便删

test

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class OneToManyTest {

@Autowired
private CustomerDao customerDao;

@Autowired
private LinkManDao linkManDao;

/**
* 保存一个客户,保存一个联系人
* 效果:客户和联系人作为独立的数据保存到数据库中
* 联系人的外键为空
* 原因?
* 实体类中没有配置关系
*/
@Test
@Transactional //配置事务
@Rollback(false) //不自动回滚
public void testAdd() {
//创建一个客户,创建一个联系人
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(false) //不自动回滚
public void testAdd1() {
//创建一个客户,创建一个联系人
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(false) //不自动回滚
public void testAdd2() {
//创建一个客户,创建一个联系人
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);
}

级联操作

  • 级联操作:指操作一个对象同时操作它的关联对象

  • 使用方法:只需要在操作主体的注解上配置cascade

/**
* cascade:配置级联操作
* CascadeType.MERGE 级联更新
* CascadeType.PERSIST 级联保存:
* CascadeType.REFRESH 级联刷新:
* CascadeType.REMOVE 级联删除:
* CascadeType.ALL 包含所有
*/
@OneToMany(mappedBy="customer",cascade=CascadeType.ALL)
private Set linkMans = new HashSet<>();

JPA中的多对多

映射的注解说明

@ManyToMany

  • 作用:用于映射多对多关系
  • 属性:
    • cascade:配置级联操作。
    • fetch:配置是否采用延迟加载。
    • targetEntity:配置目标的实体类。映射多对多的时候不用写。

@JoinTable

  • 作用:针对中间表的配置
  • 属性:
    • nam:配置中间表的名称
    • joinColumns:中间表的外键字段关联当前实体类所对应表的主键
    • inverseJoinColumn:中间表的外键字段关联对方表的主键字段

@JoinColumn

  • 作用:用于定义主键字段和外键字段的对应关系。
  • 属性:
    • name:指定外键字段的名称
    • referencedColumnName:指定引用主表的主键字段名称
    • unique:是否唯一。默认值不唯一
    • nullable:是否允许为空。默认值允许。
    • insertable:是否允许插入。默认值允许。
    • updatable:是否允许更新。默认值允许。
    • columnDefinition:列的定义信息。

示例代码

domain

### user.java
@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="age")
private Integer age;

/**
* 配置用户到角色的多对多关系
* 配置多对多的映射关系
* 1.声明表关系的配置
* @ManyToMany(targetEntity = Role.class) //多对多
* targetEntity:代表对方的实体类字节码
* 2.配置中间表(包含两个外键)
* @JoinTable
* name : 中间表的名称
* joinColumns:配置当前对象在中间表的外键
* @JoinColumn的数组
* name:外键名
* referencedColumnName:参照的主表的主键名
* 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 roles = new HashSet<>();


### role.java

@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;

@JoinTable(name = "sys_user_role",
//joinColumns,当前对象在中间表中的外键
joinColumns = {@JoinColumn(name = "sys_role_id",referencedColumnName = "role_id")},
//inverseJoinColumns,对方对象在中间表的外键
inverseJoinColumns = {@JoinColumn(name = "sys_user_id",referencedColumnName = "user_id")}
private Set users = new HashSet<>();

test

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class ManyToManyTest {

@Autowired
private UserDao userDao;
@Autowired
private RoleDao roleDao;

/**
* 保存一个用户,保存一个角色
*
* 多对多放弃维护权:被动的一方放弃
*/
@Test
@Transactional
@Rollback(false)
public void testAdd() {
User user = new User();
user.setUserName("小李");

Role role = new Role();
role.setRoleName("java程序员");

//配置用户到角色关系,可以对中间表中的数据进行维护 1-1
user.getRoles().add(role);

//配置角色到用户的关系,可以对中间表的数据进行维护 1-1
role.getUsers().add(user);

userDao.save(user);
roleDao.save(role);
}


//测试级联添加(保存一个用户的同时保存用户的关联角色)
@Test
@Transactional
@Rollback(false)
public void testCasCadeAdd() {
User user = new User();
user.setUserName("小李");

Role role = new Role();
role.setRoleName("java程序员");

//配置用户到角色关系,可以对中间表中的数据进行维护 1-1
user.getRoles().add(role);

//配置角色到用户的关系,可以对中间表的数据进行维护 1-1
role.getUsers().add(user);

userDao.save(user);
}

/**
* 案例:删除id为1的用户,同时删除他的关联对象
*/
@Test
@Transactional
@Rollback(false)
public void testCasCadeRemove() {
//查询1号用户
User user = userDao.findOne(1l);
//删除1号用户
userDao.delete(user);

}
}
  • 在多对多(保存)中,如果双向都设置关系,意味着双方都维护中间表,都会往中间表插入数据,中间表的2个字段又作为联合主键,所以报错,主键重复,解决保存失败的问题:只需要在任意一方放弃对中间表的维护权即可,推荐在被动的一方放弃
//放弃对中间表的维护权,解决保存中主键冲突的问题
@ManyToMany(mappedBy="roles")
private Set users = new HashSet(0);
  • 删除
@Autowired
private UserDao userDao;
/**
* 删除操作
* 在多对多的删除时,双向级联删除根本不能配置
* 禁用
* 如果配了的话,如果数据之间有相互引用关系,可能会清空所有数据
*/
@Test
@Transactional
@Rollback(false)//设置为不回滚
public void testDelete() {
userDao.delete(1l);
}

Spring Data JPA中的多表查询

对象导航查询

  • 对象图导航检索方式是根据已经加载的对象,导航到他的关联对象。它利用类与类之间的关系来检索对象。例如:我们通过ID查询方式查出一个客户,可以调用Customer类中的getLinkMans()方法来获取该客户的所有联系人。对象导航查询的使用要求是:两个对象之间必须存在关联关系

  • 查询一个客户,获取该客户下的所有联系人

@Autowired
private CustomerDao customerDao;

@Test
//由于是在java代码中测试,为了解决no session问题,将操作配置到同一个事务中
@Transactional
public void testFind() {
Customer customer = customerDao.findOne(5l);
Set linkMans = customer.getLinkMans();//对象导航查询
for(LinkMan linkMan : linkMans) {
System.out.println(linkMan);
}
}
  • 查询一个联系人,获取该联系人的所有客户
@Autowired
private LinkManDao linkManDao;


@Test
public void testFind() {
LinkMan linkMan = linkManDao.findOne(4l);
Customer customer = linkMan.getCustomer(); //对象导航查询
System.out.println(customer);
}

延迟加载

  • 延迟加载的思想。通过配置的方式来设定当我们在需要使用时,发起真正的查询。
  • 对象导航查询默认使用的是延迟加载的形式查询的
/**
* 在客户对象的@OneToMany注解中添加fetch属性
* FetchType.EAGER :立即加载
* FetchType.LAZY :延迟加载
*/
@OneToMany(mappedBy="customer",fetch=FetchType.EAGER)
private Set linkMans = new HashSet<>(0);

使用Specification查询

/**
* Specification的多表查询
*/
@Test
public void testFind() {
Specification spec = new Specification() {
public Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder cb) {
//Join代表链接查询,通过root对象获取
//创建的过程中,第一个参数为关联对象的属性名称,第二个参数为连接查询的方式(left,inner,right)
//JoinType.LEFT : 左外连接,JoinType.INNER:内连接,JoinType.RIGHT:右外连接
Join join = root.join("customer",JoinType.INNER);
return cb.like(join.get("custName").as(String.class),"传智播客1");
}
};
List list = linkManDao.findAll(spec);
for (LinkMan linkMan : list) {
System.out.println(linkMan);
}
}

你可能感兴趣的:(JAVA框架08 -- Spring Data JPA)