【Spring Data JPA】08 多表关系 Part1 一对多关系操作

表关系概述：

1、一 对应 一

一对夫妻，一个男人只能有一个老婆，一个女人只能有一个老公，即这种对应关系

2、一 对应 多 【多对一】

一个年级具有多个班级，一个班级具有对应的所属年级，即这种上下层级关系或者其他类似的

3、多 对应 多

授课老师和所授课程 一个授课老师可以教授多门课程，一个课程也可以被多个老师教授。即多重关系

数据库表设计的实现：

一对一只需要一个关联键即可

一对多，需要建立主表（一）从表（多）关系，从表设置外键来检索主表信息

多对多，对应的关系无法用外键实现，所以需要建立关联表，用来存储关联关系映射

实体类设计的实现：

一对一，对象附属，作为属性存在【包含】

一对多，对象仅表示一个记录，所以更改为一个对象的集合容器作为属性存在，或者使用继承实现

多对多

测试环境搭建：

customer.sql

/*创建客户表*/
CREATE TABLE cst_customer (
  cust_id bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
  cust_name varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
  cust_source varchar(32) DEFAULT NULL COMMENT '客户信息来源',
  cust_industry varchar(32) DEFAULT NULL COMMENT '客户所属行业',
  cust_level varchar(32) DEFAULT NULL COMMENT '客户级别',
  cust_address varchar(128) DEFAULT NULL COMMENT '客户联系地址',
  cust_phone varchar(64) DEFAULT NULL COMMENT '客户联系电话',
  PRIMARY KEY (`cust_id`)
) ENGINE=InnoDB AUTO_INCREMENT=94 DEFAULT CHARSET=utf8;

/*创建联系人表*/
CREATE TABLE cst_linkman (
  lkm_id bigint(32) NOT NULL AUTO_INCREMENT COMMENT '联系人编号(主键)',
  lkm_name varchar(16) DEFAULT NULL COMMENT '联系人姓名',
  lkm_gender char(1) DEFAULT NULL COMMENT '联系人性别',
  lkm_phone varchar(16) DEFAULT NULL COMMENT '联系人办公电话',
  lkm_mobile varchar(16) DEFAULT NULL COMMENT '联系人手机',
  lkm_email varchar(64) DEFAULT NULL COMMENT '联系人邮箱',
  lkm_position varchar(16) DEFAULT NULL COMMENT '联系人职位',
  lkm_memo varchar(512) DEFAULT NULL COMMENT '联系人备注',
  lkm_cust_id bigint(32) NOT NULL COMMENT '客户id(外键)',
  PRIMARY KEY (`lkm_id`),
  KEY `FK_cst_linkman_lkm_cust_id` (`lkm_cust_id`),
  CONSTRAINT `FK_cst_linkman_lkm_cust_id` FOREIGN KEY (`lkm_cust_id`) REFERENCES `cst_customer` (`cust_id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

客户：

package cn.echo42.domain;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.persistence.*;
import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

/**
 * @author DaiZhiZhou
 * @file Spring-Data-JPA
 * @create 2020-08-01 9:48
 */

@Data
@AllArgsConstructor
@NoArgsConstructor
@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);
}

联系人：

package cn.echo42.domain;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

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

/**
 * @author DaiZhiZhou
 * @file Spring-Data-JPA
 * @create 2020-08-01 9:49
 */

@Data
@AllArgsConstructor
@NoArgsConstructor
@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;//用它的主键，对应联系人表中的外键
}

编写对应的Dao接口：

package cn.echo42.repository;

import cn.echo42.domain.Customer;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

/**
 * @author DaiZhiZhou
 * @file Spring-Data-JPA
 * @create 2020-08-01 9:54
 */
public interface CustomerRepository extends JpaRepository<Customer, Integer> , JpaSpecificationExecutor<Customer> {
}
---------------------------------------------------------------------------------------------------------------------------
package cn.echo42.repository;

import cn.echo42.domain.LinkMan;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

/**
 * @author DaiZhiZhou
 * @file Spring-Data-JPA
 * @create 2020-08-01 9:54
 */
public interface LinkManRepository extends JpaRepository<LinkMan, Integer>, JpaSpecificationExecutor<LinkMan> {
}

注解配置Jpa的配置信息

自动创建数据库表设置：create每次执行创建数据库表，update没有表才会创建

多表关系插入：

创建测试类：

import cn.echo42.config.ApplicationConfiguration;
import cn.echo42.domain.Customer;
import cn.echo42.domain.LinkMan;
import cn.echo42.repository.CustomerRepository;
import cn.echo42.repository.LinkManRepository;
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;

/**
 * @author DaiZhiZhou
 * @file Spring-Data-JPA
 * @create 2020-08-01 10:06
 */

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = ApplicationConfiguration.class)
public class MTRQ_Test {

    @Autowired
    CustomerRepository customerRepository;
    @Autowired
    LinkManRepository linkManRepository;

    @Test
    @Transactional
    @Rollback(false) // 设置不自动回滚
    public void addExecute(){
        // 创建一个客户 & 联系人
        Customer customer = new Customer();
        customer.setCustName("百度");

        LinkMan linkMan = new LinkMan();
        linkMan.setLkmName("小李");

        customerRepository.save(customer);
        linkManRepository.save(linkMan);
    }

}

显示结果：

[org.hibernate.SQL]-alter table cst_linkman drop foreign key FKh9yp1nql5227xxcopuxqx2e7q
[org.hibernate.SQL]-drop table if exists cst_customer
[org.hibernate.SQL]-drop table if exists cst_linkman
[org.hibernate.SQL]-drop table if exists sys_user
[org.hibernate.SQL]-create table cst_customer (cust_id bigint not null auto_increment, cust_address varchar(255), cust_industry varchar(255), cust_level varchar(255), cust_name varchar(255), cust_phone varchar(255), cust_source varchar(255), primary key (cust_id))
[org.hibernate.SQL]-create table cst_linkman (lkm_id bigint not null auto_increment, lkm_email varchar(255), lkm_gender varchar(255), lkm_memo varchar(255), lkm_mobile varchar(255), lkm_name varchar(255), lkm_phone varchar(255), lkm_position varchar(255), lkm_cust_id bigint, primary key (lkm_id))
[org.hibernate.SQL]-create table sys_user (user_id integer not null auto_increment, user_is_del integer, user_name varchar(255), user_password varchar(255), user_status integer, primary key (user_id))
[org.hibernate.SQL]-alter table cst_linkman add constraint FKh9yp1nql5227xxcopuxqx2e7q foreign key (lkm_cust_id) references cst_customer (cust_id)

数据库查看：

可以看到联系人的外键这里没有百度，两个记录不具备任何联系，是相互独立的存在

要建立关系，我们则需要在联系人的集合中增加对象，表现出我们的关联关系：

    @Test
    @Transactional
    @Rollback(false) // 设置不自动回滚
    public void addExecute(){
        // 创建一个客户 & 联系人
        Customer customer = new Customer();
        customer.setCustName("百度");

        LinkMan linkMan = new LinkMan();
        linkMan.setLkmName("小李");
        
        // 配置多表关系
        customer.getLinkmans().add(linkMan);

        customerRepository.save(customer);
        linkManRepository.save(linkMan);
    }

再次执行的结果：

可以看到已经成功绑定到了

从客户表的角度上观察：

发送了两条插入语句，

一条插入记录

一条更新外键

我们配置了客户到联系人的关系，客户可以对外键进行维护

我们也可以换过来，从联系人的角度上关联客户：

    @Test
    @Transactional
    @Rollback(false) // 设置不自动回滚
    public void addExecute2(){
        // 创建一个客户 & 联系人
        Customer customer = new Customer();
        customer.setCustName("百度");

        LinkMan linkMan = new LinkMan();
        linkMan.setLkmName("小李");

        // 在联系人的属性中设置客户，以关联
        linkMan.setCustomer(customer);

        customerRepository.save(customer);
        linkManRepository.save(linkMan);
    }

结果一样

但是如果同时绑定设置就会出错了：

    @Test
    @Transactional
    @Rollback(false) // 设置不自动回滚
    public void addExecute3(){
        // 创建一个客户 & 联系人
        Customer customer = new Customer();
        customer.setCustName("百度");

        LinkMan linkMan = new LinkMan();
        linkMan.setLkmName("小李");

        linkMan.setCustomer(customer);
        customer.getLinkmans().add(linkMan);

        customerRepository.save(customer);
        linkManRepository.save(linkMan);
    }

双方彼此的对象在不断相互引用：

解决方案是任意的一方放弃主键的维护即可：

原先联系人类的维护关系：

如果放弃，就需要这样设置：

But it not work .... 不晓得为什么，难道又有新的策略了？

【发现是使用了Lombok原因，这里也只要记住一点，放弃主键维护注意下Lombok辅助的问题】

级联操作：

ALL 所有操作

MERGE 更新
PERSIST 持久化 -> 保存
REMOVE  移除

取消之前设置的创建数据库表：

测试级联删除：

    @Test
    @Transactional
    @Rollback(false) // 设置不自动回滚
    public void addExecute4(){
        Specification<Customer> customerSpecification = (Specification<Customer>) (root, criteriaQuery, criteriaBuilder) -> {
            // 获取比较的属性
            Path<Object> cust_id = root.get("custId");
            // 模糊要求指定参数类型
            return criteriaBuilder.equal(cust_id, 1);
        };
        Optional<Customer> customerOptional = customerRepository.findOne(customerSpecification);

        Customer customer = customerOptional.get();

        customerRepository.delete(customer);
    }