一对一唯一外键关联映射

最新推荐文章于 2019-01-17 00:03:11 发布
最新推荐文章于 2019-01-17 00:03:11 发布
阅读量115 收藏
点赞数
分类专栏： Hibernate 文章标签： Hibernate junit XML
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iteye_3043/article/details/82037941
版权
hibernate一对一唯一外键关联映射（单向关联Person---->IdCard）(是多对一的特例，只是限制了多的一端)

一对唯一外键关联映射是多对一关联映射的特例

可以采用<many-to-one>标签，指定多的一端的unique=true，这样就限制了多的一端的多重性为一
通过这种手段映射一对一唯一外键关联 
// annotation映射
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;

@Entity
public class Husband {
	private int id;
	private String name;
	private Wife wife;

	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}

	@Column(length = 10)
	public String getName() {
		return name;
	}

	@OneToOne // 注解映射OneToOne
	@JoinColumn(name = "wifeId")// JoinColumn连接字段，修改关联列名
	public Wife getWife() {
		return wife;
	}

	public void setId(int id) {
		this.id = id;
	}

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

	public void setWife(Wife wife) {
		this.wife = wife;
	}
}


import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class Wife {
	private int id;
	private String name;

	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	@Column(length = 10)
	public String getName() {
		return name;
	}

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


public class StuIdCard {
	private int id;
	private String num;
	private Student student; // 单向指向Student

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getNum() {
		return num;
	}

	public void setNum(String num) {
		this.num = num;
	}

	public Student getStudent() {
		return student;
	}

	public void setStudent(Student student) {
		this.student = student;
	}
}


public class Student {

	private int id;
	private String name;

	private int age;
	private String sex;
	private boolean good;

	public boolean isGood() {
		return good;
	}

	public void setGood(boolean good) {
		this.good = good;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}
}
public class Person {

	private int id;

	private String name;

	private IdCard idCard; 

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

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

	public IdCard getIdCard() {
		return idCard;
	}

	public void setIdCard(IdCard idCard) {
		this.idCard = idCard;
	}
}


public class IdCard {

	private int id;

	private String cardNo;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getCardNo() {
		return cardNo;
	}

	public void setCardNo(String cardNo) {
		this.cardNo = cardNo;
	}
}
// annotation one2one_uni_fk_composite
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinColumns;
import javax.persistence.OneToOne;

@Entity
public class Husband {
	private int id;
	private String name;
	private Wife wife;
	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}

	public String getName() {
		return name;
	}
	@OneToOne
	@JoinColumns(
		{
			@JoinColumn(name="wifeId", referencedColumnName="id"),
			@JoinColumn(name="wifeName", referencedColumnName="name")
		}
	)
	public Wife getWife() {
		return wife;
	}
	public void setId(int id) {
		this.id = id;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void setWife(Wife wife) {
		this.wife = wife;
	}

}


import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.IdClass;

@Entity
@IdClass(WifePK.class)
public class Wife {
	private int id;
	private String name;
	private int age;

	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Id
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	@Id
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

}


import java.io.Serializable;

@SuppressWarnings("serial")
public class WifePK implements Serializable {
	private int id;
	private String name;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}
//IdCard.hbm.xml
<hibernate-mapping>
	<class name="com.bjsxt.hibernate.IdCard" table="t_idcard">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="cardNo"/>
	</class>
</hibernate-mapping>


//Person.hbm.xml
<hibernate-mapping>
	<class name="com.bjsxt.hibernate.Person" table="t_person">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
		<many-to-one name="idCard" unique="true"/>
		<!-- many-to-one标签会在多的一端加入一属性指向一的一端 -->
	</class>
</hibernate-mapping>

import org.hibernate.Session;

import junit.framework.TestCase;

public class One2OneTest extends TestCase {

	public void testSave1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			IdCard idCard = new IdCard();
			idCard.setCardNo("88888888888888");

			Person person = new Person();
			person.setName("菜10");
			person.setIdCard(idCard);

			//不能成功保存，因为IdCard是Transient状态
			session.save(person);

			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}		

	public void testSave2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			IdCard idCard = new IdCard();
			idCard.setCardNo("88888888888888");
			session.save(idCard);

			Person person = new Person();
			person.setName("菜10");
			person.setIdCard(idCard);

			session.save(person);

			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}			
	public void testLoad1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			Person person = (Person)session.load(Person.class, 2);
			System.out.println("person.name=" + person.getName());
			System.out.println("idCard.cardNo=" + person.getIdCard().getCardNo());
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}		
}
hibernate一对一唯一外键关联映射（双向关联Person<---->IdCard）

一对一唯一外键关联双向，需要在另一端（idcard），添加<one-to-one>标签，指示hibernate如何加载
其关联对象，默认根据主键加载person，外键关联映射中，因为两个实体采用的是person的外键维护的关系，
所以不能指定主键加载person，而要根据person的外键加载，所以采用如下映射方式： 
<one-to-one name="person" property-ref="idCard"/>

public class IdCard {

	private int id;

	private String cardNo;

	private Person person;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getCardNo() {
		return cardNo;
	}

	public void setCardNo(String cardNo) {
		this.cardNo = cardNo;
	}

	public Person getPerson() {
		return person;
	}

	public void setPerson(Person person) {
		this.person = person;
	}
}


public class Person {

	private int id;

	private String name;

	private IdCard idCard; 

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

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

	public IdCard getIdCard() {
		return idCard;
	}

	public void setIdCard(IdCard idCard) {
		this.idCard = idCard;
	}
}
//IdCard.hbm.xml
<hibernate-mapping>
	<class name="com.bjsxt.hibernate.IdCard" table="t_idcard">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="cardNo"/>
		<one-to-one name="person" property-ref="idCard"/>
		<!-- one-to-one与数据库无关，只是告诉hibernate怎样加载，many-to-one会在数据库中加字段 -->
		<!-- property-ref指定与哪一字段比较 -->
	</class>
</hibernate-mapping>


//Person.hbm.xml
<hibernate-mapping>
	<class name="com.bjsxt.hibernate.Person" table="t_person">
		<id name="id">
			<generator class="native"/>
		</id>
		<property name="name"/>
		<many-to-one name="idCard" unique="true"/>
	</class>
</hibernate-mapping>
import org.hibernate.Session;

import junit.framework.TestCase;

public class One2OneTest extends TestCase {

	public void testSave1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			IdCard idCard = new IdCard();
			idCard.setCardNo("88888888888888");

			Person person = new Person();
			person.setName("菜10");
			person.setIdCard(idCard);

			//不能成功保存，因为IdCard是Transient状态
			session.save(person);

			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}		

	public void testSave2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			IdCard idCard = new IdCard();
			idCard.setCardNo("88888888888888");
			session.save(idCard);

			Person person = new Person();
			person.setName("菜10");
			person.setIdCard(idCard);

			session.save(person);

			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}			
	public void testLoad1() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			Person person = (Person)session.load(Person.class, 2);
			System.out.println("person.name=" + person.getName());
			System.out.println("idCard.cardNo=" + person.getIdCard().getCardNo());
			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}		

	public void testLoad2() {
		Session session = null;
		try {
			session = HibernateUtils.getSession();
			session.beginTransaction();

			IdCard idCard = (IdCard)session.load(IdCard.class, 1);
			System.out.println("idcard.cardNo=" + idCard.getCardNo());
			System.out.println("idcard.person.name=" + idCard.getPerson().getName());

			session.getTransaction().commit();
		}catch(Exception e) {
			e.printStackTrace();
			session.getTransaction().rollback();
		}finally {
			HibernateUtils.closeSession(session);
		}
	}		
}
iteye_3043
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一对一单向关联映射
11-18 697
映射原理         两个实体对象之间是一对一的关联映射，即一个对象只能与另外唯一的一个对象相对应。例如：一个人(Person)只有一张身份证(IdCard)。我们看一下这个例子的对象模型，如下图所示：   对象模型                   从上图中可以看出：         1、一个人只有一张身份证，唯一的一个身份证号，对象之间是一
单向一对一唯一外键关联实例
黄爱岗廊坊师范学院信息技术提高班 第七期
07-19 6304
IdCard.java类 public class IdCard { private int id; private String cardNo; public int getId() { return id; } public void setId(int id) { this.id = id; } public String getCardNo() {
hibernate 注解方式一对一 基于外键的形式
杨恒的博客
07-28 2606
个人理解 : 基于外键的形式就是多对一的形式, 然后对外键进行唯一性约束 @Entity @Table(name = "annotation_person") public class AnnotationPerson implements java.io.Serializable { /** * */ private static final long seri
双向一对一唯一外键关联
yjsuge的专栏
07-25 1706
hibernate一对一唯一外键关联映射（双向关联PersonIdCard）原理跟单向一对一唯一外键关联是一样的,都是加个外键,影响的只是对象模型一对一唯一外键关联双向采用标签映射，必须指定标签中的property-ref属性为关系字段的名称对象模型如下:public class
Hibernate一对一唯一外键关联映射（单向关联）
03-06
唯一外键关联映射时，外键字段在数据库中设置为主键约束，确保每个值都是唯一的，这样就能保证一对一的关系。 ### 2. 创建实体类 假设我们有两个实体类，`Person` 和 `IdCard`，其中 `Person` 拥有一个 `IdCard` ...
Hibernate一对一唯一外键关联映射（双向关联）
03-05
总结，通过上述步骤，我们可以使用Hibernate的`@OneToOne`注解实现一对一唯一外键关联映射，并实现双向关联。在实际项目中，应根据业务需求选择合适的级联操作和关联维护方式，以确保数据的完整性和一致性。
hibernate一对一唯一外键关联映射（单项关联）
03-01
在本案例中，我们将详细探讨“hibernate一对一唯一外键关联映射（单项关联）”。 首先，一对一关联分为两种类型：单向关联和双向关联。单向关联意味着在一个实体类中存在对另一实体的引用，而另一实体类中没有相应...
mysql | left join 出现的结果会重复的问题
Willian的博客屋
03-30 1万+
简单说明问题出现的原因： MySQL left join 语句格式为： A LEFT JOIN B ON 条件表达式 left join 是以A表为基础，A表即左表，B表即右表。 左表(A)的记录会全部显示，而右表(B)只会显示符合条件表达式的记录，如果在右表(B)中没有符合条件的记录，则记录不足的地方为NULL。 使用left join， A表与B表所显示的记录数为 1:1 或 1:...
【Hibernate】一对一唯一外键关联映射
Dream it Possible
09-10 1141
【回顾】     在上篇博客中学习的是通过主键进行实体间一对一关系的映射，但其不易扩展，一般采用的方法是本篇博客中学习的内容，即：唯一外键关联映射。 【一对一唯一外键关联】     1. 原理配置：一对一唯一外键关联映射其实是多对一的特例。采用标签来映射。     2. 实体类代码：与单向主键关联一致，此处略。     3. 实体配置映射文件： Person.hbm.xml
一对一唯一外键关联映射(单向)
yenairong的博客
02-02 422
 一对唯一外键关联映射是采用多对一关联映射方法来解决一对一的问题，它就是多对一的一个特例。        它是基于这样一种思想：在映射多的一端时采用&lt;many-to-one&gt;标签，并且用属性unique=true来限定它是唯一的，这样就实现了多的一端的多重性为一。但是，它仍保留多対一的痕迹(比如关系模型中增加一个外键字段)。   1.实体模型：       此处单向...
mysql使用left join连接出现重复记录
Fighter168的专栏
03-20 2万+
问题描述 在使用连接查询的时候，例如以A表为主表，左连接B表，我们期望的是A表有多少条记录，查询结果就有多少条记录，但是可能会出现这样的结果，就是查询出来的记录总条数，多余A表的记录总条数，并且是查询的结果显示出来时有部分列是重复的，简单的说，就是产生了笛卡尔积。 问题示例 其中A表是用户表（user），字段分别是： ID name userid 1 aaaa ...
剪不断，理不乱——数据库中主外键的关系
java开发指南博客 【转载】
08-18 447
在做机房收费系统时，考虑到了主外键，所以学习了一下，下面我们一起来探究一下它们的关系。 主键Primary key，唯一标示一个实体。是保证数据库的实体完整性，保证数据中数据的正确性和合理性，取值非空唯一。 外键Foreign，是用来使表与表之间联系。用来保证数据库的参照完整性，外键的取值必须来自参照表参照列的值，可以为空也可不为空。 外键的作用： 保持数据一致性，完整性，主...
一对一关系的外键方法选择
jhkj_5154的博客
02-28 3253
belongsTo方法对应的是hasOne一对一是有主从关系的，并非平等关系如果A关于B时在A中是belongsTo，那么在B中就是hasOne一个表本身包含外键，我们需要调用需要用belongsTo，否则用hasOne（外键在另一张表里）...
MySQL：多表操作---外键+操作关联表+连接查询+子查询
热门推荐
张彦峰的博客
01-17 82万+
MySQL：多表操作---外键+操作关联表+连接查询+子查询
唯一外键 关联关系映射
weixin_33877092的博客
06-05 82
2019独角兽企业重金招聘Python工程师标准>>> ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值