Hibernate_8_Person和IdCard实例_一对一关系:基于外键

1)建立Person类:

public class Person {

	private Integer id;
	private String name;
	private IdCard IdCard;

	public String getName() {
		return name;
	}

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

	public Integer getId() {
		return id;
	}

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

	public IdCard getIdCard() {
		return IdCard;
	}

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

	@Override
	public String toString() {
		return "Person [id=" + id + ",name=" + name + "]";
	}
}

2)建立IdCard类:

	public class IdCard {

	private Integer id;
	private String number;
	private Person person;

	public Integer getId() {
		return id;
	}

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

	public String getNumber() {
		return number;
	}

	public void setNumber(String number) {
		this.number = number;
	}

	public Person getPerson() {
		return person;
	}

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

	@Override
	public String toString() {
		return "IdCard [id=" + id + ",number=" + number + "]";
	}
}

3)建立持久化类:

public class perAndIdDao {
	/**
	 * save方法
	 */
	@Test
	public void testSave() {
		Session session = SessionFactoryTools.getSession();
		Transaction tx = null;
		try {
			tx = session.beginTransaction();

			// ===============================================

			// 新建两个Person对象
			Person person1 = new Person();
			person1.setName("张三");
			Person person2 = new Person();
			person2.setName("李四");

			// 新建两个IdCard对象
			IdCard idCard1 = new IdCard();
			idCard1.setNumber("37292501");
			IdCard idCard2 = new IdCard();
			idCard2.setNumber("37292502");

			// 加入关联对象
			person1.setIdCard(idCard1);
			person2.setIdCard(idCard2);
			idCard1.setPerson(person1);
			idCard2.setPerson(person2);

			// 保存
			session.save(person1);
			session.save(person2);
			session.save(idCard1);
			session.save(idCard2);

			// ===============================================
			tx.commit();
		} catch (RuntimeException e) {
			if (tx != null) {
				tx.rollback();
			}
			throw e;
		} finally {
			session.close();
		}

	}

	/**
	 * getById方法
	 */
	@Test
	public void testGetById() {
		Session session = SessionFactoryTools.getSession();
		Transaction tx = null;
		try {
			tx = session.beginTransaction();

			// ===============================================

			// 获取person队象并打印改队象的信息和相关联的idCard信息
			Person person = (Person) session.get(Person.class, 1);
			System.out.println(person + ":");
			System.out.println(person.getIdCard());

			// 获取idCard对象并打印改队象的信息和相关联的person信息
			IdCard idCard = (IdCard) session.get(IdCard.class, 2);
			System.out.println(idCard + ":");
			System.out.println(idCard.getPerson());

			// ===============================================
			tx.commit();
		} catch (RuntimeException e) {
			if (tx != null) {
				tx.rollback();
			}
			throw e;
		} finally {
			session.close();
		}

	}

	/**
	 * 解除关联关系的方法
	 */
	@Test
	public void testRemoveRelation() {
		Session session = SessionFactoryTools.getSession();
		Transaction tx = null;
		try {
			tx = session.beginTransaction();

			// ===============================================

			/**
			 * 获取person对象并将其关联的IdCard设置为空 在多对一中,
			 * 因为一方不具有外键管理权。所以解除外键关联是不能实现的
			 * Person person = (Person) session.get(Person.class, 1);
			 * person.setIdCard(null);
			 */

			/**
			 * 获取idCard对象并将其相关联的person设置为空 在多对一中,
			 * 因为多方具有外键的管理权限,所以该外键的解除是能够实现的
			 */
			IdCard idCard = (IdCard) session.get(IdCard.class, 1);
			idCard.setPerson(null);

			// ===============================================
			tx.commit();
		} catch (RuntimeException e) {
			if (tx != null) {
				tx.rollback();
			}
			throw e;
		} finally {
			session.close();
		}
	}

	/**
	 * 删除队象的方法
	 */
	@Test
	public void testDelete() {
		Session session = SessionFactoryTools.getSession();
		Transaction tx = null;
		try {
			tx = session.beginTransaction();

			// ===============================================

			/**
			 * 获取person对象并删除该对象
			 * 在多对一中。因为一方不具有外键的管理权限。
  	 			所以删除该对象是不可能实现的
			 * Person person = (Person) session.get(Person.class, 1);
			 * session.delete(person);
			 */

			/**
			 * 获取idCard对象并删除该对象
			 * 在多对一中。因为多方具有外键爱你的管理权限,
                         * 所以删除该对象是能够实现的
			 */
			IdCard idCard = (IdCard) session.get(IdCard.class, 1);
			session.delete(idCard);

			// ===============================================
			tx.commit();
		} catch (RuntimeException e) {
			if (tx != null) {
				tx.rollback();
			}
			throw e;
		} finally {
			session.close();
		}
	}
}

4)Person.hbm.xml的配置:

<?

xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="map_3">
	<!--类名:Person
		类相应的表名:person
		一对一相应类:IdCard
		一对一相应的表:idCard
		一对一所相应的外键的属性名:person
	-->
	<class name="Person" table="person">

		<id name="id" type="int" column="id">
			<generator class="native" />
		</id>
		<property name="name" type="string" column="name" length="20" />

	<one-to-one name="idCard" class="IdCard" property-ref="person">
</one-to-one>

	</class>
</hibernate-mapping>

5)IdCard.hbm.xml的配置:

<?

xml version="1.0"?

>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="map_3">
	<!--类名:IdCard
		类相应的表名:idCard
		多对一相应类的表名:person
		多对一相应的类名:Person
		多对一相应的列名:personId
		设置为一对一关系:unique="true"
	-->
	<class name="IdCard" table="idCard">

		<id name="id" type="int" column="id">
			<generator class="native" />
		</id>
		<property name="number" type="string" column="number" />
<many-to-one name="person" class="Person" column="personId" 		unique="true">
</many-to-one>

	</class>
</hibernate-mapping>

6) 主文件的配置:

<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
	<session-factory name="foo">

		<!-- 配置数据库信息 -->
		<property name="hibernate.dialect">
org.hibernate.dialect.MySQLDialect
</property>
		<property name="connection.url">
jdbc:mysql:///hibernate0
</property>
		<property name="connection.driver_class">
com.mysql.jdbc.Driver
</property>
		<property name="connection.username">root</property>
		<property name="hibernate.connection.password">root</property>

		<!-- 其它配置 -->
		<property name="hibernate.show_sql">false</property>
		<property name="hibernate.format_sql">false</property>
		<property name="hbm2ddl.auto">update</property>

		<!-- 映射文件配置 -->
		<mapping resource="map_3/Person.hbm.xml" />
		<mapping resource="map_3/IdCard.hbm.xml" />

	</session-factory>
</hibernate-configuration>
时间: 2024-11-10 16:32:15

Hibernate_8_Person和IdCard实例_一对一关系:基于外键的相关文章

Entity Framework - 基于外键关联的单向一对一关系

代码的世界,原以为世界关系很简单,确道是关系无处不在.NET世界里ORM框架中EntityFramework作为其中翘楚,大大解放了搬砖工作的重复工作,着实提高了不少生产力,而也碰到过不少问题!比如关系的映射! 一对一关系的映射: 用户账户密码信息表:包含用户名 密码 邮箱等账户登录时的信息 public class SystemAccount { public SystemAccount() { Id = DateUtils.GeneratedNewGuid(); } public Guid

Hibernate关系映射(二) 基于外键的双向一对一

基于外键的双向一对一关联映射 需要在一端添加<one-to-one>标签,用property-ref来指定反向属性引用. 还是通过刚才用户和地址来演示双向一对一关联. 代码演示 一.实体类 Account.cs,需要添加被控端的引用 package com.lxit.entity; import java.io.Serializable; public class Account implements Serializable{ public Account(){ } private int

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

1. 人和身份证是一个一对一的关系,他们的表结构为: 2. 类结构:Person.java public class Person { private int id; private String name; private int age; private IdCard idCard; public Person() { } public Person(String name, int age) { super(); this.name = name; this.age = age; } pu

hibernate 之 关联映射的基于外键的单向一对一映射

1. 人和身份证是一个一对一的关系,他们的表结构为: 2. 类结构:IdCard.java : public class IdCard { private String id; private String address; public IdCard() { } public IdCard(String id, String address) { super(); this.id = id; this.address = address; } public String getId() { r

java之hibernate之基于外键的双向一对一关联映射

这篇讲解 基于外键的双向一对一关联映射 1.考察如下信息,人和身份证之间是一个一对一的关系.表的设计 2.类结构 Person.java public class Person implements Serializable{ private int id; private String name; private IdCard idCard; public Person() { } public Person(String name) { super(); this.name = name;

数据库多表关系(外键)

数据库多表关系(外键) 字段操作 create table tf1( id int primary key auto_increment, x int, y int ); # 修改 alter table tf1 modify x char(4) default ''; alter table tf1 change y m char(4) default ''; # 增加 mysql>: alter table 表名 add 字段名 类型[(长度) 约束]; # 末尾 eg>: alter t

2019.09.24学习整理 数据库的字段操作、多表关系、外键

目录 字段操作 多表关系 外键 一对一 无级联关系 有级联关系 一对多 多对多 数据库的字段操作.多表关系.外键 字段操作 create table tf1( id int primary key auto_increment, x int, y int ); #修改 alter table tf1 modify x char(4) default ''; alter table tf1 change y m char(4) default ''; #增加 mysql>: alter table

注解:【基于外键的】Hibernate单向1-&gt;1关联

Person与Address关联:单向1->1,[基于外键的] Person.java package org.crazyit.app.domain; import javax.persistence.CascadeType;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Generati

Hibernate(八):基于外键映射的1-1关联关系

背景: 一个部门只有一个一把手,这在程序开发中就会设计数据映射应该设置为一对一关联. 在hibernate代码开发中,实现这个业务有两种方案: 1)基于外键映射的1-1关联: 2)基于主键映射的1-1关联. 本篇文章主要是用来学习如何使用外键实现1-1关联关系. 新建项目hibernate05 新建java project,引入依赖包,在src下添加hibernate.cfg.xml 1 <?xml version="1.0" encoding="UTF-8"