映射 一对一

转载 2012年03月30日 16:16:18

Person类:

Java代码  收藏代码
  1. package dao.po;  
  2.   
  3. /** 
  4.  * @author zl 人类 
  5.  *  
  6.  */  
  7. public class Person  
  8. {  
  9.     private int     id; //ID   
  10.   
  11.     private String  name;   //姓名  
  12.   
  13.     private IdCard  idCard; //身份证(对象)  
  14. }  

 

IdCard类:

Java代码  收藏代码
  1. package dao.po;  
  2.   
  3. /** 
  4.  * @author zl 身份主类 
  5.  *  
  6.  */  
  7. public class IdCard  
  8. {  
  9.     private int     id;     //ID  
  10.   
  11.     private String  address;    //地址  
  12.   
  13.     private Person  person; //身份证的主人  
  14. }  

 

两个XML:

Xml代码  收藏代码
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC   
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping   
  6.     package="dao.po">  
  7.   
  8.     <class name="Person">       
  9.         <id name="id">  
  10.             <generator class="native"/>  
  11.         </id>       
  12.         <property name="name" not-null="true" length="255" column="`name`"/>  
  13.           
  14.         <!-- 这里做一对一映射    -->  
  15.         <!-- 没什么好说的,就是一 one-to-one -->          
  16.         <one-to-one name="idCard" ></one-to-one>  
  17.     </class>  
  18.       
  19. </hibernate-mapping>  

 

Xml代码  收藏代码
  1. <?xml version="1.0"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC   
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping   
  6.     package="dao.po">  
  7.   
  8.     <class name="IdCard" table="id_card">       
  9.         <id name="id">  
  10.             <!-- 注意:  -->  
  11.             <!-- 本类的id 既是主键,又是外键  -->  
  12.             <!-- IdCard对象的是从对象, Person是主对象, 先有主,后有从.  -->           
  13.             <generator class="foreign">  
  14.                 <!-- 此处的person是IdCard类的一个属性 -->  
  15.                 <param name="property">person</param>  
  16.             </generator>  
  17.               
  18.         </id>       
  19.         <property name="address" not-null="true" length="255" column="`address`"/>  
  20.           
  21.         <!-- 此处的person是IdCard类的一个属性 -->  
  22.         <!-- constrained="true" 对生成的数据表产生约束,id_card表的id既是主键,又是外键 -->    
  23.         <!-- constrained="false" 表结构上没有约束, 取何值对对象关系没影响,只是对表结构有影响-->  
  24.         <one-to-one name="person" constrained="true"/>  
  25.     </class>  
  26.       
  27. </hibernate-mapping>  

 

保存与查询:

Java代码  收藏代码
  1. package dao;  
  2.   
  3. import org.hibernate.Hibernate;  
  4. import org.hibernate.Session;  
  5. import org.hibernate.Transaction;  
  6.   
  7. import dao.po.IdCard;  
  8. import dao.po.Person;  
  9.   
  10. public class One2One  
  11. {  
  12.   
  13.     /** 
  14.      * @param args 
  15.      */  
  16.     public static void main(final String[] args)  
  17.     {  
  18.         add();  
  19.         final IdCard c1 = query(5);  
  20.         System.out.println(c1.getPerson().getName());  
  21.     }  
  22.   
  23.     /** 
  24.      * 保存 
  25.      */  
  26.     public static void add()  
  27.     {  
  28.         final Person p1 = new Person();  
  29.         p1.setName("小明");  
  30.   
  31.         final IdCard c1 = new IdCard();  
  32.         c1.setAddress("北京市海淀区上地");  
  33.   
  34.         p1.setIdCard(c1); //建立关联(不能少)  
  35.         c1.setPerson(p1); //建立关联(不能少)  
  36.   
  37.         Session session = null;  
  38.         try  
  39.         {  
  40.             session = HibernateUtil.getSeesion();  
  41.             final Transaction tx = session.beginTransaction();  
  42.             //session.save(p1); //  
  43.             session.save(c1); //身份证是从对象依赖于主对象, "身份证"依赖于"人",   
  44.             //保存 c1 , 也会自动保存 他依赖的p1,前题是c1 与p1要关联.  
  45.             tx.commit();  
  46.   
  47.             //SQL 如下:  
  48.             //Hibernate: insert into Person (`name`) values (?)  
  49.             //Hibernate: insert into id_card (`address`, id) values (?, ?)  
  50.             //虽然只执行了session.save(c1) , 但有两个insert  
  51.   
  52.         }  
  53.         finally  
  54.         {  
  55.             if (session != null)  
  56.             {  
  57.                 session.close();  
  58.             }  
  59.         }  
  60.     }  
  61.   
  62.     /** 
  63.      * 查询 身份证, 
  64.      *  
  65.      * @param id 
  66.      * @return 
  67.      */  
  68.     public static IdCard query(final int id)  
  69.     {  
  70.         Session session = null;  
  71.         try  
  72.         {  
  73.             session = HibernateUtil.getSeesion();  
  74.             final IdCard c1 = (IdCard) session.get(IdCard.class, id);  
  75.             Hibernate.initialize(c1.getPerson());  
  76.             return c1;  
  77.             //SQL 如下:  
  78.             //Hibernate: select idcard0_.id as id3_0_, idcard0_.`address` as address2_3_0_ from id_card idcard0_ where idcard0_.id=?  
  79.             //Hibernate: select person0_.id as id2_1_, person0_.`name` as name2_2_1_, idcard1_.id as id3_0_, idcard1_.`address` as address2_3_0_ from Person person0_ left outer join id_card idcard1_ on person0_.id=idcard1_.id where person0_.id=?  
  80.             //注意person表又连了id-card表  
  81.         }  
  82.         finally  
  83.         {  
  84.             if (session != null)  
  85.             {  
  86.                 session.close();  
  87.             }  
  88.         }  
  89.     }  
  90. }  

 

---------------------------------------------------------------------------------------------------------------------------------------------------

第二种情况: IdCard类的ID 只是主键, IdCard类多一属性 person_id做 外键,指向Person类的主键.

 

这种情况有点像 多对一  .

 

关系如下图:

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 


两个配置文件 内容如下,  只抓了图, 没写代码,  很简单的,不用写了,  看看图就行了 .   (图中的配置是正确的)


 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

分享到:

hibernate 一对一映射的两种方式

一对一映射一共有两种映射方式: 使用用户和身份证信息的一对一的关系 User: package cn.itcast.one2one; public class User { private i...
  • u014010769
  • u014010769
  • 2015年07月28日 23:46
  • 2004

Hibernate中映射关系 一对一 详解

一对一有两种关联方式:主键关联 主键既是主键也是外键 一对一主键关联: 表中: 一对一 关联映射,我们在数据库表中设计的时候,应该是一个表中关联另一张表中的id  外键 不会各自拥有。这样符合数...
  • u010908743
  • u010908743
  • 2015年02月28日 11:49
  • 951

JPA学习笔记(9)——映射双向一对一关联关系

双向一对一关联关系一个部门有一个经理,一个经理管一个部门Department实体类package com.jpa.helloworld2;import javax.persistence.Column...
  • u010837612
  • u010837612
  • 2015年08月15日 15:21
  • 2457

mybatis 一对一的映射(两种方式)

对于一对一的关系映射一共有两种解决方案: 开发步骤:1)写OrdersMapperUser.xml文件 2)编写与xml同名的接口OrdersMapperUser 3)测试 声明:一下xml文件的...
  • u014010769
  • u014010769
  • 2015年08月05日 20:25
  • 2795

【SSH快速进阶】——Hibernate一对一映射(one-to-one)——主键关联映射

在Hibernate中实现一对一映射,有两种实现方式:1、主键关联;2、唯一外键关联,这里先说一下主键关联映射。   主键关联映射:其中一个表的主键依赖于另一张表的主键而建立起的一对一的关系,这两张互...
  • huyuyang6688
  • huyuyang6688
  • 2015年12月10日 16:50
  • 1976

【SSH】Hibernate:O/R实体映射与一对一关联

实体映射 O/R映射是ORM框架中最为关键的组成部分了。其中的实体映射介绍hibernate中类和表之间的映射属性字段的基本技术   问题:数据库中有一个表【T_User】,其中字段有【ID】、【na...
  • mengdonghui123456
  • mengdonghui123456
  • 2016年05月16日 18:04
  • 1222

【SSH进阶之路】Hibernate映射——一对一单向关联映射(五)

两个实体对象之间是一对一的关联映射,即一个对象只能与另外唯一的一个对象相对应。例如:一个人(Person)只有一张身份证(IdCard)。...
  • jiuqiyuliang
  • jiuqiyuliang
  • 2014年10月23日 08:15
  • 23584

【SSH进阶之路】Hibernate映射——一对一双向关联映射(六)

上篇博文【SSH进阶之路】Hibernate映射——一对一单向关联映射(五),我们介绍了一对一的单向关联映射,单向是指只能从人(Person)这端加载身份证端(IdCard),但是反过来,不能从身份证...
  • jiuqiyuliang
  • jiuqiyuliang
  • 2014年10月31日 08:39
  • 19188

hibernate中一对一映射配置详细解析(一)

本例模仿用户与身份证相对应的关系,即一个用户对应一个身份证信息,且身份证信息不能重复,下面代码是实现基于外键的一对一映射 1.hibernate.cfg.xml ...
  • miachen520
  • miachen520
  • 2016年08月11日 16:41
  • 4241

关联关系映射——一对一关联

一对一关联    Hibernate映射实体的一对一关联关系有两种实现方式:共享主键方式和唯一外键方式。所谓共享主键方式就是限制两个数据表的主键使用相同的值,通过主键实现一对一映射关系,即主键相同。...
  • huanhuanxiaoxiao
  • huanhuanxiaoxiao
  • 2016年12月18日 12:44
  • 367
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:映射 一对一
举报原因:
原因补充:

(最多只允许输入30个字)