hibernate自身一对多和自身多对多映射详解

版权声明:本文为博主原创,要转载留个名先 https://blog.csdn.net/do_bset_yourself/article/details/51105917

<span style="font-family: Arial, Helvetica, sans-serif; font-size: 12px; background-color: rgb(255, 255, 255);">有时候我们使用对象时可能涉及到自身关联,但部分操作和普通对象映射无异,但是还是有些细微的差异,这里我们来探讨一下详细解释都在代码中:</span>

自身一对一关联,这里采用上下级部门映射:

Department对象:

public class Department {
	private Integer id;
	private String name;
	private Department parent;
	private Set<Department> children=new HashSet<Department>();
setter
getter略
}


配置映射文件

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2016-4-9 15:45:45 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping package="com.leige.self.oneTomany">
    <class name="Department" table="department">
        <id name="id" type="int">
            <column name="ID" />
            <generator class="assigned" />
        </id>
        <property name="name" type="string">
            <column name="name" />
        </property>
<!--         自身多对一,表示与上级部门的一对多关系 -->
        <many-to-one name="parent" class="Department"  >
            <column name="parentID" />
        </many-to-one>
<!--        自身一对多,表示与下级部门的一对多关系

由于是自身关联无法设置使多的少的一方维护关系,所以只能使用集合维护关系,但是在设置保存的时候如果再对象层面上设置
双边关系,自动生成多条update语句,执行效率差,所以当我们使用自身关联时,在对象上设置单边关系,这样可以减少sql语句的执行
提高效率
 -->
        <set name="children"  inverse="false" lazy="true">
            <key>
                <column name="parentID" />
            </key>
            <one-to-many class="Department" />
        </set>
    </class>
</hibernate-mapping>


类图和数据表:


测试类:略:自己不会写的话,也看不懂这个

自身关联多对多:

本例采用Person *
 *自身多对多
 *一个人可以有多个父母()一般两个
 *也可以有多个孩子
 *例子有点牵强
 *但不影响表达

Person 类

/**
 * @author 磊哥
 *自身多对多
 *一个人可以有多个父母()一般两个
 *也可以有多个孩子
 *例子有点牵强
 *但不影响表达
 */
public class Person {
	private Integer id;
	private String name;
	//父母
	private Set<Person> parents=new HashSet<Person>();
	//孩子
	private Set<Person> chilren=new HashSet<Person>();
setter...
getter...
}

映射文件:

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2016-4-9 16:01:42 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping package="com.leige.self.manyTomany">
    <class name="Person" table="person">
        <id name="id" type="int">
            <column name="ID" />
            <generator class="native" />
        </id>
        <property name="name" type="string">
            <column name="name" />
        </property>
  <!--       自身多对多,和一般对多多差不多,只不过都是写在一个配置文件中,注意集合属性的对应,同样也需要一个中间表
  
  或者我们在设计对象时,可以生成一个无关属性,用来保证每条记录的唯一性,person的id可以重复
  表结构为
  uuid id name parentID childID
  这里就不再介绍,其实我也没有做过,这只是我的设想,不过也可以实现,这里就不再介绍了,实现的话,也会有各种问题,也许我们要自己维护person的唯一性了
  
  中间表为有孩子的人的对应关系
  personID childID
  
       -->  
        <set name="parents" table="parent_son" inverse="true" lazy="true" >
            <key>
                <column name="personID" />
            </key>
            <many-to-many class="Person" column="childID"></many-to-many>
        </set>
          <!--       自身多对多,和一般对多多差不多,只不过都是写在一个配置文件中,注意集合属性的对应
          这里设置儿子们维护关系
       -->  
        <set name="chilren"  table="parent_son" inverse="false" lazy="true">
            <key>
                <column name="childID" />
            </key>
       <many-to-many class="Person" column="personID"></many-to-many>
        </set>
    </class>
</hibernate-mapping>
类图和关系表:


测试类

package com.leige.self.manyTomany;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

public class App {
	static SessionFactory sessionFactory=null;
	static{
	sessionFactory=new Configuration().configure().buildSessionFactory();
	}
/**
 * 测试保存
 */
	@Test
public void testSave(){
	Session session=sessionFactory.openSession();
	session.beginTransaction();
	//新建对象
	
	Person father=new Person();
	father.setName("爸爸");
	Person mother=new Person();
       mother.setName("妈妈");
       
	Person person=new Person();
	person.setName("person");
	
	Person son=new Person();
	son.setName("儿子");
	Person daughter=new Person();
	daughter.setName("女儿");

	//设置关系,由于可以设置一方维护,所以我们可以在对象层面上设置双向关系,也不会多生成sql语句
	father.getChilren().add(person);
	mother.getChilren().add(person);
	person.getParents().add(father);
	person.getParents().add(mother);
	
	
	person.getChilren().add(daughter);
	person.getChilren().add(son);
	son.getParents().add(person);
	daughter.getParents().add(person);
	//保存
	session.save(mother);
	session.save(father);
	session.save(person);
	session.save(daughter);
	session.save(son);
	
	//提交
	session.getTransaction().commit();
	session.close();
	
}


}


没有更多推荐了,返回首页