`

hibernate关联关系-一对一

阅读更多

hibernate关联关系:一对一

 

模型:Person — IdCard

 

package Domain;

public class Person {
	
	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;
	}
	
	private int id;
	private String name;
	private IdCard idCard;
}

 

package Domain;

import java.util.Date;

public class IdCard {
	
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public Date getUsefulLife() {
		return usefulLife;
	}
	public void setUsefulLife(Date usefulLife) {
		this.usefulLife = usefulLife;
	}
	public Person getPerson() {
		return person;
	}
	public void setPerson(Person person) {
		this.person = person;
	}
	
	private int id;
	private Date usefulLife;
	private Person person;
}

 

 

<?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="Domain">

	<class name="Person" table="person">
		<id name="id">
			<generator class="native" />
		</id>
		<property name="name" />
		<one-to-one name="idCard"/>
	</class>
</hibernate-mapping>

 

<?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="Domain">

	<class name="IdCard" table="id_card">
		<id name="id">
			<generator class="foreign">
				<param name="property">person</param>
			</generator>
		</id>
		<property name="usefulLife" column="useful_Life"/>
		<one-to-one name="person" constrained="true"/>
	</class>
</hibernate-mapping>

 

package Dao.Test;

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

import Utils.hibernateUtil;
import Domain.Department;
import Domain.Employee;

public class One2ManyTest {
	public static void main(String[] args) {
		Department depart = add();
		queryDepart(depart.getId());
	}

	static Department queryDepart(int departId) {
		Session s = null;
		try {
			s = hibernateUtil.getSession();
			Department depart = (Department) s.get(Department.class, departId);
			System.out.println("emp  size: " + depart.getEmps().size());
			return depart;
		} finally {
			if (s != null)
				s.close();
		}
	}

	static Department add() {
		Session s = null;
		Transaction tx = null;
		try {
			Department depart = new Department();
			depart.setName("+Manager+");

			Employee emp1 = new Employee();
			emp1.setDepart(depart);// 对象模型:建立两个对象的关联
			emp1.setName("emp name1");
			
			Employee emp2 = new Employee();
			emp2.setDepart(depart);// 对象模型:建立两个对象的关联
			emp2.setName("emp name2");

			/*Set<Employee> emps = new HashSet<Employee>();
			emps.add(emp1);
			emps.add(emp2);
			depart.setEmps(emps);*/

			s = hibernateUtil.getSession();
			tx = s.beginTransaction();

			s.save(depart);
			s.save(emp1);
			s.save(emp2);
			System.out.println("-----------------------------------------");
			tx.commit();

			return depart;
		} finally {
			if (s != null)
				s.close();
		}
	}
}

 

package Dao.Test;

import java.util.Date;

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

import Utils.hibernateUtil;

import Domain.IdCard;
import Domain.Person;

public class One2OneQueryTest {
	public static void main(String[] args) {
		add();
		query(1);
	}
	
	static Person query(int id){
		Session s = null;
		Transaction tx = null;
		try{
			s = hibernateUtil.getSession();
			tx = s.beginTransaction();
			
			// 一对一 查询主对象
			// Person p = (Person)s.get(Person.class, id);
			// System.out.println( "p.getIdCard().getUsefulLife():" + p.getIdCard().getUsefulLife());
			
			// 一对一 查询从对象
			IdCard idCard = (IdCard)s.get(IdCard.class, id);
			System.out.println("idCard.getPerson().getName():" + idCard.getPerson().getName());
			
			tx.commit();
			//return p;
			return null;
		}finally{
			if(s != null){
				s.close();
			}
		}
	}
	
	
	static Person add(){
		Session s = null;
		Transaction tx = null;
		try{
			s = hibernateUtil.getSession();
			IdCard idCard = new IdCard();
			idCard.setUsefulLife(new Date());
			
			Person p = new Person();
			p.setName("Chen Huiyi");
			p.setIdCard(idCard);
			
			// 用Person对象来指定IdCard的id
			idCard.setPerson(p);
			
			tx = s.beginTransaction();
			s.save(p);
			s.save(idCard);
			tx.commit();
			return p;
		}finally{
			if(s != null){
				s.close();
			}
		}
	}	
}

  

 

分享到:
评论
1 楼 csdn_zuoqiang 2010-08-03  

根据从对象查询主对象时候,只产生一条查询语句~!!!

相关推荐

    hibernate-release-5.2.10

    7. **关联映射**:包括一对一(@OneToOne)、一对多(@OneToMany)、多对一(@ManyToOne)、多对多(@ManyToMany)关系的映射,方便处理对象间的关联关系。 8. **延迟加载**:Hibernate的懒加载策略可以在需要时才...

    hibernate-jpa-2.1-api-1.0.0.final.jar.zip

    其中,Hibernate作为一款功能强大的ORM框架,极大地简化了Java对象与数据库表之间的映射关系处理。而JPA(Java Persistence API)是Java EE规范的一部分,为ORM提供了标准的接口。`hibernate-jpa-2.1-api-1.0.0....

    hibernate一对一关联关系

    在实体类之间,Hibernate支持多种关联关系,包括一对一(One-to-One)、一对多(One-to-Many)和多对多(Many-to-Many)。本资源主要探讨的是“hibernate一对一关联关系”。 一对一关联关系在现实世界中很常见,...

    Hibernate ORM - 一对一连接表关联关系

    标题"Hibernate ORM - 一对一连接表关联关系" 提示我们,这里主要讨论的是Hibernate ORM框架在处理数据库中一对一(One-to-One)关联映射的方法。Hibernate是一个流行的Java对象关系映射(ORM)工具,它允许开发者用...

    hibernate-common-annotations.jar

    6. @OneToMany、@ManyToOne、@OneToOne、@ManyToMany:表示不同类型的关联关系,如一对一、一对多、多对多。 7. @JoinColumn:用于指定关联字段在表中的具体列名。 8. @Temporal:处理日期和时间类型的字段,如...

    hibernate-release-5.0.7.Final.zip

    Hibernate,作为Java领域中的一个强大的对象关系映射(ORM)框架,极大地简化了数据库操作,使得开发者可以使用面向对象的方式处理数据库事务。在2016年,传智播客黑马程序员发布的Hibernate教程中,特别选用了...

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

    本话题主要探讨的是Hibernate中的一种关联映射方式——一对一(One-to-One)单向外键关联。这种关联模式通常用于两个实体之间存在唯一对应的关系,例如一个用户对应一个唯一的账户。 在Hibernate中,一对一关联可以...

    hibernate-annotations-3.4.0.GA

    6. @ManyToOne、@OneToOne、@OneToMany、@ManyToMany:定义不同类型的关联关系,如一对一、一对多、多对多。 7. @JoinColumn:用于关联关系中指定外键字段的属性。 8. @Temporal:用于日期时间类型的字段,支持...

    hibernate-distribution-3.3.2.GA-dist

    7. **关联映射**:支持一对一、一对多、多对一和多对多等各种关联关系的映射,使得对象间的关联关系能够自然地反映到数据库中。 8. **延迟加载**:Hibernate的懒加载策略能有效减少数据库交互,只有在真正需要时才...

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

    在Hibernate中,一对一唯一外键关联映射是指两个实体之间的关联关系,其中一个实体作为外键,另一个实体作为关联目标。这种关联方式可以分为单向关联和双向关联两种。 单向关联是指一个实体作为外键,关联到另一个...

    最新 hibernate-release-4.2.13.Final.tgz

    2. 探索映射:深入理解实体类与数据库表之间的映射机制,包括一对一、一对多、多对一、多对多关系的配置。 3. 深入查询:掌握HQL和Criteria API的高级用法,如分页、排序、子查询等。 4. 事务管理:了解Hibernate的...

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

    在Hibernate中,一对一的主键关联关系可以通过以下几种方式配置: 1. **注解配置**: 使用`@OneToOne`注解来声明一对一关系,同时通过`@PrimaryKeyJoinColumn`注解指定共享的主键列。例如: ```java @Entity ...

    hibernate-release-5.3.2.Final

    Hibernate ORM,作为Java领域最著名的对象关系映射框架之一,自诞生以来就深受开发者喜爱。2018年7月5日,Hibernate发布了其最新版本——5.3.2.Final,带来了诸多改进和新特性,为开发者提供了更为高效、稳定的持久...

    hibernate源码release-4.1.4.Final版

    Hibernate的懒加载机制可以在需要时才加载关联的对象,避免了大量数据一次性加载导致的内存压力。但需注意防止“懒加载地狱”。 九、性能优化 包括但不限于:合理使用缓存,避免N+1查询问题,使用批处理更新,选择...

    hibernate-orm-3.3源码

    Hibernate,作为一个强大的对象关系映射(ORM)框架,一直以来都是Java开发者的重要工具。其3.3版本是 Hibernate 的一个重要里程碑,为开发者提供了丰富的功能和优化的性能。本文将针对《hibernate-orm-3.3源码》...

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

    **标题详解:**“Hibernate ORM - 一对一外键关联关系” 在Java开发中,Hibernate是一个非常流行的ORM(对象关系映射)框架,它允许开发者用面向对象的方式处理数据库操作,从而减少与SQL的直接交互。"一对一(One-...

    Hibernate one-to-many / many-to-one关系映射

    在Hibernate的hbm.xml文件中,一对一关系通过&lt;one-to-one&gt;标签,一对多关系通过、、或标签来定义。需要详细指定实体类名、主键列名以及关联的外键列名。 2. 注解配置: 在实体类上直接使用@OneToOne、@OneToMany等...

    hibernate-annotations-3.4.0.GA and hibernate-entitymanager-3.4.0.GA

    - `@ManyToOne`, `@OneToOne`: 用于表示一对一或一对多的关系,描述实体间的关联。 - `@OneToMany`, `@ManyToMany`: 描述多对一或多对多的关系,通常配合`@JoinTable`定义关联表。 - `@JoinColumn`: 定义外键字段...

    Hibernate ORM - 一对多双向关联关系

    标题“Hibernate ORM - 一对多双向关联关系”指的是在数据库建模中,Hibernate ORM(对象关系映射)框架如何处理一个实体类(如User)与多个实体类(如Article)之间的关系。在这种关系中,一个用户可以拥有多个文章...

    hibernate-orm-master.zip

    Hibernate支持多种关联映射,包括一对一(@OneToOne)、一对多(@OneToMany)、多对一(@ManyToOne)和多对多(@ManyToMany)。这些关联可以通过定义外键或使用中间表来实现,使得对象间的复杂关系得以轻松处理。 ...

Global site tag (gtag.js) - Google Analytics