hibernate基础-映射关系(一对多I多对多).

一对多关联映射(one-to-many)
一对多关联映射利用了多对一关联映射原理
  * 多对一关联映射:在多的一端加和一个外键指向一的一端,它维护的关系是多指向一的
  * 一对多关联映射:在一的一端加和一个外键指向多的一端,它维护的关系是一指向多的
也就是说一对多和多对一的映射策略是一样的,只是站的角度不同,一般都作成双项的
------------------------------------------------------------------------------
1 一对多关联映射(单项Classes--->Student)
在一一端维护关系的缺点:
  * 如果将t_student表里的classesid这段设置为非空,则无法保存
  * 因为不在student这一端维护关系,所以student不知道是哪个班的
    所以需要发出多余的update语句来更新关系

<!--
  Classes:                                  Student:
    private int id;                         private int id;
    private String name;             private String name;
    private Set students;//必须用Set
-->
<class name="com.my.hibernate.Student">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
</class>

<class name="Classes">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
        <set name="students">
            <key column="classesid"/>
            <one-to-many class="Student"/>
        </set>
</class>

public void testSave1(){
        Session session=null;
        try{
            session=HibernateUtils.getSession();
            session.beginTransaction();
            
            Student student1=new Student();
            student1.setName("10");
            session.save(student1);//先进行save操作
            
            Student student2=new Student();
            student2.setName("祖儿");
            session.save(student2);//先进行save操作
            
            Set students=new HashSet();
            students.add(student1);
            students.add(student2);
            Classes classes=new Classes();
            classes.setName("尚学堂");
            classes.setStudents(students);
            session.save(classes);
            
            session.getTransaction().commit();
        }catch(Exception e){
            session.getTransaction().rollback();
            e.printStackTrace();
        }finally{
            HibernateUtils.closeSession(session);
        }
    }
    
    public void testLoad1(){
        Session session=null;
        try{
            session=HibernateUtils.getSession();
            session.beginTransaction();
            
            Classes classes=(Classes)session.load(Classes.class, 3);
            System.out.println(classes.getName());
            Set students=classes.getStudents();
            for(Iterator iter=students.iterator();iter.hasNext();){
                Student student=(Student)iter.next();
                System.out.print(student.getName()+";");
            }
            
            session.getTransaction().commit();
        }catch(Exception e){
            session.getTransaction().rollback();
            e.printStackTrace();
        }finally{
            HibernateUtils.closeSession(session);
        }
    }

2 一对多关联映射(双项Classes<--->Student)

一对多双向关联映射：
  * 在一一端的集合上用<key>,在对方表中加入一个外键指向一的一端
  * 在多的一端采用<many-to-one>
注意：<key>标签指定的外键字段必须和<many-to-one>指定的外键字段一致，否则引用字段错误

如果在一的一端维护一对多关联关系，hibernate会发出多余的update语句，所以我们一般在多的一端来维护关联关系

关于inverse属性：
   inverse主要用在一对多和多对多双向关联上，inverse可以被设置到集合标签<set>上，
   默认inverse为 false，所以我们可以从一的一端和多的一端维护关联关系，
   如果设inverse为true，则我们只能从多的一端来维护关联关系
注意：inverse属性，只影响数据的存储，也就是持久化。

inverse和cascade:
  * inverse是关联关系的控制方向
  * cascade是操作上的连锁反应

<!--
  Classes:                                      Student:
    private int id;                               private int id;
    private String name;                   private String name;
    private Set students;//必须用 Set private Classes classes;
-->
<class name="Classes">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
        <set name="students" inverse="true" cascade="all">
                //cascade属性：none 不及连 save-update 插入或更新及连 delete删除及连 all
            <key column="classesid"/>
            <one-to-many class="Student"/>
        </set>
</class>

<class name="com.my.hibernate.Student">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
        <many-to-one name="classes" column="classesid" cascade="save-update"/>
</class>

public void testSave1(){
        Session session=null;
        try{
            session=HibernateUtils.getSession();
            session.beginTransaction();
            //在多方维护
            Classes classes=new Classes();
            classes.setName("北青");
            //session.save(classes);//加了cascade属性可以不用
            Student student1=new Student();
            student1.setName("黄不接10");
            student1.setClasses(classes);
            session.save(student1);
            
            session.getTransaction().commit();
        }catch(Exception e){
            session.getTransaction().rollback();
            e.printStackTrace();
        }finally{
            HibernateUtils.closeSession(session);
        }
    }
    
    public void testLoad1(){
        Session session=null;
        try{
            session=HibernateUtils.getSession();
            session.beginTransaction();
            //从多方读取
            Student student=(Student)session.load(Student.class, 5);
            System.out.println(student.getName());
            System.out.println(student.getClasses().getName());
            
            session.getTransaction().commit();
        }catch(Exception e){
            session.getTransaction().rollback();
            e.printStackTrace();
        }finally{
            HibernateUtils.closeSession(session);
        }
    }
    
    public void testSave2(){
        Session session=null;
        try{
            session=HibernateUtils.getSession();
            session.beginTransaction();
            //在一方维护，自动转向多方
            Classes classes=new Classes();
            classes.setName("尚学堂");
            Student student1=new Student();
            student1.setName("10");
            student1.setClasses(classes);
            Student student2=new Student();
            student2.setName("祖儿");
            student2.setClasses(classes);
            Set students=new HashSet();
            students.add(student1);
            students.add(student2);
            classes.setStudents(students);
    
            session.save(classes);
            
            session.getTransaction().commit();
        }catch(Exception e){
            session.getTransaction().rollback();
            e.printStackTrace();
        }finally{
            HibernateUtils.closeSession(session);
        }
    }

多对多关联映射(单项User---->Role)
<many-to-many/>标签
<set>标签中加入属性table="t_user_role"创建关联表

<!--
  User:                              Role:
  private int id;                   private int id;
    private String name;     private String name;
    private Set roles;
-->        
<class name="com.my.hibernate.Role">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
</class>

<class name="User">
        <id name="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
        <set name="roles" table="t_user_role">
            <key column="userid"/>
            <many-to-many class="Role" column="roleid"/>
        </set>
</class>

public void testSave1(){
        Session session=null;
        try{
            session=HibernateUtils.getSession();
            session.beginTransaction();
            Role role1=new Role();
            role1.setName("1111");
            Role role2=new Role();
            role2.setName("2222");
            Role role3=new Role();
            role3.setName("3333"color: #0

分享到：

hiberante基础-继承映射 | hibernate基础-映射关系(多对一I一对一 ...

• 2009-11-03 16:04
• 浏览 599
• 评论(0)
• 查看更多