`
JavaCrazyer
  • 浏览: 3011739 次
  • 性别: Icon_minigender_1
  • 来自: 河南
社区版块
存档分类

Hibernate温习(6)--单向一对一外键关联映射

阅读更多

hibernate一对一唯一外键关联映射(单向关联Citizen---->IDCard)

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

 基于外键关联的单向一对一关联和单向多对一关联几乎是一样的。唯一的不同就是单向一对一关联中的外键字段具有唯一性约束。只需要将原来的many-to-one元素增加unique="true"属性,用于表示N的一端也必须是唯一的,在N的一端增加了唯一的约束,即成为单向1-1。

 

具体做法

1. 单向一对一关联:对象模型和关系模型不匹配。

   对象模型上:主控方持有被控方实体类的引用。

   关系模型上:主控方对应表中添加一个外键引用自被控方的主键,这个外键必须添加唯一约束。


2. 在主控方的映射文件中:

  <many-to-one name="属性名" column="外键名" unique="true" [cascade="all"]/>


Citizen.java


package com.javacrazyer.domain;

public class Citizen {
	private Long id;
	private String name;
	private Boolean gender;
	
	//一对一关联中:主控方持有被控方的引用
	private IDCard idCard;

	public Long getId() {
		return id;
	}

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

	public String getName() {
		return name;
	}

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

	public Boolean getGender() {
		return gender;
	}

	public void setGender(Boolean gender) {
		this.gender = gender;
	}

	public IDCard getIdCard() {
		return idCard;
	}

	public void setIdCard(IDCard idCard) {
		this.idCard = idCard;
	}
	
	public String toString(){
		return "id=" + this.id + ",name=" + this.name + ",gender=" + this.gender;
	}
}


 IDCard.java


package com.javacrazyer.domain;

public class IDCard {
	private Long id;
	private String no;
	public Long getId() {
		return id;
	}
	public void setId(Long id) {
		this.id = id;
	}
	public String getNo() {
		return no;
	}
	public void setNo(String no) {
		this.no = no;
	}
	
	public String toString(){
		return "id=" + id + ",no=" + this.no;
	}
}


 Citizen.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>
	<class name="com.javacrazyer.domain.Citizen">
		<id name="id" column="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
        <property name="gender"/>
		
		<!-- 映射基于外键一对一关联 -->
		<many-to-one name="idCard" column="card_id" unique="true" cascade="all"/>
	</class>
</hibernate-mapping>


 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>
	<class name="com.javacrazyer.domain.IDCard" >
		<id name="id" column="id">
            <generator class="native"/>
        </id>
        <property name="no"/>
	</class>
</hibernate-mapping>


 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>
		<!-- 数据库连接参数配置 -->
		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="hibernate.connection.url">jdbc:mysql:///test</property>
		<property name="hibernate.connection.username">root</property>
		<property name="hibernate.connection.password">root</property>
		<!-- 数据库言的配置 -->
		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
		<property name="hibernate.show_sql">true</property>
		<property name="hibernate.format_sql">true</property>
		<property name="hibernate.hbm2ddl.auto">update</property>
		<!-- 声明实体关系映射文件 -->
		<mapping resource="com/javacrazyer/domain/IDCard.hbm.xml" />
		<mapping resource="com/javacrazyer/domain/Citizen.hbm.xml" />
	</session-factory>
</hibernate-configuration>


 启动下Hibernate,自动生成数据库表,数据库表的DDL语句如下

   idcard表



   create table `test`.`idcard`(
        `id` BIGINT not null auto_increment,
       `no` VARCHAR(255),
        primary key (`id`)
    );

    create unique index `PRIMARY` on `test`.`idcard`(`id`);

 

   citizen表

 

create table `test`.`citizen`(
        `id` BIGINT not null auto_increment,
       `name` VARCHAR(255),
       `gender` BIT,
       `card_id` BIGINT unique,
        primary key (`id`)
    );

    alter table `test`.`citizen`  
        add index `FK92029348E9FA33E0`(`card_id`), 
        add constraint `FK92029348E9FA33E0` 
        foreign key (`card_id`) 
        references `test`.`idcard`(`id`);
    create unique index `PRIMARY` on `test`.`citizen`(`id`);
    create unique index `card_id` on `test`.`citizen`(`card_id`);
    create index `FK92029348E9FA33E0` on `test`.`citizen`(`card_id`);

 



 

   

Hibernate辅助类

 

package com.javacrazyer.common;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

/**
 * Hibernate工具类
 * 
 */
public class HibernateUtil {
	private static final SessionFactory factory;
	
	private HibernateUtil(){}
	
	static{
		//加载Hibernate全局配置文件,根据配置信息创建SessionFactory工厂实例
		factory = new Configuration().configure().buildSessionFactory();
	}
	
	public static SessionFactory getSessionFactory(){
		return factory;
	}
}

 测试类

 

package com.javacrazyer.test;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

import com.javacrazyer.common.HibernateUtil;
import com.javacrazyer.domain.Citizen;
import com.javacrazyer.domain.IDCard;

public class MappingTest {
	private static SessionFactory sessionFactory;
	
	@BeforeClass
	public static void init(){
		sessionFactory = HibernateUtil.getSessionFactory();
	}
	
	@AfterClass
	public static void destroy(){
		sessionFactory = null;
	}
	
	@Test
	public void testSave(){
		Session session = sessionFactory.openSession();
		session.beginTransaction();
		
		IDCard ic = new IDCard();
		ic.setNo("xx0001");
		
		Citizen citizen = new Citizen();
		citizen.setName("赵C");
		
		//设置一对一的关联
		citizen.setIdCard(ic);
		
		session.save(citizen);
		
		session.getTransaction().commit();
		session.close();
	}
	
	@Test
	public void testGet(){
		Session session = sessionFactory.openSession();
		session.beginTransaction();
		
		Citizen c = (Citizen)session.get(Citizen.class, Long.valueOf(1));
		
		System.out.println(c.getName());
		
		IDCard idcard = c.getIdCard();
		
		System.out.println(idcard.getId());
		
		session.getTransaction().commit();
		session.close();
		
		System.out.println(idcard.getNo());
	}
	
}

 

 

  • 大小: 3.4 KB
分享到:
评论
2 楼 JavaCrazyer 2010-11-14  
Javakeith 写道
学框架  就看LZ的温习OK了! 谢谢LZ的分享!

1 楼 Javakeith 2010-11-14  
学框架  就看LZ的温习OK了! 谢谢LZ的分享!

相关推荐

    hibernate one-to-one 一对一唯一外键关联映射_单向 and 双向

    在本文中,我们将详细介绍Hibernate一对一唯一外键关联映射的概念、配置方法和实践应用。 一对一唯一外键关联映射的概念 在Hibernate中,一对一唯一外键关联映射是指两个实体之间的关联关系,其中一个实体作为外键...

    Hibernate关联映射-one to one单向外键关联

    在Hibernate中,一对一关联可以通过配置XML映射文件或者使用注解来实现。我们先来看XML映射文件的例子。假设我们有两个实体,一个是`User`,另一个是`Account`,`User`实体拥有对`Account`的引用。在`User.hbm.xml`...

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

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

    Hibernate教程04_关系映射之一对一单向外键关联

    **标题详解:**“Hibernate教程04_关系映射之一对一单向外键关联” 在Hibernate框架中,关系映射是数据库表之间的关联在对象模型中的体现。本教程重点讲解了一对一(One-to-One)单向外键关联的实现方法。在数据库...

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

    一、Hibernate一对一关联类型 一对一关联在现实世界中很常见,例如一个人只有一个身份证,一个身份证也只能属于一个人。在数据库设计中,这种关系通常通过主键和外键的方式实现,其中一方的主键作为另一方的外键,...

    Hibernate 一对一外键单向关联

    本篇文章将深入探讨Hibernate中的一对一外键单向关联。 首先,一对一外键关联指的是一个实体通过外键直接引用另一个实体的主键。在单向关联中,只有其中一个实体知道另一个实体的存在,而另一个实体则无感知。这种...

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

    在本案例中,我们将详细探讨“hibernate一对一唯一外键关联映射(单项关联)”。 首先,一对一关联分为两种类型:单向关联和双向关联。单向关联意味着在一个实体类中存在对另一实体的引用,而另一实体类中没有相应...

    hibernate一对一之唯一外键关联(双向关联)

    - 在一对一关联中,唯一外键关联是指在一个实体中定义了另一个实体的主键作为其字段,形成外键约束,确保了数据的一致性和完整性。 3. **双向关联与单向关联** - **单向关联**:只有一方知道另一方的存在,例如...

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

    本篇文章将深入探讨两种实现一对一关联的方式:主键关联(Primary Key Join)和唯一外键关联(ForeignKey Join),并结合源码和实际工具进行详细讲解。 一、主键关联(Primary Key Join) 1. 主键关联的概念: ...

    Hibernate ORM - 一对一外键关联关系

    1. **一对一外键关联配置**:在Hibernate中,可以通过在映射文件中添加`&lt;one-to-one&gt;`标签或在实体类上使用`@OneToOne`注解来定义一对一关联。关联的外键通常位于被引用的实体(“一对一”关系的“一”端)中。 2. ...

    详解Hibernate一对一映射配置

    这里,Person和Address类共享同一主键`PERSON_ID`,表明它们一对一关联。 2. **单方外键关联(Unidirectional Foreign Key Join)** 在单方外键关联中,一个实体通过外键字段引用另一个实体。配置如下: ```xml ...

    hibernate一对一之唯一外键关联(单向关联)

    在这个场景下,我们将讨论一种特殊的一对一关联方式——唯一外键关联(Single ForeignKey Association),且为单向关联。这种关联方式意味着在一个实体中有一个字段作为另一个实体的主键引用。 首先,我们需要理解...

    hibernate外键实现一对一单向关联关系源码

    **外键实现**:在一对一关联中,通常有以下两种方式实现外键: 1. **一方包含外键**:外键放在与另一方关联的一方实体中,指向另一方的主键。 2. **双方包含外键**:每个实体都有对方的外键,但实际应用中较少,因为...

    Hibernate基于外键的一对多单向关联

    “Hibernate基于外键的一对多单向关联”这个标题指的是在Java持久化框架Hibernate中,如何通过外键实现一个实体类(如订单)与另一个实体类(如商品)之间的一对多关系,并且这种关联是单向的,即从订单端可以访问到...

    Hibernate一对一单向外键关联 (联合主键annotation)

    在单向一对一关联中,只有一个实体知道另一个实体的存在,而另一个实体并不知情。这里我们讨论的是单向外键关联,即一方实体持有了另一方的外键。 在Hibernate中,一对一关联可以通过`@OneToOne`注解来实现。这个...

    Hibernate一对一外键映射

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

    hibernate一对一唯一外键关联映射(双向关联)

    在一对一关联中,如果使用唯一外键关联,那么一个实体的主键将作为另一实体的外键,同时这个外键在该实体内必须是唯一的。这可以通过在关联字段上使用`@OneToOne`注解并指定`@JoinColumn`来实现。 ### 3. 双向关联 ...

    Hibernate教程05_关系映射之一对一双向外键关联

    在Hibernate中,一对一关联的配置主要通过注解或XML配置文件完成。对于双向关联,我们需要在两个实体类中分别设置相应的属性和关联注解。 在实体类A中,我们将添加一个类型为B的属性,并使用`@OneToOne`注解来指定...

Global site tag (gtag.js) - Google Analytics