Hibernate实体关系映射：单向主键一对一关联

最新推荐文章于 2019-07-17 19:48:00 发布
最新推荐文章于 2019-07-17 19:48:00 发布
阅读量654 收藏
点赞数
分类专栏： Hibernate 文章标签： hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/walktoprogram/article/details/50275845
版权

主键单向一对一关联：

1、被控方的主键参照主控方的主键来生成

2、对应数据库表关系为被控方的主键同时参照引用主控方的主键

3、保存被控方对象，需要先保存主控方（不然怎么从native产生主键值，被控方更是获取不到了）


主控方People

public class People  implements java.io.Serializable {


    // Fields    

     private long id;
     private String name;
     private long age;
     private String sex;
   


    // Constructors

    /** default constructor */
    public People() {
    }

    // Property accessors

    public long getId() {
        return this.id;
    }
    
    public void setId(long id) {
        this.id = id;
    }

    public String getName() {
        return this.name;
    }
    
    public void setName(String name) {
        this.name = name;
    }

    public long getAge() {
        return this.age;
    }
    
    public void setAge(long age) {
        this.age = age;
    }

    public String getSex() {
        return this.sex;
    }
    
    public void setSex(String sex) {
        this.sex = sex;
    }

   
}


People的hbm.xml文件：只是普通的映射文件 

<hibernate-mapping>
    <class name="com.sjr.bean.People" table="J_PEOPLE" schema="SXBBKF">
        <id name="id" type="long">
            <column name="ID" precision="10" scale="0" />
            <generator class="native"></generator>
        </id>
        <property name="name" type="string">
            <column name="NAME" length="20" />
        </property>
        <property name="age" type="long">
            <column name="AGE" precision="10" scale="0" />
        </property>
        <property name="sex" type="string">
            <column name="SEX" length="2" />
        </property>
    </class>
</hibernate-mapping>

从控方IdCard的实体类：

public class IdCard  implements java.io.Serializable {


    // Fields    

     private long id;
     private People people;  <span style="color:#ff0000;">//这里加上主控方People类型的属性</span>
     private String numcode;


    // Constructors

    /** default constructor */
    public IdCard() {
    }
 
   
    // Property accessors

    public long getId() {
        return this.id;
    }
    
    public void setId(long id) {
        this.id = id;
    }

    public People getPeople() {
        return this.people;
    }
    
    public void setPeople(People people) {
        this.people = people;
    }

    public String getNumcode() {
        return this.numcode;
    }
    
    public void setNumcode(String numcode) {
        this.numcode = numcode;
    }

IdCard的hbm.xml文件：负责维护关系 

<hibernate-mapping>
    <class name="com.sjr.bean.IdCard" table="J_IDCARD" schema="SXBBKF">
        <id name="id" type="long">
            <column name="ID" precision="10" scale="0" />
            <generator class="foreign">      <!--<span style="color:#ff0000;">从控方的主键生成策略是 foreign 的方式，这里的param属性是它自己对应的属性名</span>-->
            <param name="property">people</param>
            </generator>
        </id>
        <property name="numcode" type="string">
            <column name="NUMCODE" length="20" />
        </property>
        
        <one-to-one name="people" class="com.sjr.bean.People" constrained="true"></one-to-one>  </span>
<span style="font-size:14px;"><span style="white-space:pre">	</span><!--<span style="color:#ff0000;">这里需要one-to-one进行映射，后面的constrained 后面详解，主要影响save、delete的先后顺序而已,详情看这里</span>-->
    </class>
</hibernate-mapping>



二、测试增删改查

（1）查询

//从控方idcard查询操作
	 public void testidcard(){
			
		Session session=null;
		try{
			session=HibernateUtil.getSession();
			IdCard idcard=(IdCard)session.get(IdCard.class, new Long("48"));  
</pre><pre name="code" class="java">                                             //获取IdCard中Id是48的对象，并进而通过一对一的映射关系获取其对应的people的值
			System.out.println(idcard.getId()+" "+idcard.getNumcode());
			System.out.println(idcard.getPeople().getId()+" "+idcard.getPeople().getName()+" "+idcard.getPeople().getAge());
			
			
		}catch (Exception e) {
			
			e.printStackTrace();
			
		}finally{
			HibernateUtil.closeSession();
		}	
	}


输出效果： 

Hibernate: select idcard0_.ID as ID0_0_, idcard0_.NUMCODE as NUMCODE0_0_ from SXBBKF.J_IDCARD idcard0_ where idcard0_.ID=?
48 3203203201
Hibernate: select people0_.ID as ID1_0_, people0_.NAME as NAME1_0_, people0_.AGE as AGE1_0_, people0_.SEX as SEX1_0_ from SXBBKF.J_PEOPLE people0_ where people0_.ID=?
48 张三 20

注：如果constrained=true，hibernate即会延迟加载sql，只把主表的查出来，等有用到关联表的再发sql取。

发放


（2）添加

public void testSaveIdCard(){
			
			Session session=null;
			try{
				session=HibernateUtil.getSession();
				session.getTransaction().begin();
				
				People people=new People();
				people.setName("张三");
				people.setAge(20);
				people.setSex("M");    //主控方的对象
				
				//session.save(people);
				
				IdCard idcard=new IdCard();
				idcard.setNumcode("3203203201");
				idcard.setPeople(people);
				session.save(idcard);   //constrained为true，则在插入从控方对象前，需要创建一个主控方People的对象，并set给从控方的IdCard对象；保存时只需要保存从控方的对象就行，一次保存2个对象。
				
				session.getTransaction().commit();
				
			}catch (Exception e) {
				session.getTransaction().rollback();
				e.printStackTrace();
	
			}finally{
				HibernateUtil.closeSession();
			}
		}

运行结果： 

Hibernate: select hibernate_sequence.nextval from dual
Hibernate: insert into SXBBKF.J_PEOPLE (NAME, AGE, SEX, ID) values (?, ?, ?, ?)
Hibernate: insert into SXBBKF.J_IDCARD (NUMCODE, ID) values (?, ?)

（3）删除

①删从控方

//删除 从控方 idcard
	public void testRemoveIdCard(){
		
		Session session=null;
		try{
			session=HibernateUtil.getSession();
			session.getTransaction().begin();
			
			/*People people=new People();
			people.setName("张三");
			people.setAge(20);
			people.setSex("M");*/
			
			//session.save(people);
			
			IdCard idcard=(IdCard)session.get(IdCard.class, new Long("48"));

			session.delete(idcard);
			
			session.getTransaction().commit();
			
		}catch (Exception e) {
			session.getTransaction().rollback();
			e.printStackTrace();

		}finally{
			HibernateUtil.closeSession();
		}
	}

运行结果： 

Hibernate: select idcard0_.ID as ID0_0_, idcard0_.NUMCODE as NUMCODE0_0_ from SXBBKF.J_IDCARD idcard0_ where idcard0_.ID=?
Hibernate: delete from SXBBKF.J_IDCARD where ID=?

显然，它只删除了从控方的对象，并没有自动关联删除主控方的对象


②删主控方

//删除 主控方 people
	public void testRemovepeople(){
		
		Session session=null;
		try{
			session=HibernateUtil.getSession();
			session.getTransaction().begin();
			People people=(People)session.get(People.class, new Long("49"));

			session.delete(people);
			
			session.getTransaction().commit();
			
		}catch (Exception e) {
			session.getTransaction().rollback();
			e.printStackTrace();

		}finally{
			HibernateUtil.closeSession();
		}
	}

运行结果： 
Hibernate: select people0_.ID as ID1_0_, people0_.NAME as NAME1_0_, people0_.AGE as AGE1_0_, people0_.SEX as SEX1_0_ from SXBBKF.J_PEOPLE people0_ where people0_.ID=?
Hibernate: delete from SXBBKF.J_PEOPLE where ID=?
org.hibernate.exception.ConstraintViolationException: Could not execute JDBC batch update

Caused by: java.sql.BatchUpdateException: ORA-02292: 违反完整约束条件 (SXBBKF.FK28F66C40613448E8) - 已找到子记录

很显然，直接删除主控方，被控方没有了外键约束关系，这是潍坊约束条件的，所以无法这样删除


③手动先删被控方，再删主控方

public void removeAll(){
		testRemoveIdCard();
		testRemovepeople();
	}

就是上面两个方法调用一起意思


运行结果：

Hibernate: select idcard0_.ID as ID0_0_, idcard0_.NUMCODE as NUMCODE0_0_ from SXBBKF.J_IDCARD idcard0_ where idcard0_.ID=?
Hibernate: delete from SXBBKF.J_IDCARD where ID=?
Hibernate: select people0_.ID as ID1_0_, people0_.NAME as NAME1_0_, people0_.AGE as AGE1_0_, people0_.SEX as SEX1_0_ from SXBBKF.J_PEOPLE people0_ where people0_.ID=?
Hibernate: delete from SXBBKF.J_PEOPLE where ID=?

这样必须四条语句了呀，没有疑问的


四、修改

//修改 从控方 idcard
	public void testModifyIdCard(){
		
		Session session=null;
		try{
			session=HibernateUtil.getSession();
			session.getTransaction().begin();
			
			IdCard idcard=(IdCard)session.get(IdCard.class, new Long("47"));
			
			idcard.setNumcode("3203203201010101");
			session.update(idcard);      //取出记录，重新赋值后update一下就行，没有关联约束关系
			
			session.getTransaction().commit();
			
		}catch (Exception e) {
			session.getTransaction().rollback();
			e.printStackTrace();

		}finally{
			HibernateUtil.closeSession();
		}
	}

运行结果： 

Hibernate: select idcard0_.ID as ID0_0_, idcard0_.NUMCODE as NUMCODE0_0_ from SXBBKF.J_IDCARD idcard0_ where idcard0_.ID=?
Hibernate: update SXBBKF.J_IDCARD set NUMCODE=? where ID=?


综上，单向主键一对一映射关系：从控方的实体类和hbm文件需要负责维护关系，主控方不用；constrained属性会影响save操作和删除操作：save是先主控后从控，delete是先从控后主控。


另：这篇博文用相反的思路，可以参考：http://blog.csdn.net/lsh6688/article/details/7583623









「已注销」
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Hibernate关系映射--单向一对一@OneToOne
路在路上的博客
08-23 991
1.无连接表的单向一对一 单向一对一与单向多对一很相似 需要在一的一方添加注解@OneToOne @JoinColumn（name=""，unique=true) 因为是一对一，所有要unique=true主要代码及例子 在一的一方添加注解@OneToOne(cascade={CascadeType.ALL}) @JoinColumn(name="",unique=true)
Hibernate一对一主键关联映射（单向关联）
03-05
总结来说，Hibernate中的一对一主键关联映射允许两个实体共享同一个主键，实现单向关联时只需在依赖方添加对另一方的引用。在实际应用中，应根据业务需求谨慎选择关联类型，以确保数据的完整性和一致性。
Hibernate -- 映射实体关联关系(一对一关联关系)
newbie00的博客
02-08 491
一对一关联关系中的两端实体为一一对应
Hibernate 一对一主键单向关联
yenairong的博客
02-22 139
Hibernate 一对一主键单向关联   1-1的关联可以基于主键关联，但基于主键关联的持久化类不能拥有自己的主键生成策略，它的主键由关联类负责生成。另外，另外，增加one-to-one元素来关联属性，必须为one-to-one元素增加constrained="true"属性，表明该类主键由关联类生成。     一、模型介绍   一个人（Person）对应一个地址（Address...
Hibernate关联关系之单向主键一对一
忽尔今夏丶的博客
10-31 191
1、创建项目 2、创建lib文件夹，导入相关jar包（Hibernate10个，MySQL 1个），然后buildpath 3、创建实体类User.java、Info.java（com.bean包下） User.java package com.bean; public class User { private int id; private String username; p
【Hibernate】Hibernate实体关系映射——主键相同的一对一关系
lmb55的专栏
06-20 2505
主键相同的一对一关系 由于两个实体类是一对一的关系，因此可设置两个实体类使用相同的主键。反过来，具有相同主键的实体被视为一对一的关系。这样两个表就省掉了外键关联。 以客户地址管理为例学习主键相同的一对一关系：一个客户对应一个地址，对应的实体之间使用相同的主键。 客户与地址之间是一对一的关系，并且两个实体的id是相同的。双方都有对方的引用。注意，两个数据库表之间没有关联关系，hibernate...
hibernate主键实现一对一单向关联关系源码
10-09
在Java的持久化框架Hibernate中，一对一（One-to-One）关联关系是常见的一种实体关系映射。本主题将深入探讨如何使用Hibernate通过主键来实现一对一的单向关联关系，并提供相关的源码分析。 首先，我们需要理解一对...
Hibernate教程06_关系映射之一对一单向主键关联
04-13
**标题详解：** "Hibernate教程06_关系映射之一对一单向主键关联" 在Hibernate框架中，关系映射是将数据库中的表关系映射到对象模型上的过程。本教程聚焦于一对一（One-to-One）单向主键关联，这是一种特定类型的...
java之hibernate之基于外键的一对一单向关联映射
weixin_30768661的博客
07-17 89
这篇讲解基于外键的一对一单向关联映射 1.考察如下信息，人和身份证之间是一个一对一的关系。表的设计 注意：基于外键的一对一关联的表结构和多对一的表结构是一致的，但是，外键是唯一的。 2.类的结构 Person.java public class Person implements Serializable{ private int id; priva...
hibernate一对一主键关联单向（一）
wzm112358的专栏
11-21 379
一对一主键单向引用 User 和car的一对一，car id主键引用user id作为外键。User实体可以访问card实体，但是反之不配置（单向）。   CREATE TABLE `card` (   `id` int(11)NOT NULL ,   `info`varchar(255) DEFAULT NULL,   PRIMARY KEY(`id`),   UNIQUE KEY
java框架篇---hibernate(一对一)映射关系
weixin_33885253的博客
04-12 104
对象-关系映射（Object/Relation Mapping，简称ORM），是随着面向对象的软件开发方法发展而产生的,是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术,本质上就是将数据从一种形式转换到另外一种形式。 面向对象的开发方法是当今企业级应用开发环境中的主流开发方法，关系数据库是企业级应用环境中永久存放数据的主流数据存储系统。对象和关系数据是业务实体的两种表现形式，业务实体...
java鬼混笔记：Hibernate：2、一对一关系之主键单向和双向关联
u013845177的博客
08-16 260
Hiberante 一对一主键关联 包含 单向和双向
Hibernate基于主键的一对一关系----单向双向
红桃峰峰 的博客
07-18 550
hibernate基于主键的一对一关系，有两种，单向和双向。基于主键的一对一关系指的是，两张表使用的是同一个id。 现在先说说单向 新建一个java项目，名称是：15hibernate_single_one_to_one_primary 结构如下： 需要的jar包和如何从hibernate上获得jar包，请参见《Hibernate环境搭建和配置》
Hibernate一对一关联关系介绍和简单demo
feng15230805625的博客
10-08 222
> 开头说两句： Hibernate一对一关系分为两种： 1.主键关联一对一映射：例如在两个表a,b中，一个字段在a表中是主键，a表中的该字段级联b表中的字段，该字段在b表中作为主键，也就是当a表中该字段修改时，b表中的字段随之改变;通过``元素配置， 2.唯一外键关联一对一映射：一对多关系的一种特例，主键表对应实体类的配置文件中通过one-to-one元素配置。 在这里我说一下第一种情况
数据关联关系之一(一对一)--Hibernate解决方案.
java心如止水
06-06 142
   大家在做开发的时候一定会用到表与表之间一对一的关系.   在学习数据的关联关系时候,请把容器映射看一看.不然不容易理解关联关系.   环境: Myeclispe+mysql. (1) 创建表 --刪除表drop table if exists email ;drop table if exists person ; --新建表create table person( id int not n...
hibernate的主控方与被控方
weixin_33860147的博客
05-22 504
2019独角兽企业重金招聘Python工程师标准>>> ...
Hibernate关系映射级别注解（一对一双向外键关联、一对一双向外键联合主键）
Gray的博客
10-18 506
一对一双向外键关联这个一对一双向外键关联要怎么理解，双方都持有对方的引用，也就是你中有我，我中有你。 以前一篇的例子来说，学生方持有身份证类的引用，身份证类也持有一个学生对象的引用，这两个引用都充当各自表中的外键。主控方的配置和一对一单向外键关联中的是一样的，不一样的地方是被控方。被控方的引用属性上边也要加上@OneToOne注解，其中要设置一下mappedBy属性，这个mappedBy属性指定了
hibernate之一对一双向关联
gaoyw的博客
05-06 227
wife类import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.Id; import javax.persistence.OneToOne; @Entity(name="wife1") public class Wife { pr
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值