hibernate--关系映射归纳和总结

最新推荐文章于 2024-05-10 11:56:07 发布
最新推荐文章于 2024-05-10 11:56:07 发布
阅读量1.4k 收藏
点赞数
分类专栏： hibernate 文章标签： hibernate 关联映射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012411414/article/details/50444008
版权

有用的参考文章：

http://blog.csdn.net/laner0515/article/details/12905711  重要

http://blog.csdn.net/linminqin/article/details/6324567

http://www.cnblogs.com/jyh317/p/3691842.html

http://blog.csdn.net/lovelyhermione/article/details/2020881

前言：

hibernate关系映射十分重要，对于掌握hibernate是必备的知识，关系映射分为一对一 一对多 多对一 多对多  看起来关系关系复杂，但其实了解其中原理就可以灵活自如运用。

在了解详细分类之前，有一些点和关键系必须掌握其意义：

cascade关键词：表示级联包括add update delete 一般情况不使用 不好。 作用：一般在保存对象时 需要先显示的save对端关联的对象 变为持久太之后才可以在被本端set进去，但在配置文件中加入级联之后 可以不显示的save，我们save本端对象后（set完对端） 自动save关联对象。
最佳实践： 如果没有特殊情况 不要使用cascade 特别注意：可能使用cascade的地方一般都是在一的一方进行删除时候 多的一方删除会出问题
特殊需求才会使用cascade的add 正常情况add方法都是应该由程序员添加（为了防止级联添加乱七八糟的其他东西）
inverse：默认为false 。设置为true表示让对端来进行维护关系 即让对端来set。 

lazy=extra：使用了lazy=extra之后会稍微只能些  会根据取得值得不同来判断是调用的count还是获取投影

property-ref：xml文件中主表端property-ref表示一对一时让对端（从表端）维护关系


1:    所谓哪端维护关系指含有对方引用的一端 可以对对端的对象set操作 可能由一端维护 也可能由多的一端维护
        如果有设置了Inverse=true 或 property-ref(1对1)的话 维护关系端变成对端
        所谓单双向  就是指在哪端加对端的引用
2： 在哪端添加时 要先把关联的对端对象给save了  不允许 不save 因为那是瞬时态，否则说瞬时对象没有被保存
      org.hibernate.TransientObjectException: object references an unsaved transient instance - save the transient instance before flushing但是有一种情况 就是xml配置时  加入cascade 可以不显示的save关联对象  但这在多对一级联删除多端某个对象时又出现问题  因为级联删除一端后  相同外键的多端值就错了
3：所谓One to many 双向 就是 one to many 单向加many to one 单向
4：注意：即使是双向设置 即两边都加了引用 但如果我在添加时 在一的一方添即维护关系 只在一端set了多端 而多端没有把一端set进去
      此时仍然会发出5条语句 三个插入 两个更新 因为需要更新外键值
5：注意：如果在一端加入了inverse=true 表示让对端（多端）维护关系  如果仍然像4中在一端set多端的值 
      此时只会产生3条插入语句  不会有更新语句  多端外键的则值为Null 因为多端根本不知道一端的情况即多端没有set一端的classroom值
6：一句话 如果让多端维护关系 那么添加时需要从多端添加 把一端的对象给set进去  才能正确
      如果让一端维护关系 那么添加时需要从一端添加set多端的值 但此时效率低 多产生update语句
7：一端加载时  可以把多的也加载出来 同理 多端加载时 可以把一端也加载进来（只要设置了关系即有了对方的引用即可）   注意  查询是不用级联的 与级联无关 用load时候 会自动懒加载关联对象（不会产生SQL语句 在调用它的属性时候才会）  get会自动加载关联对象（产生SQL语句）
        1） 加载和cascade是没有关系的 cascade只有增加 删除 修改  

        2） 加载也与Inverse没有关系  只要在某一端配置了关系 就可以进行加载对端或者懒加载

8：重要：关联加载产生的条件：
             只要本端持有对端的对象 也就是本端也维护关系 那么就可以用Load或者get来关联调用对方对象

注意：在一对一双向关联时最特殊（延迟加载在其他关联时都正常）：在先加载非维护关系端的对象时， 
              取维护关系一端的对象才能实现对端的延迟加载 如果取得是不维护关系的一端 那么只会发出1条语句（用join） 
              把关联对象全部查询 不会延迟加载

9：一对一的时候 最好不要使用双向关联 
     如果使用双向关联 尽可能在没有维护关系的一边取数据 
     hibernate会自动完成join操作 仅仅只会发出一条SQL
      如果从维护关系端取数据 在通过延迟加载取关联对象时  会同时再去取person的IDcard关联

10：在双向关系中 需要加一个设置 让某一端来进行维护 比如一对一时候 在主表端添加property-ref让从表端维护 一对多双向时候 设置inverse=true

11：多对多时 使用关联对象以及关联表（两个一对多关系） 不要单独使用关联表

12：总体来说：最佳实践就是，一般不使用双向关联，特别不建议使用一的这一方的关联
        在设计的时候不是特殊情况不要使用双向关联

一：多对一单向

配置文件：

hibernate.cfg.xml
<!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.dialect">
			org.hibernate.dialect.MySQLDialect</property>
		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hiber?characterEncoding=UTF8</property>
		<property name="hibernate.connection.username">root</property>
		<property name="hibernate.connection.password"></property>
		
		<property name="show_sql">true</property>
		<!--  <property name="format_sql">true</property>-->
		<property name="hibernate.hbm2ddl.auto">update</property>
		
		<mapping resource="com/itany/model/User.hbm.xml"/>
		<mapping resource="com/itany/model/Book.hbm.xml"/>
		<mapping resource="com/itany/model/Classroom.hbm.xml"/>
		<mapping resource="com/itany/model/Student.hbm.xml"/>
		<mapping resource="com/itany/model/Message.hbm.xml"/>
		<mapping resource="com/itany/model/Comment.hbm.xml"/>
	</session-factory>
</hibernate-configuration>

Classroom.hbm.xml

<?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 package="com.itany.model">

	<class name="Classroom" table="t_cla">
		<id name="id" >
		<!-- 主键的生成策略 native increment assigned-->
		 <generator class="native"></generator>
		</id>
		<property name="name" ></property>
		<property name="grade" ></property>
	</class>
</hibernate-mapping>

Student.hbm.xml 

<?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 package="com.itany.model">

	<class name="Student" table="t_stu">
		<id name="id" >
		<!-- 主键的生成策略 native increment assigned-->
		 <generator class="native"></generator>
		</id>
		<property name="name" ></property>
		<property name="no" ></property>
		<!-- 当设置cascade时候 会自动完成关联 若添加（写）时没有显示的添加关联对象(此处是之前写入父关联对象classroom) 那么会自动添加一个关联对象 
最佳实践： 如果没有特殊情况 不要使用cascade 特别注意：可能使用cascade的地方一般都是在一的一方进行删除时候 多的一方删除会出问题
特殊需求才会使用cascade的add 正常情况add方法都是应该由程序员添加（为了防止级联添加乱七八糟的其他东西）-->
		<many-to-one name="classRoom" class="Classroom" column="cid" cascade="all"></many-to-one>
	</class>
</hibernate-mapping>

junit4测试代码： 


public class TestMany2One
{
    /*
     * 多对一单向 
     */
    @Test
    public void testAdd1()
    {
        Session session=null;
        Transaction trans=null;
        try
        {
            session = HibernateUtil.openSession();
            trans = session.beginTransaction();
            //先添加一的一方  再添加多的一方 关系由多的一方维护 共发出三条SQL语句  
            Classroom c=new Classroom();
            c.setGrade(2016);
            c.setName("计算机");
            session.save(c);
            
            Student stu1=new Student();
            stu1.setName("张三");
            stu1.setNo("001");
            stu1.setClassRoom(c);
            Student stu2=new Student();
            stu2.setName("张三2");
            stu2.setNo("003");
            stu2.setClassRoom(c);
            session.save(stu1);
            session.save(stu2);
            
            trans.commit();
        }
        catch (Exception e)
        {
            if(null!=session)
                trans.rollback();
        }
        finally
        {
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
    }
    @Test
    public void testAdd2()
    {
        Session session=null;
        Transaction trans=null;
        try
        {
            session = HibernateUtil.openSession();
            trans = session.beginTransaction();
            //先添加多的一方  再添加一的一方 此时要多修改两次 发出5条语句
            Student stu1=new Student();
            stu1.setName("张三3");
            stu1.setNo("001");
            session.save(stu1);
            
            Student stu2=new Student();
            stu2.setName("张三4");
            stu2.setNo("003");
            session.save(stu2);
            
            Classroom c=new Classroom();
            c.setGrade(2017);
            c.setName("计算机");
            session.save(c);
            
            stu1.setClassRoom(c);
            stu2.setClassRoom(c);
            
            /*
             * 最佳实践  一定要先添加一的一方 再添加多的一方 总之关系让多的一方来维护
             */
            
            trans.commit();
        }
        catch (Exception e)
        {
            if(null!=session)
                trans.rollback();
        }
        finally
        {
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
    }
    @Test
    public void testAdd3WithoutCascade()
    {
        /*
         * 注意；查询是不用级联的 与级联无关 用load时候 会自动懒加载 get会自动加载
         * 在多的配置文件中没有加入cascade  也没有保存classroom 直接保存student
         * 在保存student时 是需要联系外键的 但此时 没有显示的保存classsroom 因此student和classroom都无法保存
         * 抛出异常
         * org.hibernate.TransientObjectException:
         *  object references an unsaved transient instance - save the transient instance before flushing: com.itany.model.Classroom
         */
        Session session=null;
        Transaction trans=null;
        try
        {
            session = HibernateUtil.openSession();
            trans = session.beginTransaction();
            Classroom c=new Classroom();
            c.setGrade(2018);
            c.setName("计算机科学");
           
            Student stu1=new Student();
            stu1.setName("张三5");
            stu1.setNo("001");
            session.save(stu1);
            
            Student stu2=new Student();
            stu2.setName("张三6");
            stu2.setNo("003");
            session.save(stu2);
            
            stu1.setClassRoom(c);
            stu2.setClassRoom(c);
            
            trans.commit();
        }
        catch (Exception e)
        {
            if(null!=session)
                trans.rollback();
            e.printStackTrace();
        }
        finally
        {
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
    }
    @Test
    public void testAdd4WithCascade()
    {
        /*
         * 不需要显示保存关联对象了
         */
        Session session=null;
        Transaction trans=null;
        try
        {
            session = HibernateUtil.openSession();
            trans = session.beginTransaction();
            Classroom c=new Classroom();
            c.setGrade(2018);
            c.setName("计算机科学");
           
            Student stu1=new Student();
            stu1.setName("张三5");
            stu1.setNo("001");
            session.save(stu1);
            
            Student stu2=new Student();
            stu2.setName("张三6");
            stu2.setNo("003");
            session.save(stu2);
            
            stu1.setClassRoom(c);
            stu2.setClassRoom(c);//发出五条语句 前三条为插入对象 后两条为修改stu对象
            
            trans.commit();
        }
        catch (Exception e)
        {
            if(null!=session)
                trans.rollback();
            e.printStackTrace();
        }
        finally
        {
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
    }
    @Test
    public void testLoad()
    {
        /*
         * 多对一 加载多的对象 可以把一的对象也加载出来（多端维护关系）
         */
        Session session=null;
        Transaction trans=null;
        try
        {
            session = HibernateUtil.openSession();
            trans = session.beginTransaction();
            Student s1=(Student)session.load(Student.class,1);//这一步没有SQL产生
            System.out.println(s1.getName());//此时仅仅发出1条SQL 并没有加载classroom对象 查询出的是代理 懒加载
            
            System.out.println(s1.getClassRoom().getName());//此时又发出一条sql 才真正查询classroom对象


            trans.commit();
        }
        catch (Exception e)
        {
            if(null!=session)
                trans.rollback();
        }
        finally
        {
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
    }
    @Test
    public void testLoad2()
    {
        /*
         * 单向多对一 加载一端的对象 （多端维护关系）这种从一端加载多端的对象是不可能的
         */
        Session session=null;
        Transaction trans=null;
        try
        {
            session = HibernateUtil.openSession();
            Classroom c1=(Classroom)session.load(Classroom.class,1);//这一步没有SQL产生 SQL产生在c1.getName()的时候
            //Classroom c1=(Classroom)session.get(Classroom.class,1);//这一步有SQL产生
            System.out.println(c1.getName());
            


        }
        catch (Exception e)
        {
            if(null!=session)
                e.printStackTrace();
        }
        finally
        {
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
    }
    @Test
    public void testDeleteWithCascade()
    {
        /*
         * 在多的一方进行级联删除 配置文件已加cascade=all
         * 当有多个多的一方外键只想同一个一的对象
         * 在级联删除多的某一个时 想把一的一方也级联删除 会异常
         * Cannot delete or update a parent row: a foreign key constraint
         * 因为多的一方还有其他的行关联了同一个一的一方的对象
         */
        Session session=null;
        Transaction trans=null;
        try
        {
            session = HibernateUtil.openSession();
            trans = session.beginTransaction();
            Student s=(Student)session.load(Student.class,11);
            session.delete(s);
            trans.commit();
        }
        catch (Exception e)
        {
            if(null!=session)
                trans.rollback();
            e.printStackTrace();
        }
        finally
        {
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
    }
}

二：一对多单向

一对多单向 开发中不建议使用 麻烦 效率低

Message.hbm.xml

<?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 package="com.itany.model">

	<class name="Message" table="t_message">
		<id name="id" >
		<!-- 主键的生成策略  assigned 开发人员指定 -->
		 <!--  <generator class="assigned"></generator>  -->
		<!-- 主键的生成策略  uuid会自动生成字符串16进制 128位 16字节  注意此时主键必须为String类型 --> 
		 <generator class="native"></generator>
		</id>
		<property name="title" ></property>
		<property name="content" ></property>
		<!-- 使用了lazy=extra之后会稍微只能些  会根据取得值得不同来判断是调用的count还是获取投影 -->
		<set name="comments" lazy="extra">
			<!-- key 指的是(对方)多的一方的外键名称 此处为one to many 单向-->
			<key column="mid" />
			<one-to-many class="Comment"/>
		</set>
	</class>
</hibernate-mapping>

Comment.hbm.xml 

<?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 package="com.itany.model">

	<class name="Comment" table="t_comment">
		<id name="id" >
		<!-- 主键的生成策略  assigned 开发人员指定 -->
		 <!--  <generator class="assigned"></generator>  -->
		<!-- 主键的生成策略  uuid会自动生成字符串16进制 128位 16字节  注意此时主键必须为String类型 --> 
		 <generator class="native"></generator>
		</id>
		<property name="content" ></property>
	</class>

</hibernate-mapping>

junit4测试 

public class TestOne2Many
{
    /*
     * 一对多单向 
     * 开发中不建议使用 麻烦 效率低
     */
    @Test
    public void testAdd()
    {
        Session session=null;
        Transaction trans=null;
        
        try
        {
            session=HibernateUtil.openSession();
            trans=session.beginTransaction();
            Comment c1=new Comment();
            c1.setContent("123");
            Comment c2=new Comment();
            c2.setContent("456");
            session.save(c1);
            session.save(c2);
            Message m1=new Message();
            m1.setTitle("圣兽山");
            m1.setContent("sssssssssssssssssssssssss");
            m1.addComments(c1);
            m1.addComments(c2);
            session.save(m1);
            trans.commit();
            /*
             * 一共发出5条SQL语句  三个Insert 两个Update 因为在一的一方维护关系（一种有多方的引用 一方来set）
             * 多的一方无法知道主表是什么 因为多的一方没有一方的引用
             * 因此 一的一方保存后 为了通过One2many维护关系 需要通过外键update2次  在一方维护效率低下
             */
        }
        catch (HibernateException e)
        {
            if(null!=session)
                trans.rollback();
            e.printStackTrace();
        }
        finally
        {
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
            
    }
    @Test
    public void testLoad()
    {
        /*
         * 一端加载时  可以把多的也加载出来 同理 多端加载时 可以把一端也加载进来  
         * 1 加载和cascade是没有关系的 cascade只有增加 删除 修改  
         * 2 加载也与Inverse没有关系  只要在某一端配置了关系 就可以进行加载对端或者懒加载
         */
        Session session=null;
        session=HibernateUtil.openSession();
        Message m1=(Message)session.load(Message.class,1);
        System.out.println(m1.getContent());
        Set<Comment> comments=m1.getComments();
        for (Comment comment : comments)
        {
            //懒加载
            System.out.println(comment.getContent());
        }
        try
        {
            session=HibernateUtil.openSession();

        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
    }
    @Test
    public void testLoad2()
    {
        /*
         * 在set标签中添加 lazy="extra" 使得我们调用set.size()方法时候 SQL用count（）稍微智能
         * <set name="comments" lazy="extra">
         */
        Session session=null;
        session=HibernateUtil.openSession();
        Message m1=(Message)session.load(Message.class,1);
        System.out.println(m1.getContent());
        Set<Comment> comments=m1.getComments();
        System.out.println(comments.size());
        try
        {
            session=HibernateUtil.openSession();

        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
    }
}


三：一对多双向  多对一双向 

主要还是看谁来维护关系 即让哪端进行添加操作等

如果在这种设置下，代码中让一端维护关系 在配置文件中一端inverse=true  让多端配置
那么会造成多端的外键值为Null

Classroom.hbm.xml

<?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 package="com.itany.model">

	<class name="Classroom" table="t_cla">
		<id name="id" >
		<!-- 主键的生成策略 native increment assigned-->
		 <generator class="native"></generator>
		</id>
		<property name="name" ></property>
		<property name="grade" ></property>
		<set name="students" lazy="extra" inverse="true">
			<key column="cid"/>
			<one-to-many class="Student"/>
		</set>
	</class>
</hibernate-mapping>

Student.hbm.xml 

</pre><pre name="code" class="html"><?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 package="com.itany.model">

	<class name="Student" table="t_stu">
		<id name="id" >
		<!-- 主键的生成策略 native increment assigned-->
		 <generator class="native"></generator>
		</id>
		<property name="name" ></property>
		<property name="no" ></property>
		<!-- 当设置cascade时候 会自动完成关联 若添加（写）时没有显示的添加关联对象(此处是之前写入父关联对象classroom) 那么会自动添加一个关联对象 
最佳实践： 如果没有特殊情况 不要使用cascade 特别注意：可能使用cascade的地方一般都是在一的一方进行删除时候 多的一方删除会出问题
特殊需求才会使用cascade的add 正常情况add方法都是应该由程序员添加（为了防止级联添加乱七八糟的其他东西）-->
		<many-to-one name="classRoom" class="Classroom" column="cid" cascade="all"></many-to-one>
	</class>
</hibernate-mapping>

junit4测试 

 @Test
    public void testAdd3()
    {
        /*
         * 所谓维护关系 就是指在哪端添加            所谓单双向 就是指在哪端加对端引用
         * 在一端维护  表示在一端set进多端的值
         * 在多端维护  表示在多端set进一端的值
         * 
         * 注意：在哪端添加时 要先把关联的对端对象给save了  不允许 不save 因为那是顺势态
         * 
         * 所谓One to many 双向 就是 one to many 单向加many to one 单向
         * 1 注意：即使是双向设置 即两边都加了引用 但如果我在添加时 在一的一方添即维护关系 只在一端set了多端 而多端没有把一端set进去
         * 此时仍然会发出5条语句 三个插入 两个更新 因为需要更新外键值
         * 
         * 2 注意：如果在一端加入了inverse=true 表示让对端（多端）维护关系  如果仍然像情况1中在一端set多端的值 
         * 此时只会产生3条插入语句  不会有更新语句  多端外键的则值为Null 因为多端根本不知道一端的情况即多端没有set一端的classroom值
         * 
         * 一句话 如果让多端维护关系 那么添加时需要从多端添加 把一端的对象给set进去  才能正确
         * 如果让一端维护关系 那么添加时需要从一端添加set多端的值 但此时效率低 多产生update语句
         */
        Session session=null;
        Transaction trans=null;
        
        try
        {
            session=HibernateUtil.openSession();
            trans=session.beginTransaction();
            Student s1=new Student();
            s1.setName("lisi3");
            s1.setNo("333");//注意！！！ 瞬时对象要先session.save 然后在被set进classroom对象中 否则报错 说瞬时对象没有被保存
                            //org.hibernate.TransientObjectException: object references an unsaved transient instance - save the transient instance before flushing
            session.save(s1);
            
            Student s2=new Student();
            s2.setName("lisi4");
            s2.setNo("444");
            session.save(s2);
            
            Set<Student> students=new HashSet<Student>();
            students.add(s1);
            students.add(s2);
            Classroom c=new Classroom();
            c.setName("C++班");
            c.setGrade(2019);
            
            c.setStudents(students);
            session.save(c);
            trans.commit();//5条SQL
            /*
             * 一共发出5条SQL语句  三个Insert 两个Update 因为在一的一方维护关系（一种有多方的引用 一方来set）
             * 多的一方无法知道主表是什么 因为多的一方没有一方的引用
             * 因此 一的一方保存后 为了通过One2many维护关系 需要通过外键update2次  在一方维护效率低下
             */
        }
        catch (HibernateException e)
        {
            if(null!=session)
                trans.rollback();
            e.printStackTrace();
        }
        finally
        {
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
            
    }
    @Test
    public void testAdd4()
    {
        /*
         * 与testAdd3对应 这是双向 时限制在多端进行维护（inverse）  先把一端关联的给save了
         */
        Session session=null;
        Transaction trans=null;
        
        try
        {
            session=HibernateUtil.openSession();
            trans=session.beginTransaction();
            
            Classroom c=new Classroom();
            c.setName("C班");
            c.setGrade(2020);
            session.save(c);
            
            Student s1=new Student();
            s1.setName("lisi5");
            s1.setNo("555");//注意 瞬时对象要先session.save 然后在被set进classroom对象中 否则报错 说瞬时对象没有被保存
                            //org.hibernate.TransientObjectException: object references an unsaved transient instance - save the transient instance before flushing
            s1.setClassRoom(c);
            session.save(s1);
            
            Student s2=new Student();
            s2.setName("lisi6");
            s2.setNo("666");
            s2.setClassRoom(c);
            session.save(s2);
            
            trans.commit();//5条SQL
            /*
             * 一共发出5条SQL语句  三个Insert 两个Update 因为在一的一方维护关系（一种有多方的引用 一方来set）
             * 多的一方无法知道主表是什么 因为多的一方没有一方的引用
             * 因此 一的一方保存后 为了通过One2many维护关系 需要通过外键update2次  在一方维护效率低下
             */
        }
        catch (HibernateException e)
        {
            if(null!=session)
                trans.rollback();
            e.printStackTrace();
        }
        finally
        {
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
            
    }
    @Test
    public void testLoad3()
    {
        /*
         *环境是 一对多 双向 两端都进行了配置 同上
         */
        Session session=null;
        session=HibernateUtil.openSession();
        Classroom c=(Classroom)session.load(Classroom.class,7);//从一端加载
        System.out.println(c.getStudents().size());
        
        Student s=(Student)session.load(Student.class,17);//从多端加载
        System.out.println(s.getName());
        System.out.println(s.getClassRoom().getName());//此处不会产生SQL  用的是session缓存
        //以上一共3条SQL
        try
        {
            session=HibernateUtil.openSession();

        }
        catch (HibernateException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
    }

四：一对一单向（从表端进行维护关系）

主表：person.hbm.xml

<?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 package="com.itany.model">

	<class name="Person" table="t_person">
		<id name="id" column="id">
		<!-- 主键的生成策略 native increment assigned-->
		 <generator class="native"></generator>
		</id>
		<property name="name" />
	</class>

</hibernate-mapping>

从表：idcard.hbm.xml 

<?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 package="com.itany.model">

	<class name="IDCard" table="t_id_card">
		<id name="id" column="id">
			<generator class="native"></generator>
		</id>
		<property name="no" ></property>
		<!-- 一对一外键关联 -->
		<many-to-one name="person" column="pid" unique="true" />
		
	</class>

</hibernate-mapping>

junit4测试： 

public class TestOne2One
{
    
    //person是主表 idcard是从表
    //-----------------------------------以下为一对一单向（由外键即从表端维护关系）------------------------------------------
    @Test
    public void testAdd()
    {
        Session session=null;
        Transaction trans=null;
        try
        {
            session = HibernateUtil.openSession();
            trans = session.beginTransaction();
            Person p=new Person();
            p.setName("隔壁老王");
            session.save(p);
            IDCard card=new IDCard();
            card.setNo("111111");
            card.setPerson(p);
            session.save(card);
            
            trans.commit();
        }
        catch (Exception e)
        {
            if(null!=session)
                trans.rollback();
            e.printStackTrace();
        }
        finally
        {
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
    }
   
    @Test
    public void testAdd02()
    {
        /*
         * 由于使用了Unique 为一对一单向外键关联 此时添加两个一端绑定同一个Person 包重复错误
         */
        Session session=null;
        Transaction trans=null;
        try
        {
            session = HibernateUtil.openSession();
            trans = session.beginTransaction();
            Person p=(Person)session.load(Person.class,1);
            IDCard card=new IDCard();
            card.setNo("22222222");
            card.setPerson(p);
            session.save(card);
            
            trans.commit();
        }
        catch (Exception e)
        {
            if(null!=session)
                trans.rollback();
            e.printStackTrace();
        }
        finally
        {
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
    }
    @Test
    public void testload1()
    {
        Session session=null;
        Transaction trans=null;
        try
        {
            session = HibernateUtil.openSession();
            //从多的一端进行延迟加载
            /*
             * 所谓哪端维护关系指含有对方引用的一端 可以对对端的对象set操作 可能由一端维护 也可能由多的一端维护
             * 如果有设置了Inverse=true 或 property-ref(1对1)的话 维护关系端变成对端
             * 
             * 重要：延迟加载产生的条件：
             * 1 加载时候使用Load方法
             * 2 取维护关系一端的对象才能实现对端的延迟加载 如果取得是不维护关系的一端 那么只会发出1条语句（用join） 
             *   把关联对象全部查询 不会延迟加载
             * 
             * 因此这个一对一单向 从表端维护 可以做到延迟加载 会产生2条SQL语句
             */
            IDCard card=(IDCard)session.load(IDCard.class,5);
            System.out.println(card.getNo()+","+card.getPerson().getName());
            
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
    }
}


五：一对一双向（特殊 最好不要使用）
如果一定要使用 在查询时候 要从不维护关系的一端进行查询 这样只会产生1条语句 ，若从维护关系的一端查询会产生3条语句 效率低 

<?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 package="com.itany.model">

	<class name="Person" table="t_person">
		<id name="id" column="id">
		<!-- 主键的生成策略 native increment assigned-->
		 <generator class="native"></generator>
		</id>
		<property name="name" />
		<!-- name表示属性的名次
		     property-ref表示由对端来维护关系 也就是对端的person属性维护关系 -->
		<one-to-one name="card" property-ref="person" />
	</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 package="com.itany.model">

	<class name="IDCard" table="t_id_card">
		<id name="id" column="id">
			<generator class="native"></generator>
		</id>
		<property name="no" ></property>
		<!-- 一对一外键关联 -->
		<many-to-one name="person" column="pid" unique="true" />
		
	</class>

</hibernate-mapping>

测试代码： 

 //-----------------------------------以下为一对一双向（两边都进行了配置）------------------------------------------
    @Test
    public void testAdd3()
    {
        /*
         * 重要 xml文件中主表端property-ref表示一对一时让对端（从表端）维护关系  因此
         * 下面的添加操作 虽然我们是在主表端进行的  但是从表端的外键值为null 关系不会更新（因为添加代码没有从从表端维护 即没有从表.set(主表对象)）
         * 和在双向一对多关联时 一端Inverse时发生的情形一样
         */
        Session session=null;
        Transaction trans=null;
        try
        {
            session = HibernateUtil.openSession();
            trans = session.beginTransaction();
            IDCard card=new IDCard();
            card.setNo("3333");
            session.save(card);
            Person p=new Person();
            p.setName("隔离老张");
            p.setCard(card);
            session.save(p);
            trans.commit();
        }
        catch (Exception e)
        {
            if(null!=session)
                trans.rollback();
            e.printStackTrace();
        }
        finally
        {
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
    }
    @Test
    public void testAdd4()
    {
        /*
         * 一对一双向都配置时 主表端配置了property-ref  表示让对端从表进行维护
         * 我们这里从从表外键端进行添加维护  完全正确
         */
        Session session=null;
        Transaction trans=null;
        try
        {
            session = HibernateUtil.openSession();
            trans = session.beginTransaction();
            Person p=new Person();
            p.setName("lao liu");
            session.save(p);
            IDCard card=new IDCard();
            card.setNo("6666");
            card.setPerson(p);
            session.save(card);
            trans.commit();
        }
        catch (Exception e)
        {
            if(null!=session)
                trans.rollback();
            e.printStackTrace();
        }
        finally
        {
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
    }
    @Test
    public void testload2()
    {
        /*
         * 一对一双向时  从没有维护关系的一端（此时是主表端 因为主表端设置了property-ref表示对端维护）进行加载
         * 此时会产生一条SQL语句 不会延迟加载 
         * 因为延迟加载是由维护关系的一端也就是外键端进行的
         */
        Session session=null;
        Transaction trans=null;
        try
        {
            session = HibernateUtil.openSession();
            Person p=(Person)session.load(Person.class,1);
            System.out.println(p.getName()+p.getCard().getNo());
            
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
    }
    @Test
    public void testload3()
    {
        /*这个地方比较特殊：
         * 一对一双向时  从维护关系的一端 此处为从表端进行取从表对象 会发3条
         * 第一条为从表对象 第二条为把懒加载的主表对象取出  因为主表关联从表 此时又会发一条去取idcard 共3条
         * 
         * 特别注意：如果没有双向，此时会发两条 一条取IDcard 一条延迟加载person
         * 
         */
        Session session=null;
        Transaction trans=null;
        try
        {
            session = HibernateUtil.openSession();
            IDCard card=(IDCard)session.load(IDCard.class,5);
            System.out.println(card.getNo()+","+card.getPerson().getName());
            
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
    }
    /*
     * 最佳实践：
     * 一对一的时候 最好不要使用双向关联 
     * 如果使用双向关联 尽可能在没有维护关系的一边取数据 
     * hibernate会自动完成join操作 仅仅只会发出一条SQL
     * 如果从维护关系端取数据 在通过延迟加载取关联对象时  会同时再去取person的IDcard关联
     */


六：多对多（三张表 两个类  使用关联表  不推荐 因为很多字段只能存在关联表中 又没有对应的类对应 很是不方便）

admin 表示用户 role表示角色 是多对多的关系

Admin.hbm.xml

<?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 package="com.itany.model">

	<class name="Admin" table="t_admin">
		<id name="id" >
		 <generator class="native"></generator>
		</id>
		<property name="name" />
		<set name="roles" table="t_admin_role" lazy="extra">
			<key column="aid" /><!-- 是我在对方的外键 在别人的表里-->
			<many-to-many class="Role" column="rid"/>
		</set>
	 
	</class>

</hibernate-mapping>

Role.hbm.xml 

<?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 package="com.itany.model">

	<class name="Role" table="t_role">
		<id name="id" >
		 <generator class="native"></generator>
		</id>
		<property name="name" />
		<set name="admins" table="t_admin_role" lazy="extra">
			<key column="rid" />
			<many-to-many class="Admin" column="aid"/>
		</set>
	</class>

</hibernate-mapping>

测试代码： 

/*
     * 使用ManyToMany（两个实体类 三个表 其中一个为关联表）无论从哪端来维护关系都比较麻烦
     * 而且很多属性只能加在关联表中 比如学生-课程关系 学生每门课的成绩就必须保存在关联表中 而在实体类中没有类与之对应
     * 
     * 所以在开发中，经常是使用两个一对多的关系来代替多对多（三个实体类 三张表）
     */
    //------------------------------------两个实体类 三个表 其中一个为关联表------------------------------------------------
    @Test
    public void testAdd()
    {
        Session session=null;
        Transaction trans=null;
        
        try
        {
            session=HibernateUtil.openSession();
            trans=session.beginTransaction();
            Admin a1=new Admin();
            a1.setName("张三");
            session.save(a1);
            Admin a2=new Admin();
            a2.setName("李四");
            session.save(a2);
            
            Role r1=new Role();
            r1.setName("超级管理员");
            r1.add(a1);
            r1.add(a2);
            session.save(r1);
            
            Role r2=new Role();
            r2.setName("财务管理员");
            r2.add(a1);
            r2.add(a2);
            session.save(r2);
            //以上共产生8条语句
            //2条admin插入 2条role插入
            //4条中间表插入
            trans.commit();
        }
        catch (HibernateException e)  
        {
            if(null!=session)
                trans.rollback();
            e.printStackTrace();
        }
        finally
        { 
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
            
    }
    @Test
    public void testLoad()
    {
        Session session=null;
        Transaction trans=null;
        try
        {
            session = HibernateUtil.openSession();
            Admin a1=(Admin)session.load(Admin.class,1);
            for (Role role : a1.getRoles())
            {
                System.out.println(role.getName());
            }//以上产生两条语句
            
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
    }

七：多对多（三张表 三个类 两个一对多关系的合并 推荐使用）

teacher和course的关系  使用TeacherCourse作为关联对象 且有对应的关联表

teacher.hbm.xml

<?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 package="com.itany.model">

	<class name="Teacher" table="t_teacher">
		<id name="id" >
		 <generator class="native"></generator>
		</id>
		<property name="name" />
		<set name="tcs" lazy="extra" inverse="true">
			<key column="tid" />
			<one-to-many class="TeacherCourse"/>
		</set>
	 
	</class>

</hibernate-mapping>
course.hbm.xml 

<?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 package="com.itany.model">

	<class name="Course" table="t_course">
		<id name="id" >
		 <generator class="native"></generator>
		</id>
		<property name="name" />
		<set name="tcs" lazy="extra" inverse="true">
			<key column="cid" />
			<one-to-many class="TeacherCourse" />
		</set>	 
	</class>

</hibernate-mapping>
teachercourse.hbm.xml 
<?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 package="com.itany.model">

	<class name="TeacherCourse" table="t_teacher_course">
		<id name="id" >
		 <generator class="native"></generator>
		</id>
		<property name="score" />
		<many-to-one name="teacher" column="tid" class="Teacher" /> 
		<many-to-one name="course" column="cid" class="Course" />
	</class>

</hibernate-mapping>
TeacherCourse.java 

public class TeacherCourse
{
    private int id;
    private double score;
    private Teacher teacher;
    private Course course;
//set get方法
}
测试类： 

//------------------------------------三个实体类 三个表 两个一对多关系的合并------------------------------------------------
    
    @Test
    public void testAdd2()
    {
        Session session=null;
        Transaction trans=null;
        
        try
        {
            session=HibernateUtil.openSession();
            trans=session.beginTransaction();
            Teacher t1=new Teacher();
            t1.setName("张三");
            session.save(t1);
            Teacher t2=new Teacher();
            t2.setName("李四");
            session.save(t2);
            
            Course c1=new Course();
            c1.setName("java");
            session.save(c1);
            Course c2=new Course();
            c2.setName("c++");
            session.save(c2);
            
            TeacherCourse tc1=new TeacherCourse();
            tc1.setScore(99);
            tc1.setTeacher(t1);
            tc1.setCourse(c1);
            session.save(tc1);
            
            TeacherCourse tc2=new TeacherCourse();
            tc2.setScore(98);
            tc2.setTeacher(t1);
            tc2.setCourse(c2);
            session.save(tc2);
            
            TeacherCourse tc3=new TeacherCourse();
            tc3.setScore(97);
            tc3.setTeacher(t2);
            tc3.setCourse(c1);
            session.save(tc3);
            
            TeacherCourse tc4=new TeacherCourse();
            tc4.setScore(96);
            tc4.setTeacher(t2);
            tc4.setCourse(c2);
            session.save(tc4);
            
            trans.commit();
        }
        catch (HibernateException e)  
        {
            if(null!=session)
                trans.rollback();
            e.printStackTrace();
        }
        finally
        { 
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
            
    }
    @Test
    public void testLoad2()
    {
        Session session=null;
        Transaction trans=null;
        try
        {
            //共产生4条SQL
            session = HibernateUtil.openSession();
            Teacher t=(Teacher)session.load(Teacher.class, 1);//这步执行完并没有产生SQL
            for (TeacherCourse tc:t.getTcs())//第一次到这会产生两条SQL语句
            {
                System.out.println(tc.getCourse().getName()+","+tc.getScore());//每次到这都会延迟加载一次
            }
            /*
             * load的时候由于延迟加载 会根据不同的情况取相应的关联对象  所以会发出大量的sql
             * 
             * 总体来说：最佳实践就是，一般不使用双向关联，特别不建议使用一的这一方的关联
             * 因为从一的这一端取关联对象很有可能涉及到分页操作（一次就要取出大量对象 不能使用延迟加载），所以基本不会使用
             * 
             * 在设计的时候不是特殊情况不要使用双向关联
             */
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(null!=session)
                HibernateUtil.closeSession(session);
        }
    }

把hibernate关联映射总结下，可终结。也为日后复习方便。



一路走来的自己
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Hibernate的关系映射实例总结
FYM1211的博客
07-22 219
Hibernate的关系映射实例总结 1、实例说明 利用hibrante技术做数据持久层，实现一个小吃点餐demo，实现小吃的种类展示，全部小吃展示，用户餐后点评。 数据库表有，用户表，小吃表，小吃种类表，用户评论表，以及小吃用户关系表。 其中关系为： 小吃种类表与小吃表一对多。 用户与小吃表多对多。 用户与评论一对多。 这个系统最主要的就是学习hiberate的关系映射部分。 直接需要项目的可以点击跳转到我这里–>>hibernate关系映射demo 2、实例结构 就之后dao层和vo层，记
Hibernate关系映射总结
路在路上的博客
08-24 484
1.无论是单向多对多还是双向多对多（@ManyToMany），都使用连接表（@JoinTable）的形式建立两个实体的关联关系 2.单向一对多，建议使用有链接表的单向一对多，注解为@OneToMany（cascade={CascadeType.ALL}) @JoinTable 3.单向一对一，无连接表时注解为@OneToOne(cascade={CascadeType.ALL}) @JoinC
Hibernate 关系映射 收集、总结整理
Cages的专栏
05-14 207
《Hibernate 关系映射》是我很早之前收集、总结整理的，在此也发上来 希望对大家有用。因为是很早之前写的，不当之处请指正。 一、概念： 关系：名词，事物之间相互作用、相互联系的状态。 关联：名词：表示对象（数据库表）之间的关系；动词：将对象（数据库表）之间通过某种方式联系起来。 映射：将一种形式转化为另一种形式，包括关系。 级联：动词，有关系的双方中操作一方，另一方也将采取一些...
Hibernate 框架总结(四)：多张表的关联映射
llllllxj的博客
05-15 2490
Hibernate 框架总结(一)：简单开发Hibernate 框架总结(二)：session的获取方式及hibernate对象的生命周期Hibernate 框架总结(三)：主键的生成策略表与表之间的关系存在三种关系一对一：丈夫——妻子， 学生——学生证一对多：学生——班级， 皇帝——大臣多对多：学生——课程， 学生——老师配置关系映射的时候，无论是什么关系，要保证你中有我，我中有你的思想一对一开...
Hibernate多对多的关系映射，详解（代码+图解）与应用 举个栗子，搞的清楚
最新发布
2401_83330354的博客
05-10 644
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
hibernate关联关系映射总结
阿福的时光机
10-15 180
这里主要是为了自己梳理学习的知识，重在理解不是代码实践。 第一问：关联关系映射干什么用的？ hibernate给我们提供的就是ORM功能，我们通过组织对象（包含私有对象）配置xml文件让hibernate帮助我们完成，类与类的关系映射到到数据库中表与表之间。 第二问：关联关系有那些呢？ 单向一对一，双向一对一，单向一对多，单向多对一，双向一对多，单向多对多，双向多对多。 （双向一对多，多对一没...
hibernate中关联映射的学习总结
weixin_33716154的博客
10-06 89
数据表单的关联（只有一种情况）和hibernate的关联映射 hibernate关联映射是建立在数据表的关联之上的，根据业务需求，方便数据的操作而设计的 而数据表的关联，不一定会导致hibernate的关联1、many-to-one关联映射（单项关联） public class Customer { private Integer id; private String n...
Spring+Hibernate+MySql的应用实例
04-25
测试过程中，若遇到问题，可参照作者归纳的总结和不能运行的原因来排查和修复。 总之，"Spring+Hibernate+MySql的应用实例"是一个典型的Java Web开发示例，涵盖了从数据持久化到业务逻辑处理再到Web展示的完整流程...
WorkingwithHibernateinEclipse英文原文归纳.pdf
03-04
Hibernate是一种强大的对象关系映射（ORM）框架，它允许开发者用面向对象的方式处理数据库操作，从而减少了数据访问层的复杂性。在Eclipse中，通过Hibernate Synchronizer插件，我们可以实现映射文件和Java代码之间...
JAVAWEB开发三大框架整理归纳.pdf
10-30
"JAVAWEB开发三大框架...JavaWeb开发三大框架整理归纳是指Struts、Hibernate和Spring三个框架的整合和比较。三个框架的整合可以提供一个更加完善的JavaWeb开发解决方案，但需要根据实际情况选择合适的框架和整合方式。
ssh框架搭建[归纳].pdf
10-12
Hibernate是一个强大的ORM（对象关系映射）工具，负责对象与数据库之间的转换。配置Hibernate包括：设置Hibernate的配置文件（hibernate.cfg.xml）、实体类的定义、DAO层的编写以及SessionFactory的创建。在...
hibernate关联映射的作用和常用属性解释
10-28
文件中包含关于hibernate 各个属性的解释
hibernate表的映射关系总结
11-05
hibernate表映射一直记不住，这次总结一下，放便下次使用。。。
hibernate映射关系总结
08-19
hibernate开发的关系： one-to-one,many-to-one,many-to-many学习经验总结
JAVA错误文档[归纳].pdf
10-19
确保你的`struts.xml`文件中已经定义了相应的行为映射，例如`<action name="attent" class="net.qbsp.AccessoryAction">`，并且对应的Action类和方法存在。 3. **XML文档解析错误：Attribute 'calss' is not ...
hibernate映射关系
影子
10-18 296
hibernate的关联关系映射一共有7种： 1.单向多对一 2.单向一对多 3.单向一对一 4.单向多对多 5.双向多对一 6.双向一对一 7.双向多对多 一，单向多对一（many--to--one） 两个对象之间多对一的关系，比如员工（emp）和部门（dept），多个员工可以在一个部门，映射原理就是在多的一端添加一个外键指向一的一端的主键。 在多的一端的映射
Hibernate的七种映射关系之七种关联映射（一）
weixin_34239169的博客
04-27 127
　　 　　关联映射就是将关联关系映射到数据库里，在对象模型中就是一个或多个引用。　　 　　一、Hibernate多对一关联映射：就是在“多”的一端加外键，指向“一”的一端。 　　比如多个学生对应一个班级，多个用户对应一个级别等等，都是多对一关系。 　　 　　1、“多”端实体加入引用“一”端实体的变量及getter,setter方法。 　　比如说多个学生对应一个班级，在学生实体类加入：p...
Hibernate关联映射（非常详细）
youandme520的专栏
02-12 1585
在前面的学习中，我们所涉及的都是基于单表的操作，但在实际的开发过程中，基本上都是同时对多张表的操作，且这些表都存在一定的关联关系。 Hibernate 是一款基于 ORM 设计思想的框架，它将关系型数据库中的表与我们 Java 实体类进行映射，表中的记录对应实体类的对象，而表中的字段对应着实体类中的属性。Hibernate 进行增删改查等操作时，不再直接操作数据库表，而是对与之对应的实体类对象进行处理。那么，Hibernate 是如何处理多表关联问题的呢？本节我们针对此问题进行介绍。 关联映射 在关系型
hibernate关联关系
weixin_56069070的博客
10-25 6533
前言：今天要分享的知识是hibernate框架的关联关系 码字不易，点个赞 转载请说明！ 开发工具:eclipse 目录 一、一对多的配置 二、懒加载 1、定义：懒加载可以这样理解，只加载某一项东西，其他的东西不会加载 2、操作：在我们进行项目的操作时候，就会想到，当自己把订单的id查出来之后，改订单id下面的对应的订单项会不会也同样出来 三、一对多的自关联 1、定义：一对多的自关联就好比做树形菜单的时候，就会出现一个最大的节点，下面会有很多的子节点。 2、案例 四、多对多的配置 .
Hibernate实体关联关系映射实战与总结
"这篇文章是关于Hibernate实体关联关系映射的学习总结，主要探讨了在实际开发中如何选择和使用各种关联关系，以及作者对单表映射与业务逻辑控制外键关系的看法。" 在软件开发中，尤其是Java企业级应用中，Hibernate...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值