`

hibernate 一对一映射

Hibernate.netXML 
阅读更多
（一）主键关联，即限制两张表的主键使用相同的值。

          例如登记业务信息表的字段很多，可是平时有些字段用的并不是那么多，因此可以把平时比较少用的字段放到另一表中，这样平时加载业务信息表的时候就不用加载这些字段，效率比较高。这次就学生和档案的关系举例，每个学生都有一个档案，但平时档案用的不多而且内容多。

   （1）编写POJO类
      Tb_student.java

（一）主键关联，即限制两张表的主键使用相同的值。

          例如登记业务信息表的字段很多，可是平时有些字段用的并不是那么多，因此可以把平时比较少用的字段放到另一表中，这样平时加载业务信息表的时候就不用加载这些字段，效率比较高。这次就学生和档案的关系举例，每个学生都有一个档案，但平时档案用的不多而且内容多。

   （1）编写POJO类
      Tb_student.java

    public class TbStudent {
         private Long sn;
         private String name;
         private String sex;
         private String age;
         public Long getSn() {
              return sn;
         }
         public void setSn(Long sn) {
              this.sn = sn;
         }
         public String getName() {
              return name;
         }
         public void setName(String name) {
              this.name = name;
         }
         public String getSex() {
              return sex;
         }
         public void setSex(String sex) {
              this.sex = sex;
         }
         public String getAge() {
              return age;
         }
         public void setAge(String age) {
              this.age = age;
         }
    }

  tb_dossier.java
public class TbDossier {
      private Long sn;
      private String seniorSchool;
      private String highSchool;
      private String university;
      private TbStudent tbStudent;

      public TbStudent getTbStudent() {
            return tbStudent;
      }
      public void setTbStudent(TbStudent tbStudent) {
            this.tbStudent = tbStudent;
      }
      public Long getSn() {
            return sn;
      }
      public void setSn(Long sn) {
            this.sn = sn;
      }
      public String getSeniorSchool() {
            return seniorSchool;
      }
      public void setSeniorSchool(String seniorSchool) {
            this.seniorSchool = seniorSchool;
      }
      public String getHighSchool() {
            return highSchool;
      }
      public void setHighSchool(String highSchool) {
            this.highSchool = highSchool;
      }
      public String getUniversity() {
            return university;
      }
      public void setUniversity(String university) {
            this.university = university;
      }
}

（2）映射文件

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
<hibernate-mapping package="com.longtop.entity">
    <class name="TbStudent" table="TB_STUDENT">
        <id name="sn" type="java.lang.Long" column="SN">
            <generator class="sequence" >
            <param name="sequence">seq_tb_student_sn</param>
            </generator>       
        </id>
        <property name="name" type="java.lang.String">
            <column name="NAME" length="30" not-null="true" />
        </property>
 
        <property name="sex" type="java.lang.String">
            <column name="SEX" length="20" />
        </property>
         <property name="age" type="java.lang.String">
            <column name="AGE" length="20" />
        </property>   
    </class>
</hibernate-mapping>
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

<hibernate-mapping package="com.longtop.entity">
    <class name="TbDossier" table="TB_DOSSIER">
        <id name="sn" type="java.lang.Long" column="SN">
            <generator class="foreign">
                  <param name="property">tbStudent</param>
            </generator>
        </id>
        <property name="highSchool" type="java.lang.String">
            <column name="HIGH_SCHOOL" length="30" not-null="true" />
        </property>
 
        <property name="seniorSchool" type="java.lang.String">
            <column name="SENIOR_SCHOOL" length="20" />
        </property>
        <property name="university" type="java.lang.String">
            <column name="UNIVERSITY" length="20" />
        </property>
        <one-to-one name="tbStudent" class="TbStudent"
           cascade="all">
        </one-to-one>      
    </class>
</hibernate-mapping>
    tb_dossier的主键sn和对应的tb_student的主键sn是相同值，主要通过foreign的方式生成的，其中如果删除了可以级联操作cascade，即删除了tb_dossier，就会自动删除tb_student。

（4）测试类

    public class OneToOne {
   
         public static void main(String[] args) throws HibernateException {
              SessionFactory sessions =   new Configuration().configure().buildSessionFactory();
              Session session = sessions.openSession();
              Transaction tx = session.beginTransaction();
              Long start = new Date().getTime();
              System.out.println("starttime:"+start);
             
              //添加、修改、删除方法
              OneToOne.createStudent(session,
                OneToOne.newStudent(session, "leochou", "26"),
                "1中",
                "1中",
                "厦门大学");
             
              OneToOne.updateDossier(session, new Long("11"));
            // OneToOne.updateStudent(session, new Long("31"));
            //
            // OneToOne.deleteDossier(session, new Long("6"));
             
            // session.save(OneToOne.createStudent(session, "lucy", "20"));
              tx.commit();
              session.close();
             
              Long end = new Date().getTime();  
              System.out.println("endtime:"+end);
              System.out.println("总共用了"+(end-start)+"的时间");
       
         }
         private static TbStudent newStudent(Session session,String name,String age) throws HibernateException {
              TbStudent student = new TbStudent();
              student.setName(name);
              student.setAge(age);
              return student;
         }
       
         private static void createStudent(Session session,
                   TbStudent student,
                   String highSchool,
                   String seniorSchool,
                   String university) throws HibernateException {
              TbDossier dossier = new TbDossier();
              dossier.setHighSchool(highSchool);
              dossier.setSeniorSchool(seniorSchool);
              dossier.setUniversity(university);
              dossier.setTbStudent(student);
              session.save(dossier);
         }
        
         private static void updateDossier(Session session,Long sn) throws HibernateException {
              TbDossier dossier = (TbDossier) session.load(TbDossier.class, sn);
              dossier.setSeniorSchool("八中");
              dossier.getTbStudent().setName("change dossier");
              session.update(dossier);
         }
        
         private static void updateStudent(Session session,Long sn) throws HibernateException {
              TbStudent student = (TbStudent) session.load(TbStudent.class, sn);
              student.setName("change student");
              session.update(student);
         }
        
         private static void deleteDossier(Session session,Long sn) throws HibernateException {
              TbDossier dossier = (TbDossier) session.load(TbDossier.class, sn);
              session.delete(dossier);
         }
    }

注意：

       为了保证每个同学都有一个档案，所以创建学生的时候，必须session.save(tbDossier)。这样才能tb_student与tb_dossier同时创建。

    （二）tb_dossier通过student_sn外键关联tb_student。

              两种实现方式的最大不同在于：1、tb_dossier必须新增一个字段student_sn存放对应的tb_student的sn，2、配置文件的不同，tb_dossier主键的生成不再以来tb_student的主键，独立生成。两个的关系用<many to one>表示，注意 unique="true"必须设为true。

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

<hibernate-mapping package="com.longtop.entity">
    <class name="TbDossier" table="TB_DOSSIER">
        <id name="sn" type="java.lang.Long" column="SN">
        <generator class="sequence">
        <param name="sequence">seq_tb_dossier_sn</param>
        </generator>
        </id>
        <property name="highSchool" type="java.lang.String">
            <column name="HIGH_SCHOOL" length="30" not-null="true" />
        </property>
 
        <property name="seniorSchool" type="java.lang.String">
            <column name="SENIOR_SCHOOL" length="20" />
        </property>
        <property name="university" type="java.lang.String">
            <column name="UNIVERSITY" length="20" />
        </property>
        <many-to-one name="tbStudent"
        class="com.longtop.entity.TbStudent"
        column="STUDENT_SN"
        unique="true" cascade="all">
        </many-to-one>      
    </class>
</hibernate-mapping>
分享到：
| 使得select选择框也可以输入
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    hibernate一对一映射

    "hibernate一对一映射"是Hibernate中的一个重要概念，它用于表示两个实体类之间一对一的关系。这种关系意味着在一个实体类中，每个实例都唯一对应另一个实体类的单个实例。 一对一映射有以下几种实现方式： 1. **...

    Hibernate一对一映射

    **Hibernate一对一映射详解** 在Java的持久化框架中，Hibernate是备受青睐的一员，它提供了一种方便的方式来处理对象与数据库之间的映射关系。本文将深入探讨Hibernate中的一对一映射，帮助开发者理解并掌握这种...

    hibernate 映射关系学习入门 一对一映射

    在提供的压缩包`TestHiberOnetoOne`中，可能包含了使用Eclipse创建的Hibernate一对一映射关系的项目源码。你可以通过运行这个项目来更直观地理解一对一映射的工作原理，包括实体类的定义、配置文件的编写以及如何在...

    hibernate一对一映射例子

    本教程将通过一个具体的例子来深入理解Hibernate中的一对一映射。 首先，一对一映射的基本概念：在数据库设计中，一对一关系意味着两个表中的每个记录都唯一对应另一个表中的一个记录。例如，一个人可能只有一个...

    Hibernate 一对一

    深入理解 Hibernate 一对一映射的实现原理，需要阅读 Hibernate 源码，了解其如何生成 SQL 以及如何处理关联对象的加载和更新。 **总结** Hibernate 的一对一映射是 ORM 设计中的重要部分，它使得数据访问更加便捷...

    Hibernate一对一唯一外键关联映射（单向关联）

    在Java的持久化框架Hibernate中，一对一（One-to-One）关联映射是常见的...以上就是关于Hibernate一对一唯一外键关联映射（单向关联）的详细说明。通过这种方式，我们可以轻松地在Java应用中处理数据库的一对一关系。

    hibernate多对多关联映射

    在Java的持久化框架Hibernate中，多对多关联映射是一种常见的关系数据库模型映射方式，用于处理两个实体之间存在多个实例互相关联的情况。本文将深入探讨Hibernate如何实现多对多关联映射，并通过实际例子解析相关...

    Hibernate一对一关联映射(注解)

    ### Hibernate一对一关联映射原理 一对一关联映射是指在数据库中两个表之间存在一对一的关系，例如，一个人只有一个身份证，一个身份证也只属于一个人。在Hibernate中，我们可以通过@OneToOne注解来实现这种映射。 ...

    hibernate 主键一对一映射（单向） 实例（java类）

    本实例将深入探讨如何在Hibernate中实现主键级别的单向一对一映射。 首先，我们理解一对一映射的基本概念。在数据库设计中，一对一映射通常发生在两个表的主键之间，其中一个表的主键是另一个表的外键。在Hibernate...

    hibernate关联映射详解

    包含《多对多双向关联映射》《多对一单向关联映射》《多对一双向关联映射》《一对多单向关联映射》等文档，并有图解及例子，非常适合新手学习，尤其是刚刚接触hibernate，对映射关系不清楚的。。。。

    Hibernate一对一主键关联映射（双向关联）

    标题"Hibernate一对一主键关联映射（双向关联）"中的"主键关联"指的是两个实体通过共享相同的主键来建立关联。"双向关联"则意味着在两个实体类中，都可以直接访问到对方的实例，即在实体A中有一个对实体B的引用，...

    Hibernate一对一主键映射

    在这个实例中，我们将深入探讨Hibernate一对一主键映射的概念、配置以及如何通过源代码和测试程序进行实践。 1. **一对一关系理解**： 一对一关系指的是一个实体类中的记录对应另一个实体类中的唯一一条记录。例如...

    Hibernate一对一外键映射

    **标题：Hibernate一对一外键映射** 在关系型数据库中，一对一（One-to-One）关联是一种常见的关系，它表示两个实体之间存在着唯一的关系。Hibernate，作为Java领域中的一个流行的ORM（对象关系映射）框架，提供了...

    hibernate 一对多多对一的映射

    通过学习和实践Hibernate的一对多和多对一映射，你可以更高效地管理数据库中的复杂关系，使得数据操作更加便捷。在实际项目中，根据业务需求灵活运用这些映射策略，可以极大地提高开发效率和代码的可维护性。

    hibernate一对一主键关联映射（双项关联）

    在Java的持久化框架Hibernate中，一对一（One-to-One）关联映射是一种常见的关系映射方式，用于表示两个实体之间一对一的对应关系。本篇主要探讨的是基于主键（Primary Key）的双向关联映射，这在实际项目中非常常见...

    Hibernate 一对一关联映射（主键关联VS唯一外键关联）

    在Java的持久化框架Hibernate中，一对一（One-to-One）关联映射是常见的关系数据库模型。这篇文章将深入探讨两种主要的一对一关联映射方式：主键关联（Primary Key Join）和唯一外键关联（Foreign Key Join）。我们...

    hibernate(一对多，多对一映射)操作

    本文将深入探讨Hibernate中的一对多和多对一映射关系，并通过一个实际的demo演示它们在增删查改操作中的应用。 首先，我们要理解什么是数据库的关联关系。在数据库设计中，我们经常遇到一种情况，即一个实体可能与...

    hibernate_one_to_one映射简单入门例子

    **一、Hibernate一对一映射简介** 在Java编程中，Hibernate是一个强大的对象关系映射（ORM）框架，它允许开发者将数据库操作转化为面向对象的方式。在数据表之间，有一种常见的关联关系是一对一（One-to-One），即...

    hibernate一对一关联映射

    **标题:** Hibernate一对一关联映射 **描述:** 在Java开发中，Hibernate作为一款强大的对象关系映射（ORM）框架，极大地简化了数据库操作。一对一（OneToOne）关联映射是Hibernate提供的一种对象关系映射策略，它...

Magicbox
Global site tag (gtag.js) - Google Analytics