SpringData JPA的一对多操作

Myth丶恋晨 2023-07-01 05:26 12阅读 0赞

在实际开发中，我们数据库的表会有相互的关联关系，在操作表的时候就有可能涉及到多张表的操作。而在这种实现了ORM思想的框架中(比如JPA)，可以让我妈通过操作实体类就实现对数据库表的操作。

# 思路 #

*  第一步：明确两张表之间的关系。
 *  第二步：在数据库中实现两张表的关系（外键（从表上添加外键） | 中间表）
 *  第三步：在实体类中描述出两个实体的关系（包含关系）
 *  第四步：配置出实体类和数据库表的关系映射（重点）

# 实例 #

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

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

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

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

## 明确表关系 ##

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

什么是外键？

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

一对多数据库关系的建立，如下图所示  
![在这里插入图片描述][20200119133323294.png]

/*创建客户表*/
    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;

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

1、创建一个不使用maven的模块  
2、引入pom坐标

<properties>
            <spring.version>4.2.4.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>8.0.15</mysql.version>
        </properties>
    
        <dependencies>
            
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.9</version>
                <scope>test</scope>
            </dependency>
    
            
            <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>
    
            <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>
    
            
    
            
            <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>
            
    
            
            <dependency>
                <groupId>c3p0</groupId>
                <artifactId>c3p0</artifactId>
                <version>${c3p0.version}</version>
            </dependency>
            
    
            
            <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>
            
    
    
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>
    
            <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>
    
            
            <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>
            
        </dependencies>

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 + "]";
    	}
    }

4、dao层

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

public interface LinkManDao  extends JpaRepository<LinkMan, Long>, JpaSpecificationExecutor<LinkMan> {
        
    }

5、编写配置文件：src\\main\\resources\\applicationContext.xml

<?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:aop="http://www.springframework.org/schema/aop"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:tx="http://www.springframework.org/schema/tx"
           xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:task="http://www.springframework.org/schema/task"
           xsi:schemaLocation="
    		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.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/tx http://www.springframework.org/schema/tx/spring-tx.xsd
    		http://www.springframework.org/schema/data/jpa
    		http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">
    
        
    
        
        <bean id="entityManagerFactoty" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
            <property name="dataSource" ref="dataSource" />
            
            <property name="packagesToScan" value="com.oceanstar.domain" />
            
            <property name="persistenceProvider">
                <bean class="org.hibernate.jpa.HibernatePersistenceProvider"/>
            </property>
    
            
            <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>
    
            
            <property name="jpaProperties" >
                <props>
                    <prop key="hibernate.hbm2ddl.auto">create</prop>
                </props>
            </property>
    
        </bean>
    
        
        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
            <property name="user" value="root"></property>
            <property name="password" value="123456"></property>
            <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test?serverTimezone=UTC" ></property>
            <property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
        </bean>
    
        
        <jpa:repositories base-package="com.oceanstar.dao" transaction-manager-ref="transactionManager"
                       entity-manager-factory-ref="entityManagerFactoty" ></jpa:repositories>
    
        
        <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
            <property name="entityManagerFactory" ref="entityManagerFactoty"></property>
        </bean>
    
        
        <tx:advice id="txAdvice" transaction-manager="transactionManager">
            <tx:attributes>
                <tx:method name="save*" propagation="REQUIRED"/>
                <tx:method name="insert*" propagation="REQUIRED"/>
                <tx:method name="update*" propagation="REQUIRED"/>
                <tx:method name="delete*" propagation="REQUIRED"/>
                <tx:method name="get*" read-only="true"/>
                <tx:method name="find*" read-only="true"/>
                <tx:method name="*" propagation="REQUIRED"/>
            </tx:attributes>
        </tx:advice>
    
        
        <aop:config>
            <aop:pointcut id="pointcut" expression="execution(* com.oceanstar.service.*.*(..))" />
            <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut" />
        </aop:config>
    
    
        
    
        
        <context:component-scan base-package="com.oceanstar" ></context:component-scan>
    </beans>

## 映射的注解说明 ##

### @OneToMany ###

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

### @ManyToOne ###

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

### @JoinColumn ###

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

## 3.5一对多的操作 ##

### 添加 ###

@RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(locations="classpath:applicationContext.xml")
    public class OneToManyTest {
        
    
        @Autowired
        private CustomerDao customerDao;
    
        @Autowired
        private LinkManDao linkManDao;
    
    
        /**
         * 保存操作
         * 需求:
         * 	保存一个客户和一个联系人
         * 要求：
         * 	创建一个客户对象和一个联系人对象
         *  建立客户和联系人之间关联关系（双向一对多的关联关系）
         *  先保存客户，再保存联系人
         * 问题：
         *		当我们建立了双向的关联关系之后，先保存主表，再保存从表时：
         *		会产生2条insert和1条update.
         * 		而实际开发中我们只需要2条insert。
         *
         */
        @Test
        @Transactional  //开启事务
        @Rollback(false)//设置为不回滚
        public void testAdd() {
        
            Customer c = new Customer();
            c.setCustName("TBD云集中心");
            c.setCustLevel("VIP客户");
            c.setCustSource("网络");
            c.setCustIndustry("商业办公");
            c.setCustAddress("昌平区北七家镇");
            c.setCustPhone("010-84389340");
    
            LinkMan l = new LinkMan();
            l.setLkmName("TBD联系人");
            l.setLkmGender("male");
            l.setLkmMobile("13811111111");
            l.setLkmPhone("010-34785348");
            l.setLkmEmail("98354834@qq.com");
            l.setLkmPosition("老师");
            l.setLkmMemo("还行吧");
    
    
            c.getLinkmans().add(l);
            l.setCustomer(c);
            customerDao.save(c);
            linkManDao.save(l);
        }
    }

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

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

## 删除数据 ##

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

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

**删除主表数据：**

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

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

## 级联操作 ##

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

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

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

/**
         * 级联添加：保存一个客户的同时，保存客户的所有联系人
         *      需要在操作主体的实体类上，配置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);
        }

[20200119133323294.png]: https://img-blog.csdnimg.cn/20200119133323294.png