`

Hibernate一对一主键映射

阅读更多
IdCard的主键不是自增长,是用Person的Id作为主键同时作为外键,IdCard的主键随Person的Id的变化而改变,其实两个主键的值是相等的。
Person.java
package cn.itcast.hibernate.domain;

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
package cn.itcast.hibernate.domain;

import java.util.Date;

public class IdCard {
	private int id;
	private Date usefullife;
	private Person person;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}

	public Person getPerson() {
		return person;
	}
	public void setPerson(Person person) {
		this.person = person;
	}
	public Date getUsefullife() {
		return usefullife;
	}
	public void setUsefullife(Date usefullife) {
		this.usefullife = usefullife;
	}
	
}


JavaBean映射文件1(Person.hbm.xml)
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="cn.itcast.hibernate.domain">
	<class name="Person" table="person">
		<id name="id">
			<generator class="native" />
		</id>
		<property name="name" unique="true"/>
		<one-to-one name="idcard"/>
	</class>

</hibernate-mapping>


JavaBean映射文件2(IdCard.hbm.xml)
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="cn.itcast.hibernate.domain">
	<class name="IdCard" table="id_card">
		<id name="id">
			<generator class="foreign" >
				<!-- IdCard的id根据这个属性找到person的getId()获得id值 -->
				<param name="property">person</param>
			</generator>
		</id>
		<property name="usefullife" column="useful_life"/>
		<one-to-one name="person" constrained="true"/>
	</class>

</hibernate-mapping>


Hibernate配置文件(hibernate.cfg.xml)
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

	<session-factory>

		<!-- Database connection settings -->
		<property name="connection.driver_class">
			com.mysql.jdbc.Driver
		</property>
		<property name="connection.url">
			jdbc:mysql://localhost:3306/test
		</property>
		<property name="connection.username">root</property>
		<property name="connection.password">123456</property>

		<!-- JDBC connection pool (use the built-in) -->
		<property name="connection.pool_size">1</property>

		<!-- SQL dialect -->
		<property name="dialect">
			org.hibernate.dialect.MySQLDialect
		</property>

		<!-- Echo all executed SQL to stdout -->
		<property name="show_sql">true</property>

		<!-- Drop and re-create the database schema on startup如果没有表则自动创建 -->
		<property name="hbm2ddl.auto">create</property>

		
		<mapping resource="cn/itcast/hibernate/domain/Person.hbm.xml" />
		<mapping resource="cn/itcast/hibernate/domain/IdCard.hbm.xml" />
	</session-factory>

</hibernate-configuration>



One2One.java用来使用映射
package cn.itcast.hibernate;

import java.util.Date;
import java.util.HashSet;
import java.util.Set;

import org.hibernate.Session;
import org.hibernate.Transaction;

import cn.itcast.hibernate.domain.Department;
import cn.itcast.hibernate.domain.Employee;
import cn.itcast.hibernate.domain.IdCard;
import cn.itcast.hibernate.domain.Person;

public class One2One {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		add();
		queryPerson(1);
//		queryIdCard(1);
	}

	static Person queryPerson(int id){
		Session s= null;
		Transaction tx = null;
		try {
			s=HibernateUtil.getSession();
			tx= s.beginTransaction();
			Person person=(Person)s.get(Person.class, id);
			System.out.println(person.getIdcard().getUsefullife());
			tx.commit();
			return person;
		}finally{
			if(s!=null){
				s.close();
			}
		}
	}
	
	static IdCard queryIdCard(int id){
		Session s= null;
		Transaction tx = null;
		try {
			s=HibernateUtil.getSession();
			tx= s.beginTransaction();
			IdCard idCard=(IdCard)s.get(IdCard.class, id);
			System.out.println(idCard.getPerson().getName());
			tx.commit();
			return idCard;
		}finally{
			if(s!=null){
				s.close();
			}
		}
	}
	
	static Person add(){
		Session s= null;
		Transaction tx = null;
		try {
			s=HibernateUtil.getSession();
			tx= s.beginTransaction();
			
			IdCard idcard = new IdCard();
			idcard.setUsefullife(new Date());

			Person person = new Person();
			person.setName("personname1");
			person.setIdcard(idcard);
			
			idcard.setPerson(person);
			s.save(person);
			s.save(idcard);
			tx.commit();
			return person;
		}finally{
			if(s!=null){
				s.close();
			}
		}
	}
}

0
0
分享到:
评论

相关推荐

    Hibernate一对一主键关联映射(双向关联)

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

    hibernate 无主键表映射

    在Java的持久化框架Hibernate中,无主键表映射是一种特殊情况,主要处理那些在数据库中没有明确单一主键的表。这种情况通常出现在那些通过多个字段共同唯一标识一条记录的复合主键(Composite Key)场景。本文将详细...

    hibernate一对一主键关联映射(单项关联)

    本篇将深入探讨在Hibernate中实现一对一主键关联映射的单项关联方式。这种关联意味着两个实体类共享相同的主键,即一个实体类的一个实例对应另一个实体类的唯一实例。 首先,我们要明确一对一主键关联映射的基本...

    hibernate 双向一对一基于主键的关联映射

    在Java持久化框架Hibernate中,双向一对一(OneToOne)基于主键的关联映射是一种常见的对象关系映射(ORM)技术。这种映射方式允许两个实体类之间建立一对一的关联,且关联是通过主键来实现的。接下来,我们将深入...

    hibernate一对一主键关联映射(双项关联)

    在Java的持久化框架...总结来说,Hibernate的一对一主键关联映射,尤其是双向关联,能有效地简化对象关系的映射,提高代码的可读性和维护性。然而,需要根据实际情况权衡其带来的性能影响,确保系统设计的高效性。

    Hibernate一对一主键关联映射(单向关联)

    总结来说,Hibernate中的一对一主键关联映射允许两个实体共享同一个主键,实现单向关联时只需在依赖方添加对另一方的引用。在实际应用中,应根据业务需求谨慎选择关联类型,以确保数据的完整性和一致性。

    hibernate 主键一对一映射(单向) 实例(java类)

    通过以上步骤,我们就可以在Hibernate中实现单向一对一主键映射。这个实例中的`hibernate_fifth_one2one_pk_1`文件可能包含了相关的代码示例或测试用例,供你参考和学习。理解并掌握一对一映射是提高Hibernate使用...

    Hibernate Annotation 共享主键一对一双向关联

    本文将详细讲解“Hibernate Annotation 中的共享主键一对一双向关联”。 首先,我们需要理解什么是共享主键(Shared Primary Key)。在一对一的关联关系中,如果两个实体共享同一个主键,那么这种关联被称为共享...

    Hibernate注解映射联合主键

    在Hibernate中,有三种主要的注解方式来映射联合主键,以下是对这三种方式的详细解释: 1. **使用`@Embeddable`和`@Id`** 在这种映射方式中,联合主键的字段被放在一个单独的类中,这个类需要实现`java.io....

    hibernate使用主键关联的一对一关系

    总之,理解并正确实现Hibernate中的一对一主键关联对于优化数据模型和提高代码的可维护性至关重要。通过共享主键,我们可以确保数据的完整性和一致性,同时简化对象之间的交互。阅读提供的博客资源,结合本文的讲解...

    Hibernate教程07_关系映射之一对一双向主键关联

    在本教程中,我们将深入探讨Hibernate中的一个关键概念——关系映射,特别是“一对一双向主键关联”。这种关联类型是数据库设计中的常见模式,它允许两个实体类之间通过共享相同的主键来建立关联。在Java应用中,...

    Hibernate一对多主键关联映射源代码

    本教程通过源代码的形式,讲解如何在Hibernate中实现一对多主键关联映射,适用于初学者学习。 首先,我们需要理解一对多关联的基本概念。在数据库中,一个表的某一列(主键)可能与另一个表的多行相关联,比如一个...

    Hibernate 一对一关联映射(主键关联VS唯一外键关联)

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

    详解Hibernate一对一映射配置

    在Java持久化框架Hibernate中,一对一(One-to-One)映射是对象关系映射的一种常见方式,用于表示两个实体之间一对一的关系。这种关系通常出现在一个实体的实例只能与另一个实体的单个实例相关联的情况。下面我们将...

    hibernate主键一对一关联映射代码示例

    本示例将深入讲解如何在Hibernate中实现主键一对一关联映射,并通过代码示例进行解析。 一对一关联意味着在一个实体中,每个实例都唯一对应另一个实体的实例。这种关联可以通过共享主键(primary key)或外键...

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

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

    hibernate一对一主键关联代码实现

    本教程将详细解释如何通过代码实现Hibernate的一对一主键关联。 首先,我们需要理解一对一关联的含义:在数据库中,如果一个表的记录只能与另一个表的唯一一条记录对应,这就构成了主键关联的一对一关系。例如,一...

Global site tag (gtag.js) - Google Analytics