SpringDataJpa（三）

七、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<T> spec);	//根据条件查询集合List<T> findAll(Specification<T> spec);//根据条件分页查询Page<T> findAll(Specification<T> spec, Pageable pageable);//排序查询查询List<T> findAll(Specification<T> spec, Sort sort);//统计查询long count(Specification<T> spec);
}

对于JpaSpecificationExecutor，这个接口基本是围绕着Specification接口来定义的。我们可以简单的理解为，Specification构造的就是查询条件。

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

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

7.1 基于Specifications实现查询

代码结构

在这里插入图片描述

dao、domain、applicationContext.xml、pom.xml不变，延用上面部分。

对test文件夹编写代码

7.1.1 条件查询

test/SpecTest.java

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class SpecTest {@Autowiredprivate CustomerDao customerDao;/*** 根据条件，查询单个对象**/@Testpublic void testSpec() {//匿名内部类/*** 自定义查询条件*      1.实现Specification接口（提供泛型：查询的对象类型）*      2.实现toPredicate方法（构造查询条件）*      3.需要借助方法参数中的两个参数（*          root：获取需要查询的对象属性*          CriteriaBuilder：构造查询条件的，内部封装了很多的查询条件（模糊匹配，精准匹配）*       ）*  案例：根据客户名称查询，查询客户名为传智播客的客户*          查询条件*              1.查询方式*                  cb对象*              2.比较的属性名称*                  root对象**/Specification<Customer> spec = new Specification<Customer>() {@Overridepublic Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {//1.获取比较的属性Path<Object> custName = root.get("custId");//2.构造查询条件  ：    select * from cst_customer where cust_name = '传智播客'/*** 第一个参数：需要比较的属性（path对象）* 第二个参数：当前需要比较的取值*/Predicate predicate = cb.equal(custName, "传智播客");//进行精准的匹配  （比较的属性，比较的属性的取值）return predicate;}};Customer customer = customerDao.findOne(spec);System.out.println(customer);}/*** 多条件查询*      案例：根据客户名（传智播客）和客户所属行业查询（it教育）**/@Testpublic void testSpec1() {/***  root:获取属性*      客户名*      所属行业*  cb：构造查询*      1.构造客户名的精准匹配查询*      2.构造所属行业的精准匹配查询*      3.将以上两个查询联系起来*/Specification<Customer> spec = new Specification<Customer>() {@Overridepublic Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {Path<Object> custName = root.get("custName");//客户名Path<Object> custIndustry = root.get("custIndustry");//所属行业//构造查询//1.构造客户名的精准匹配查询Predicate p1 = cb.equal(custName, "传智播客");//第一个参数，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);}
}

7.1.2 模糊查询

    /*** 案例：完成根据客户名称的模糊匹配，返回客户列表*      客户名称以 ’传智播客‘ 开头** equal ：直接的到path对象（属性），然后进行比较即可* gt，lt,ge,le,like : 得到path对象，根据path指定比较的参数类型，再去进行比较*      指定参数类型：path.as(类型的字节码对象)*/@Testpublic void testSpec3() {//构造查询条件Specification<Customer> spec = new Specification<Customer>() {@Overridepublic Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {//查询属性：客户名Path<Object> custName = root.get("custName");//查询方式：模糊匹配Predicate like = cb.like(custName.as(String.class), "传智播客%");return like;}};
//        List<Customer> 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<Customer> list = customerDao.findAll(spec, sort);for (Customer customer : list) {System.out.println(customer);}}

7.1.3 分页查询

对于Spring Data JPA中的分页查询，是其内部自动实现的封装过程，返回的是一个Spring Data JPA提供的pageBean对象。其中的方法说明如下：

    /*** 分页查询*      Specification: 查询条件*      Pageable：分页参数*          分页参数：查询的页码，每页查询的条数*          findAll(Specification,Pageable)：带有条件的分页*          findAll(Pageable)：没有条件的分页*  返回：Page（springDataJpa为我们封装好的pageBean对象，数据列表，共条数）*/@Testpublic void testSpec4() {Specification spec = null;//PageRequest对象是Pageable接口的实现类/*** 创建PageRequest的过程中，需要调用他的构造方法传入两个参数*      第一个参数：当前查询的页数（从0开始）*      第二个参数：每页查询的数量*/Pageable pageable = new PageRequest(0,2);//分页查询Page<Customer> page = customerDao.findAll(null, pageable);System.out.println(page.getContent());         //得到数据集合列表System.out.println(page.getTotalElements());   //得到总条数System.out.println(page.getTotalPages());      //得到总页数}

7.2 方法对应关系

方法名称Sql对应关系
equlefiled = value
gt（greaterThan ）filed > value
lt（lessThan ）filed < value
ge（greaterThanOrEqualTo ）filed >= value
le（ lessThanOrEqualTo）filed <= value
notEqulefiled != value
likefiled like value
notLikefiled not like value

八、多表设计

8.1 表之间关系的划分

数据库中多表之间存在着三种关系，如图所示。

在这里插入图片描述

明确：我们今天只涉及实际开发中常用的关联关系，一对多和多对多。而一对一的情况，在实际开发中几乎不用

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

在实际开发中，我们数据库的表难免会有相互的关联关系，在操作表的时候就有可能会涉及到多张表的操作。而在这种实现了ORM思想的框架中（如JPA），可以让我们通过操作实体类就实现对数据库表的操作。所以今天我们的学习重点是：掌握配置实体之间的关联关系。

第一步：首先确定两张表之间的关系。

​ 如果关系确定错了，后面做的所有操作就都不可能正确。

第二步：在数据库中实现两张表的关系

第三步：在实体类中描述出两个实体的关系

第四步：配置出实体类和数据库表的关系映射（重点）

九、JPA中的一对多

9.1 示例分析

我们采用的示例为客户和联系人。

客户：指的是一家公司，我们记为A。

联系人：指的是A公司中的员工。

在不考虑兼职的情况下，公司和员工的关系即为一对多。

9.2 表关系建立

在一对多关系中，我们习惯把一的一方称之为主表，把多的一方称之为从表。在数据库中建立一对多的关系，需要使用数据库的外键约束。

外键：指的是从表中有一列，取值参照主表的主键，这一列就是外键。

一对多数据库关系的建立，如下图所示

在这里插入图片描述

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

代码结构如下

在这里插入图片描述

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

domain/Customer.java

package cn.itcast.domain;import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;/*** 1.实体类和表的映射关系*      @Eitity*      @Table* 2.类中属性和表中字段的映射关系*      @Id*      @GeneratedValue*      @Column*/
@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;@Column(name="cust_industry")private String custIndustry;@Column(name="cust_level")private String custLevel;@Column(name="cust_name")private String custName;@Column(name="cust_phone")private String custPhone;@Column(name="cust_source")private String custSource;//配置客户和联系人之间的关系（一对多关系）/*** 使用注解的形式配置多表关系*      1.声明关系*          @OneToMany : 配置一对多关系*              targetEntity ：对方对象的字节码对象*      2.配置外键（中间表）*              @JoinColumn : 配置外键*                  name：外键字段名称*                  referencedColumnName：参照的主表的主键字段名称**  * 在客户实体类上（一的一方）添加了外键了配置，所以对于客户而言，也具备了维护外键的作用**///    @OneToMany(targetEntity = LinkMan.class)
//    @JoinColumn(name = "lkm_cust_id",referencedColumnName = "cust_id")/*** 放弃外键维护权*      mappedBy：对方配置关系的属性名称\* cascade : 配置级联（可以配置到设置多表的映射关系的注解上）*      CascadeType.all         : 所有*                  MERGE       ：更新*                  PERSIST     ：保存*                  REMOVE      ：删除** fetch : 配置关联对象的加载方式*          EAGER   ：立即加载*          LAZY    ：延迟加载*/@OneToMany(mappedBy = "customer",cascade = CascadeType.ALL)private Set<LinkMan> linkMans = new HashSet<>();public Long getCustId() {return custId;}public void setCustId(Long custId) {this.custId = custId;}public String getCustAddress() {return custAddress;}public void setCustAddress(String custAddress) {this.custAddress = custAddress;}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 getCustName() {return custName;}public void setCustName(String custName) {this.custName = custName;}public String getCustPhone() {return custPhone;}public void setCustPhone(String custPhone) {this.custPhone = custPhone;}public String getCustSource() {return custSource;}public void setCustSource(String custSource) {this.custSource = custSource;}public Set<LinkMan> getLinkMans() {return linkMans;}public void setLinkMans(Set<LinkMan> linkMans) {this.linkMans = linkMans;}@Overridepublic String toString() {return "Customer{" +"custId=" + custId +", custAddress='" + custAddress + '\'' +", custIndustry='" + custIndustry + '\'' +", custLevel='" + custLevel + '\'' +", custName='" + custName + '\'' +", custPhone='" + custPhone + '\'' +", custSource='" + custSource + '\'' +'}';}
}

由于联系人是多的一方，在实体类中要体现出，每个联系人只能对应一个客户，代码如下：

daomain/LinkMan.java

package cn.itcast.domain;import javax.persistence.*;@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;//联系人姓名@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;//联系人备注/*** 配置联系人到客户的多对一关系*     使用注解的形式配置多对一关系*      1.配置表关系*          @ManyToOne : 配置多对一关系*              targetEntity：对方的实体类字节码*      2.配置外键（中间表）** * 配置外键的过程，配置到了多的一方，就会在多的一方维护外键**/@ManyToOne(targetEntity = Customer.class,fetch = FetchType.LAZY)@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;}@Overridepublic String toString() {return "LinkMan{" +"lkmId=" + lkmId +", lkmName='" + lkmName + '\'' +", lkmGender='" + lkmGender + '\'' +", lkmPhone='" + lkmPhone + '\'' +", lkmMobile='" + lkmMobile + '\'' +", lkmEmail='" + lkmEmail + '\'' +", lkmPosition='" + lkmPosition + '\'' +", lkmMemo='" + lkmMemo + '\'' +'}';}
}

do/CustomerDao.java

package cn.itcast.dao;import cn.itcast.domain.Customer;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;import java.util.List;/*** 符合SpringDataJpa的dao层接口规范*      JpaRepository<操作的实体类类型，实体类中主键属性的类型>*          * 封装了基本CRUD操作*      JpaSpecificationExecutor<操作的实体类类型>*          * 封装了复杂查询（分页）*/
public interface CustomerDao extends JpaRepository<Customer,Long> ,JpaSpecificationExecutor<Customer> {}

do/LinkeManDao.java

package cn.itcast.dao;import cn.itcast.domain.LinkMan;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;/*** 联系人的dao接口*/
public interface LinkManDao extends JpaRepository<LinkMan,Long>, JpaSpecificationExecutor<LinkMan> {
}

9.4 映射的注解说明

@OneToMany：建立一对多的关系映射

​ 属性：

​ targetEntityClass：指定多的多方的类的字节码

​ mappedBy：指定从表实体类中引用主表对象的名称

​ cascade：指定要使用的级联操作

​ fetch：指定是否采用延迟加载

​ orphanRemoval：是否使用孤儿删除

@ManyToOne：建立多对一的关系

​ 属性：

​ targetEntityClass：指定一的一方实体类字节码

​ cascade：指定要使用的级联操作

​ fetch：指定是否采用延迟加载

​ optional：关联是否可选。如果设置为false，则必须始终存在非空关系。

@JoinColumn：用于定义主键字段和外键字段的对应关系。

​ 属性：

​ name：指定外键字段的名称

​ referencedColumnName：指定引用主表的主键字段名称

​ unique：是否唯一。默认值不唯一

​ nullable：是否允许为空。默认值允许。

​ insertable：是否允许插入。默认值允许。

​ updatable：是否允许更新。默认值允许。

​ columnDefinition：列的定义信息。

9.5 一对多的操作

9.5.1 添加

test/OneToManyTest.java

package cn.itcast.test;import cn.itcast.dao.CustomerDao;
import cn.itcast.dao.LinkManDao;
import cn.itcast.domain.Customer;
import cn.itcast.domain.LinkMan;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class OneToManyTest {@Autowiredprivate CustomerDao customerDao;@Autowiredprivate 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);}/*** 级联添加：保存一个客户的同时，保存客户的所有联系人*      需要在操作主体的实体类上，配置casacde属性*/@Test@Transactional //配置事务@Rollback(false) //不自动回滚public void testCascadeAdd() {Customer customer = new Customer();customer.setCustName("百度1");LinkMan linkMan = new LinkMan();linkMan.setLkmName("小李1");linkMan.setCustomer(customer);customer.getLinkMans().add(linkMan);customerDao.save(customer);}/*** 级联删除：*      删除1号客户的同时，删除1号客户的所有联系人*/@Test@Transactional //配置事务@Rollback(false) //不自动回滚public void testCascadeRemove() {//1.查询1号客户Customer customer = customerDao.findOne(1l);//2.删除1号客户customerDao.delete(customer);}
}

通过保存的案例，我们可以发现在设置了双向关系之后，会发送两条insert语句，一条多余的update语句，那我们的解决是思路很简单，就是一的一方放弃维护权

Customer.java

	/***放弃外键维护权的配置将如下配置改为*///@OneToMany(targetEntity=LinkMan.class)//@JoinColumn(name="lkm_cust_id",referencedColumnName="cust_id")	//设置为@OneToMany(mappedBy="customer")

9.5.2 删除

	@Autowiredprivate CustomerDao customerDao;@Test@Transactional@Rollback(false)//设置为不回滚public void testDelete() {customerDao.delete(1l);}

删除操作的说明如下：

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

删除主表数据：

  • 有从表数据

    1、在默认情况下，它会把外键字段置为null，然后删除主表数据。如果在数据库的表 结构上，外键字段有非空约束，默认情况就会报错了。

    2、如果配置了放弃维护关联关系的权利，则不能删除（与外键字段是否允许为null， 没有关系）因为在删除时，它根本不会去更新从表的外键字段了。

    3、如果还想删除，使用级联删除引用

  • 没有从表数据引用：随便删

在实际开发中，级联删除请慎用！(在一对多的情况下)

9.5.3 级联操作

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

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

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

test/ObjectQueryTest.java

package cn.itcast.test;import cn.itcast.dao.CustomerDao;
import cn.itcast.dao.LinkManDao;
import cn.itcast.domain.Customer;
import cn.itcast.domain.LinkMan;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;import java.util.Set;@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class ObjectQueryTest {@Autowiredprivate CustomerDao customerDao;@Autowiredprivate LinkManDao linkManDao;//could not initialize proxy - no Session//测试对象导航查询（查询一个对象的时候，通过此对象查询所有的关联对象）@Test@Transactional // 解决在java代码中的no session问题public void  testQuery1() {//查询id为1的客户Customer customer = customerDao.getOne(1l);//对象导航查询，此客户下的所有联系人Set<LinkMan> linkMans = customer.getLinkMans();for (LinkMan linkMan : linkMans) {System.out.println(linkMan);}}/*** 对象导航查询：*      默认使用的是延迟加载的形式查询的*          调用get方法并不会立即发送查询，而是在使用关联对象的时候才会差和讯*      延迟加载！* 修改配置，将延迟加载改为立即加载*      fetch，需要配置到多表映射关系的注解上**/@Test@Transactional // 解决在java代码中的no session问题public void  testQuery2() {//查询id为1的客户Customer customer = customerDao.findOne(1l);//对象导航查询，此客户下的所有联系人Set<LinkMan> linkMans = customer.getLinkMans();System.out.println(linkMans.size());}/*** 从联系人对象导航查询他的所属客户*      * 默认 ： 立即加载*  延迟加载：**/@Test@Transactional // 解决在java代码中的no session问题public void  testQuery3() {LinkMan linkMan = linkManDao.findOne(2l);//对象导航查询所属的客户Customer customer = linkMan.getCustomer();System.out.println(customer);}}

十、JPA中的多对多

10.1 示例分析

我们采用的示例为用户和角色。
用户：指的是咱们班的每一个同学。
角色：指的是咱们班同学的身份信息。
比如A同学，它是我的学生，其中有个身份就是学生，还是家里的孩子，那么他还有个身份是子女。
同时B同学，它也具有学生和子女的身份。
那么任何一个同学都可能具有多个身份。同时学生这个身份可以被多个同学所具有。
所以我们说，用户和角色之间的关系是多对多。

10.2 表关系建立

多对多的表关系建立靠的是中间表，其中用户表和中间表的关系是一对多，角色表和中间表的关系也是一对多，如下图所示：
在这里插入图片描述

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

代码结构如下：

在这里插入图片描述

一个用户可以具有多个角色，所以在用户实体类中应该包含多个角色的信息，代码如下：

daomain/User.java

package cn.itcast.domain;import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;@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<Role> roles = new HashSet<>();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;}public Set<Role> getRoles() {return roles;}public void setRoles(Set<Role> roles) {this.roles = roles;}
}

一个角色可以赋予多个用户，所以在角色实体类中应该包含多个用户的信息，代码如下：

daomain/Role.java

package cn.itcast.domain;import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;@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<>();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;}public Set<User> getUsers() {return users;}public void setUsers(Set<User> users) {this.users = users;}
}

10.4 映射的注解说明

@ManyToMany

​ 作用：用于映射多对多关系

​ 属性：

​ cascade：配置级联操作。

​ fetch：配置是否采用延迟加载。

​ targetEntity：配置目标的实体类。映射多对多的时候不用写。

@JoinTable

​ 作用：针对中间表的配置

​ 属性：

​ nam：配置中间表的名称

​ joinColumns：中间表的外键字段关联当前实体类所对应表的主键字段

​ inverseJoinColumn：中间表的外键字段关联对方表的主键字段

​

@JoinColumn

​ 作用：用于定义主键字段和外键字段的对应关系。

​ 属性：

​ name：指定外键字段的名称

​ referencedColumnName：指定引用主表的主键字段名称

​ unique：是否唯一。默认值不唯一

​ nullable：是否允许为空。默认值允许。

​ insertable：是否允许插入。默认值允许。

​ updatable：是否允许更新。默认值允许。

​ columnDefinition：列的定义信息。

10.5 多对多的操作

10.5.1 保存

test/ManyToManyTest.java

package cn.itcast.test;import cn.itcast.dao.RoleDao;
import cn.itcast.dao.UserDao;
import cn.itcast.domain.Role;
import cn.itcast.domain.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class ManyToManyTest {@Autowiredprivate UserDao userDao;@Autowiredprivate RoleDao roleDao;/*** 保存一个用户，保存一个角色**  多对多放弃维护权：被动的一方放弃*/@Test@Transactional@Rollback(false)public void  testAdd() {User user = new User();user.setUserName("小李");Role role = new Role();role.setRoleName("java程序员");//配置用户到角色关系，可以对中间表中的数据进行维护     1-1user.getRoles().add(role);//配置角色到用户的关系，可以对中间表的数据进行维护     1-1role.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-1user.getRoles().add(role);//配置角色到用户的关系，可以对中间表的数据进行维护     1-1role.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<SysUser> users = new HashSet<SysUser>(0);

十一 Spring Data JPA中的多表查询

11.1 对象导航查询

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

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

	@Autowiredprivate CustomerDao customerDao;@Test//由于是在java代码中测试，为了解决no session问题，将操作配置到同一个事务中@Transactional public void testFind() {Customer customer = customerDao.findOne(5l);Set<LinkMan> linkMans = customer.getLinkMans();//对象导航查询for(LinkMan linkMan : linkMans) {System.out.println(linkMan);}}

查询一个联系人，获取该联系人的所有客户

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

对象导航查询的问题分析

问题1：我们查询客户时，要不要把联系人查询出来？

分析：如果我们不查的话，在用的时候还要自己写代码，调用方法去查询。如果我们查出来的，不使用时又会白白的浪费了服务器内存。
解决：采用延迟加载的思想。通过配置的方式来设定当我们在需要使用时，发起真正的查询。
配置方式：

	/*** 在客户对象的@OneToMany注解中添加fetch属性* 		FetchType.EAGER	：立即加载* 		FetchType.LAZY	：延迟加载*/@OneToMany(mappedBy="customer",fetch=FetchType.EAGER)private Set<LinkMan> linkMans = new HashSet<>(0);

问题2：我们查询联系人时，要不要把客户查询出来？
分析：例如：查询联系人详情时，肯定会看看该联系人的所属客户。如果我们不查的话，在用的时候还要自己写代码，调用方法去查询。如果我们查出来的话，一个对象不会消耗太多的内存。而且多数情况下我们都是要使用的。
解决： 采用立即加载的思想。通过配置的方式来设定，只要查询从表实体，就把主表实体对象同时查出来
配置方式

	/*** 在联系人对象的@ManyToOne注解中添加fetch属性* 		FetchType.EAGER	：立即加载* 		FetchType.LAZY	：延迟加载*/@ManyToOne(targetEntity=Customer.class,fetch=FetchType.EAGER)@JoinColumn(name="cst_lkm_id",referencedColumnName="cust_id")private Customer customer;

11.2 使用Specification查询

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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/184698.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

ClickHouse主键索引最佳实践

ClickHouse主键索引最佳实践

在本文中&#xff0c;我们将深入研究ClickHouse索引。我们将对此进行详细说明和讨论&#xff1a; ClickHouse的索引与传统的关系数据库有何不同ClickHouse是怎样构建和使用主键稀疏索引的ClickHouse索引的最佳实践 您可以选择在自己的机器上执行本文给出的所有Clickhouse SQL…
阅读更多...
宝马——使用人工智能制造和驾驶汽车

宝马——使用人工智能制造和驾驶汽车

德国汽车制造商宝马(BMW)每年在全球制造和销售250万台汽车&#xff0c;其品牌包括宝马、MINI和劳斯莱斯。 宝马汽车以其卓越的性能和对新技术的应用而著名&#xff0c;它是道路上最精致的汽车之一&#xff0c;并且和其竞争对手戴姆勒(Daimler)一样&#xff0c;在将自动驾驶汽车…
阅读更多...
​软考-高级-信息系统项目管理师教程 第四版【第23章-组织通用管理-思维导图】​

​软考-高级-信息系统项目管理师教程 第四版【第23章-组织通用管理-思维导图】​

软考-高级-信息系统项目管理师教程 第四版【第23章-组织通用管理-思维导图】 课本里章节里所有蓝色字体的思维导图
阅读更多...
案例 | 3D可视化工具HOOPS助力SolidWorks edrawings成功引入AR/VR技术

案例 | 3D可视化工具HOOPS助力SolidWorks edrawings成功引入AR/VR技术

HOOPS中文网慧都科技是HOOPS全套产品中国地区指定授权经销商&#xff0c;提供3D软件开发工具HOOPS售卖、试用、中文试用指导服务、中文技术支持。http://techsoft3d.evget.com/达索系统SolidWorks面临的挑战 达索系统SolidWorks公司开发和销售三维CAD设计软件、分析软件和产品…
阅读更多...
【机器学习2】模型评估

【机器学习2】模型评估

模型评估主要分为离线评估和在线评估两个阶段。 针对分类、 排序、 回归、序列预测等不同类型的机器学习问题&#xff0c; 评估指标的选择也有所不同。 1 评估指标 1.1准确率 准确率是指分类正确的样本占总样本个数的比例 但是准确率存在明显的问题&#xff0c;比如当负样本…
阅读更多...
class类默认导出，header字段在请求中的位置

class类默认导出，header字段在请求中的位置

这是封装好的&#xff0c;没封装的如下 如果没有用uni.post那么就是如下的结构 let header {Content-Type: application/x-www-form-urlencoded,tenant: MDAwMA, } request({url:/sal/formula/validFormula,method:post,data:{},header })
阅读更多...
用循环结构程序自动化计算——计数循环

用循环结构程序自动化计算——计数循环

用循环结构程序自动化计算——计数循环 低阶目标&#xff1a; 利用for循环结构来完成已知次数的自动化处理&#xff0c;掌握计数循环结构应用方法 高阶目标&#xff1a; 学会利用for循环解决生活中的实际问题 用循环结构程序自动化计算——计数循环 用循环结构程序自动化计算…
阅读更多...
ElasticSearch与Lucene是什么关系？Lucene又是什么？

ElasticSearch与Lucene是什么关系？Lucene又是什么？

一. ElasticSearch 与 Lucene 的关系 Elasticsearch&#xff08;ES&#xff09;和Apache Lucene之间有密切的关系&#xff0c;可以总结如下&#xff1a; Elasticsearch构建于Lucene之上&#xff1a;Elasticsearch实际上是一个分布式的、实时的搜索和分析引擎&#xff0c;它构建…
阅读更多...
案例 - 拖拽上传文件,生成缩略图

案例 - 拖拽上传文件,生成缩略图

直接看效果 实现代码 <!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8"><meta name"viewport" content"widthdevice-width, initial-scale1.0"><title>拖拽上传文件</title>&l…
阅读更多...
Ecal基于wifi下跨机通讯

Ecal基于wifi下跨机通讯

4. Network configuration — Eclipse eCAL™ UDP无法通信&#xff0c;改成TCP配置可以通信&#xff0c;但是没有重连。 Ecal版本&#xff1a;5.12稳定 WIFI连接eCAL Cloud Configuration Not Sending/Receiving Data Correctly Issue #650 eclipse-ecal/ecal GitHub 一开始…
阅读更多...
Spring笔记(四)(黑马)(web层解决方案-SpringMVC)

Spring笔记(四)(黑马)(web层解决方案-SpringMVC)

01、Spring MVC 简介 1.1 SpringMVC概述 SpringMVC是一个基于Spring开发的MVC轻量级框架&#xff0c;Spring3.0后发布的组件&#xff0c;SpringMVC和Spring可以无 缝整合&#xff0c;使用DispatcherServlet作为前端控制器&#xff0c;且内部提供了处理器映射器、处理器适配器…
阅读更多...
RflySim | 滤波器设计实验二

RflySim | 滤波器设计实验二

本讲是关于无人机滤波器&#xff0c;其中包括无人机滤波器简介、测量原理、线性互补滤波器设计、线性互补滤波器参数分析、卡尔曼滤波器设计等。 滤波器设计实验2 卡尔曼滤波器是一种递推线性最小方差估计算法&#xff0c;它的最优估计需满足以下三个条件&#xff1a; 1&#…
阅读更多...
LCD充气桨板冲浪板充气泵方案——pcba/芯片方案

LCD充气桨板冲浪板充气泵方案——pcba/芯片方案

LCD充气桨板冲浪板充气泵规格书 一、主要功能介绍&#xff1a; 1、开机默认显示上次设定气压值&#xff0c; 2、测量范围&#xff1a;0~22psi、测量精度&#xff1a;0.5PSI 3、分辨率&#xff1a;0.01 PSI 4、温度范围&#xff1a;-10至50度摄氏 5、5个按键&#xff1a;PSI键、…
阅读更多...
python自动化测试（十一）：写入、读取、修改Excel表格的数据

python自动化测试（十一）：写入、读取、修改Excel表格的数据

目录 一、写入 1.1 安装 xlwt 1.2 增加sheet页 1.2.1 新建sheet页 1.2.2 sheet页写入数据 1.2.3 excel保存 1.2.4 完整代码 1.2.5 同一坐标&#xff0c;重复写入 二、读取 2.1 安装读取模块 2.2 读取sheet页 2.2.1 序号读取shee页 2.2.2 通过sheet页的名称读取she…
阅读更多...
快来看看如何拿下7+干湿结合生信思路。赶紧拿起笔记本

快来看看如何拿下7+干湿结合生信思路。赶紧拿起笔记本

今天给同学们分享一篇生信文章“CENPF/CDK1 signaling pathway enhances the progression of adrenocortical carcinoma by regulating the G2/M-phase cell cycle”&#xff0c;这篇文章发表在J Transl Med期刊上&#xff0c;影响因子为7.4。 结果解读&#xff1a; CENPF在AC…
阅读更多...
易云维®工厂能耗管理平台系统方案，保证运营质量，推动广东制造企业节能减排

易云维®工厂能耗管理平台系统方案，保证运营质量，推动广东制造企业节能减排

我国《关于完整准确全面贯彻新发展理念推进碳达峰碳中和工作的实施意见》出台&#xff0c;提出了推进碳达峰碳中和工作的总体目标。到2025年&#xff0c;广东具备条件的地区、行业和企业率先实现碳达峰&#xff0c;为全省实现碳达峰、碳中和奠定坚实基础&#xff1b;2030年前实…
阅读更多...
Java算法（二）：数组元素求和（元素个位和十位不能是 7 ，且只能是偶数）

Java算法（二）：数组元素求和（元素个位和十位不能是 7 ，且只能是偶数）

java算法&#xff08;二&#xff09; 需求&#xff1a; ​ 有这样一个数组&#xff1a; 元素是&#xff1a;{68, 27, 95, 88, 171, 996, 51, 210} ​ 求出该数组中满足要求的元素和 ​ 要求是&#xff1a; 求和的元素各位和十位都不能是 7 &#xff0c;并且只能是偶数 packa…
阅读更多...
Android 深色模式切换适配

Android 深色模式切换适配

在Android11上测试 1&#xff0c;把需要适配的资源文件复制一份后缀加上-night&#xff0c;里面就放置变主题后的资源 2&#xff0c;两个主题一个白&#xff0c;一个黑&#xff0c;分别放置在对应的valuse-styles.xml中 <style name"Theme.LaserMachPor" parent&…
阅读更多...
【delphi】中 TNetHTTPClient 注意事项

【delphi】中 TNetHTTPClient 注意事项

一、TNetHTTPClient 是什么&#xff1f; 用于管理 HTTP 客户端的组件。相当于indy中的TidHTTP控件&#xff0c;是实现HTTP请求的客户端控件。 二、TNetHTTPClient 需要注意什么&#xff1f; 需要注意的是几个Timeout&#xff0c;因为我们使用TNetHTTPClient控件的时候&#x…
阅读更多...
046_第三代软件开发-虚拟屏幕键盘

046_第三代软件开发-虚拟屏幕键盘

第三代软件开发-虚拟屏幕键盘 文章目录 第三代软件开发-虚拟屏幕键盘项目介绍虚拟屏幕键盘 关键字&#xff1a; Qt、 Qml、 虚拟键盘、 qtvirtualkeyboard、 自定义 项目介绍 欢迎来到我们的 QML & C 项目&#xff01;这个项目结合了 QML&#xff08;Qt Meta-Object L…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023