Hibernate学习笔记7（一对多关系的配置与操作）

怼烎@ 2021-11-23 11:31 306阅读 0赞

# **数据库表与表之间的关系** #

这个在mysql中有写过，这里再写一遍https://blog.csdn.net/qq\_40817827/article/details/90637303

*  一对多关系
    
     *  什么样关系属于一对多？  
        一个部门对应多个员工，一个员工只能属于某一个部门。  
        一个客户对应多个联系人，一个联系人只能属于某一个客户。
     *  一对多的建表原则：  
        ![在这里插入图片描述][20190726173538199.png]
 *  多对多关系
    
     *  什么样关系属于多对多？  
        一个学生可以选择多门课程，一门课程也可以被多个学生选择。  
        一个用户可以选择多个角色，一个角色也可以被多个用户选择。
     *  多对多的建表原则：
     *  ![在这里插入图片描述][20190726173648770.png]
 *  一对一关系
    
     *  什么样关系属于一对一？  
        一个公司只能有一个注册地址，一个注册地址只能被一个公司注册。
     *  一对一的建表原则：  
        ![在这里插入图片描述][20190726173807538.png]

# **Hibernate一对多的关系配置** #

**1.创建项目，引入jar包  
2.创建数据库和表**

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_phone` varchar(64) DEFAULT NULL COMMENT '固定电话',
      `cust_mobile` varchar(16) DEFAULT NULL COMMENT '移动电话',
      PRIMARY KEY (`cust_id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
    
    CREATE TABLE `cst_linkman` (
      `lkm_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '联系人编号(主键)',
      `lkm_name` varchar(16) DEFAULT NULL COMMENT '联系人姓名',
      `lkm_cust_id` bigint(32) DEFAULT NULL COMMENT '客户id',
      `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_qq` varchar(16) DEFAULT NULL COMMENT '联系人qq',
      `lkm_position` varchar(16) DEFAULT NULL COMMENT '联系人职位',
      `lkm_memo` varchar(512) DEFAULT NULL COMMENT '联系人备注',
      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=1 DEFAULT CHARSET=utf8;

![在这里插入图片描述][2019072617420733.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwODE3ODI3_size_16_color_FFFFFF_t_70]  
**3.创建实体**

一的一方实体，放置多的一方集合

public class Customer {
    	private Long cust_id;
    	private String cust_name;
    	private String cust_source;
    	private String cust_industry;
    	private String cust_level;
    	private String cust_phone;
    	private String cust_mobile;
    	//通过ORM方式表示；一个客户对应多个联系人
    	//放置的多的一方的集合，Hibernate默认使用Set集合
    	private Set<LinkMan> LinkMans = new HashSet<LinkMan>();

多的一方实体，放置一的一方对象

public class LinkMan {
    	private Long lkm_id;
    	private String lkm_name;
    	private String lkm_cust_id;
    	private String lkm_gender;
    	private String lkm_phone;
    	private String lkm_mobile;
    	private String lkm_email;
    	private String lkm_qq;
    	private String lkm_position;
    	private String lkm_memo;
    	//通过ORM方式表示：一个联系人只能属于某一个客户
    	//放置的是一的一方的对象
    	private Customer customer;

**4创建映射文件**

*  **多的一方的映射的创建**

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE hibernate-mapping PUBLIC 
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
        <hibernate-mapping>
        <class name="domain.LinkMan"  table="cst_linkman">
        
        <id name="lkm_id" column="lkm_id" >
        
        <generator class="native"/>
        </id>
        
          <property name="lkm_name"  />
    		<property name="lkm_gender"  />
    		<property name="lkm_phone" />
    		<property name="lkm_mobile" />
    		<property name="lkm_email" />
    		<property name="lkm_qq" /> 
            <property name="lkm_position" /> 
            <property name="lkm_memo" /> 
       		
       		
       		 <many-to-one name="customer" class="domain.Customer" column="lkm_cust_id"/>
        </class>
        </hibernate-mapping>

*  **一的一方的映射的创建**

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE hibernate-mapping PUBLIC 
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
    <hibernate-mapping>
    	
    <class name="domain.Customer.java" table="cst_customer">
    
    <id name="cust_id" column="cust_id" >
    
    			<generator class="native"/>
    </id>
    
    		<property name="cust_name" column="cust_name"  />
    		<property name="cust_source" column="cust_source" />
    		<property name="cust_industry" column="cust_industry"/>
    		<property name="cust_level" column="cust_level"/>
    		<property name="cust_phone" column="cust_phone"/>
    		<property name="cust_mobile" column="cust_mobile"/>
    		 
    		 
    		 <set name="linkMans">
    		 
    		 <key column="lkm_cust_id"/>
    		 
    		 <one-to-many class="domain.LinkMan"/>
    		 </set>
    </class>
    </hibernate-mapping>

**5.创建核心配置  
Hibernate.cfg.xml**

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE hibernate-configuration PUBLIC
    	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    	"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
    	<hibernate-configuration> 
    		<session-factory>
    	 		
    	 		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
    	 		<property name="hibernate.connection.url">jdbc:mysql:///hibernateday02</property>
    		    <property name="hibernate.connection.username">root</property>
    		    <property name="hibernate.connection.password">root</property>
    		
    		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
    		
    		
    		<property name="hibernate.show_sql">true</property>
    		
    		<property name="hibernate.format_sql">true</property>
            
    		<property name="hibernate.hbm2ddl.auto">update</property>
    		
    		
    		
    		<property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
    		
    		<property name="c3p0.min_size">5</property>
    		
    		<property name="c3p0.max_size">20</property>
    		
    		<property name="c3p0.timeout">120</property>
    		 
    		<property name="c3p0.idle_test_period">3000</property>
    		
    		<property name = "hibernate.connection.isolation">4</property>
    		
    		<property name="hibernate.current_session_context_class">thread</property>
    		
    		<mapping resource="domain/Customer.hbm.xml"/>
    		<mapping resource="domain/LinkMan.hbm.xml"/>
    		</session-factory>
    	</hibernate-configuration>

**6.引入工具类**

package hibernateUtils;
    
    import org.hibernate.Session;
    import org.hibernate.SessionFactory;
    import org.hibernate.cfg.Configuration;
    
    /*
     * 
     * Hibernate工具类
     * 
     * 
     */
    
    public class HibernateUtils {
    	public static final Configuration cfg;
    	public static final SessionFactory sf;
    	
    	static {
    		cfg=new Configuration().configure();
    		sf=cfg.buildSessionFactory();
    	}
    	
    	public static Session openSession() {
    		return sf.openSession();
    	}
    	public static Session getCurrentSession() {
    		return sf.getCurrentSession();
    		
    	}
    	
    	
    }

**7.测试类**

package demo1;
    
    import org.hibernate.Session;
    import org.hibernate.Transaction;
    import org.junit.Test;
    
    import domain.Customer;
    import domain.LinkMan;
    import hibernateUtils.HibernateUtils;
    
    /**
     * 
     * 一对多的测试类
     * 
     * 
     * @author ASUS
     *
     */
    public class HibernateDemo1 {
    @Test
    //保存两个客户和三个联系人
    public void demo1() {
    	Session session = HibernateUtils.getCurrentSession();
    	Transaction tx = session.beginTransaction();
    	
    	//创建两个客户
    	Customer customer1 = new Customer();
    	customer1.setCust_name("张二");
    	Customer customer2 = new Customer();
    	customer2.setCust_name("张三");
    	
    	//创建三个联系人
    	LinkMan linkman1 = new LinkMan();
    	linkman1.setLkm_name("孙一");
    	LinkMan linkman2 = new LinkMan();
    	linkman2.setLkm_name("孙二");
    	LinkMan linkman3 = new LinkMan();
    	linkman3.setLkm_name("孙三");
    	
    	//设置关系
    	linkman1.setCustomer(customer1);
    	linkman2.setCustomer(customer1);
    	linkman3.setCustomer(customer2);
    	
    	//保存数据
    	session.save(customer1);
    	session.save(customer2);
    	session.save(linkman1);
    	session.save(linkman2);
    	session.save(linkman3);
    	
    	tx.commit();
    }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwODE3ODI3_size_16_color_FFFFFF_t_70 1]  
可以看见数据已经插入数据库中

# **Hibernate的一对多相关操作** #

**1. 一对多关系只保存一边是否可以**

@Test
    public void demo2() {
    	Session session = HibernateUtils.getCurrentSession();
    	Transaction tx = session.beginTransaction();
    	
    	Customer customer = new Customer();
    	customer.setCust_name("如花");
    	
    	LinkMan linkMan = new LinkMan();
    	linkMan.setLkm_name("岁月");
    	customer.getLinkMans().add(linkMan);
    	linkMan.setCustomer(customer);
    	//只保存一边是否可以，不可以，报一个瞬时对象异常：持久态对象关联了一个瞬时态对象
    	//session.save(customer);
    	session.save(linkMan);
    	
    	tx.commit();
    }

![在这里插入图片描述][20190801091719203.png]  
瞬时对象异常  
customer本来是瞬时的，sava()后变持久了，但联系人还是瞬时的，然后客户与之做了关联，现在就不能保存客户了

**2.一对多的级联操作**

*  什么叫级联操作  
    级联指的是，操作一个对象的时候，是否会操作其他关联对象
 *  级联是有方向性的  
    操作一的一方的时候，是否操作到多的一方  
    操作多的一方的时候，是否操作到一的一方

**3.级联保存或更新**

*  保存客户级联联系人

@Test
    /*
     * 级联保存或更新操作
     * 保存客户级联联系人，操作主体是客户对象，需要在Customer.hbm.xml中进行配置
     *  <set name="linkMans" cascade="save-update">
     * 
     */
    public void demo3() {
    	Session session = HibernateUtils.getCurrentSession();
    	Transaction tx = session.beginTransaction();
    	
    	Customer customer = new Customer();
    	customer.setCust_name("如花");
    	
    	LinkMan linkMan = new LinkMan();
    	linkMan.setLkm_name("岁月");
    	customer.getLinkMans().add(linkMan);
    	linkMan.setCustomer(customer);
    	//只保存一边是否可以，不可以，报一个瞬时对象异常：持久态对象关联了一个瞬时态对象
    	session.save(customer);
    	//session.save(linkMan);
    	
    	tx.commit();
    }

*  保存联系人级联客户

/*
     * 级联保存或更新操作
     * 保存联系人级联客户，操作的主体是联系人对象，需要在LinkMan.hbm.xml中进行配置
     *  <many-to-one name="customer" cascade="save-update" class="domain.Customer" column="lkm_cust_id"/>
     */
    @Test
    public void demo4() {
    	Session session = HibernateUtils.getCurrentSession();
    	Transaction tx = session.beginTransaction();
    	
    	Customer customer = new Customer();
    	customer.setCust_name("如花2");
    	
    	LinkMan linkMan = new LinkMan();
    	linkMan.setLkm_name("岁月2");
    	customer.getLinkMans().add(linkMan);
    	linkMan.setCustomer(customer);
    	//只保存一边是否可以，不可以，报一个瞬时对象异常：持久态对象关联了一个瞬时态对象
    	//session.save(customer);
    	session.save(linkMan);
    	
    	tx.commit();
    }

![在这里插入图片描述][20190801094200153.png]  
![在这里插入图片描述][20190801094212385.png]  
4.测试对象导航

/*
     
     * 测试对象的导航
     * 前提：一对多的双方都设置cascade="save-uodate"
     * 
     */
    @Test
    public void demo5() {
    	Session session = HibernateUtils.getCurrentSession();
    	Transaction tx = session.beginTransaction();
    	
    	Customer customer = new Customer();
    	customer.setCust_name("如花3");
    	
    	LinkMan linkMan1 = new LinkMan();
    	linkMan1.setLkm_name("岁月3");
    	LinkMan linkMan2 = new LinkMan();
    	linkMan2.setLkm_name("岁月4");
    	LinkMan linkMan3 = new LinkMan();
    	linkMan3.setLkm_name("岁月5");
    	
    	linkMan1.setCustomer(customer);
    	customer.getLinkMans().add(linkMan2);
    	customer.getLinkMans().add(linkMan3);
    	
    	//双方都设置了cascade
    	//session.save(linkMan1);//发送了几条insert语句 4条
    	//首先保存联系人1，进入数据库，一条，联系人1又关联客户，客户进去，两条，客户又带进去2.3.一共4条
    	session.save(customer);//发送几条 3条 客户和所关联的两个联系人
    	session.save(linkMan2);//发送几条数据 1条
    	
    	tx.commit();
    }

插入4条，后面同理  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwODE3ODI3_size_16_color_FFFFFF_t_70 2]  
**5.级联删除**  
**删除一边的时候，同时将另一方的数据也一并删除。**

*  删除客户级联删除联系人

@Test
    /*
     * 
     * 级联删除
     * 删除客户级联删除联系人，删除的主题是客户，需要在Customer.hbm.xml中配置
     * 
     * 
     * 
     * 删除客户，级联删除联系人，之前删除有联系的，jdbc是不能删除的，但hibernate可以
     *  <set name="linkMans" cascade="save-update,delete">
     */
    public void demo6() {
    	Session session = HibernateUtils.getCurrentSession();
    	Transaction tx = session.beginTransaction();
    	
    	//没有设置级联删除，默认情况,修改联系人的外键，删除客户
    	//Customer customer = session.get(Customer.class,1l);
    	//session.delete(customer);
    	
    	//删除客户，同时删除联系人
    	Customer customer = session.get(Customer.class,1l);
    	session.delete(customer);
    	
    	tx.commit();
    
    }

*  删除联系人级联删除客户（基本不用）

@Test
    /*
     * 级联删除：删除联系人级联删除客户，删除的主体是联系人，需要在LinkMan.hbm.xml中配置
     * many-to-one name="customer" cascade="delete" 
     * 
     * 
     */
    public void demo7(){
    	
    	Session session = HibernateUtils.getCurrentSession();
    	Transaction tx = session.beginTransaction();
    	
    	//删除客户，同时删除联系人
    	LinkMan linkman = session.get(LinkMan.class, 3l);
    	session.delete(linkman);
    	
    	tx.commit();
    	
    }

**6.一对多设置了双向关联产生多余的sql语句**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwODE3ODI3_size_16_color_FFFFFF_t_70 3]

*  解决多余的SQL语句  
    单向维护：  
    使一方放弃外键维护权：  
    一的一方放弃。在set上配置inverse=”true”  
    一对多的关联查询的修改的时候。

**7.区分cascade和inverse**

@Test
    /*区分cascade和inverse区别 
     * 
     */
    public void demo9() {
    	Session session = HibernateUtils.getCurrentSession();
    	Transaction tx = session.beginTransaction();
    	
    	Customer customer = new Customer();
    	customer.setCust_name("李冰");
    	
    	LinkMan linkman = new LinkMan();
    	linkman.setLkm_name("凤姐");
    	
    	customer.getLinkMans().add(linkman);
    	//条件是在Customer.hbm.xml的set配置了cascade="save-update" inverse="true"
    	
    	session.save(customer);//客户和联系人都会插入到数据库，但外键null
    	
    	tx.commit();
    }

[20190726173538199.png]: /images/20211122/04a20366e58e4bb5bfda5a9f03910890.png
[20190726173648770.png]: /images/20211122/66d350b9a08044b1b0d5fd1d1e05d6ca.png
[20190726173807538.png]: /images/20211122/1377ec8ac77b4ea08dbadcd41cdbb7b2.png
[2019072617420733.png]: /images/20211122/7af8608afee4460987c36b3a0eb3ff0b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwODE3ODI3_size_16_color_FFFFFF_t_70]: /images/20211122/5bee1021580d4dabb210bf3fb5ae8f9e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwODE3ODI3_size_16_color_FFFFFF_t_70 1]: /images/20211122/875d0614ebb14666ac69247497a0edaf.png
[20190801091719203.png]: /images/20211122/b49c1cfc7d0648db8648621e4540cdbb.png
[20190801094200153.png]: /images/20211122/0fdfb50fb68c48bc8be7e3abbe946f8f.png
[20190801094212385.png]: /images/20211122/3c7ce481b08d464994135823212d1478.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwODE3ODI3_size_16_color_FFFFFF_t_70 2]: /images/20211122/ba59cd51c9214a76a1ffb8eab399d84c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwODE3ODI3_size_16_color_FFFFFF_t_70 3]: /images/20211122/06fd249db59e4eb99031643b8f5337e7.png