Hibernate一对多的数据关联
2009年03月02日 评论(0)|浏览(29) 点击查看原文
(2)一对多的关联(重点)
一个部门有多个雇员:
.部门表
.雇员表
create table dept
(
deptno int identity(1,1) primary key,
dname varchar(20) not null,
loc varchar(20) not null
)
create table emp
(
empno int identity(1,1) primary key,
deptno int,
ename varchar(20) not null,
saly float not null,
hirdate datetime,
foreign key(deptno) references dept(deptno)
)
建立POJO类之间的关系
Dept.java:
import java.util.*;
public class Dept {
private int id;
private String dname;
private String loc;
//一对多集合,与此Dept类对应的所有的Emp类全部放在Set集合中
private Set emp=new HashSet(0);
public Set getEmp() {
return emp;
}
public void setEmp(Set emp) {
this.emp = emp;
}
public String getDname() {
return dname;
}
public void setDname(String dname) {
this.dname = dname;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getLoc() {
return loc;
}
public void setLoc(String loc) {
this.loc = loc;
}
}
Emp.java:
import java.util.Date;
public class Emp {
private int id;
private String ename;
private float saly;
private Date hirdate;
//dept表示此Emp类关联的Dept类
private Dept dept;
public Dept getDept() {
return dept;
}
public void setDept(Dept dept) {
this.dept = dept;
}
public String getEname() {
return ename;
}
public void setEname(String ename) {
this.ename = ename;
}
public Date getHirdate() {
return hirdate;
}
public void setHirdate(Date hirdate) {
this.hirdate = hirdate;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public float getSaly() {
return saly;
}
public void setSaly(float saly) {
this.saly = saly;
}
}
配置映射文件:
Dept.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="emp.Dept" table="dept" catalog="myshop" schema="dbo">
<id name="id" type="java.lang.Integer">
<column name="deptno"></column>
<generator class="native"></generator>
</id>
<property name="dname" type="java.lang.String">
<column name="dname" length="20" not-null="true"/>
</property>
<property name="loc" type="java.lang.String">
<column name="loc" length="20" not-null="true"></column>
</property>
<!-- 配置set集合,name表示Dept类中的属性名称 -->
<!-- inverse 表示Emp类是否有主动权,为true表示没有主动权 -->
<!-- cascade 表示两个表的关联性 -->
<!-- lazy 表示是否延迟加载,为true表示延迟加载 -->
<set name="emp" inverse="true" cascade="all" lazy="true">
<key column="deptno" not-null="true"></key>
<one-to-many class="emp.Emp"/>
</set>
</class>
</hibernate-mapping>
Emp.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="emp.Emp" table="emp" catalog="myshop" schema="dbo">
<id name="id" type="java.lang.Integer">
<column name="empno"></column>
<generator class="native"></generator>
</id>
<property name="ename" type="java.lang.String">
<column name="ename" length="20" not-null="true"></column>
</property>
<property name="saly" type="java.lang.Float">
<column name="saly" not-null="true"/>
</property>
<property name="hirdate" type="java.util.Date">
<column name="hirdate" not-null="false"></column>
</property>
<many-to-one name="dept" class="emp.Dept" fetch="select">
<column name="deptno" not-null="true"></column>
</many-to-one>
</class>
</hibernate-mapping>
测试类:
import java.util.*;
import org.hibernate.*;
import org.hibernate.cfg.Configuration;
public class Test {
private SessionFactory sessionFactory;
private Session session;
public Test()
{
sessionFactory=new Configuration().configure().buildSessionFactory();
session=sessionFactory.openSession();
}
public void doCreate()
{
Dept p=new Dept();
p.setDname("销售部");
p.setLoc("很好");
//创建两个与Dept相关联的类e,e1
Emp e=new Emp();
e.setEname("张三");
e.setSaly(1000.0f);
e.setHirdate(new Date());
Emp e2=new Emp();
e2.setEname("李四");
e2.setSaly(2000.0f);
e2.setHirdate(new Date());
//把两个Emp 对象添加到Set集合中
p.getEmp().add(e);
p.getEmp().add(e2);
//Emp类也要设置关联
e.setDept(p);
e2.setDept(p);
//保存Dept类同时,也会保存与Dept相关联的Emp类e,e1
session.save(p);
session.beginTransaction().commit();
session.close();
}
public void find2()
{
Dept d=(Dept)session.get(Dept.class, new Integer(1));
System.out.println(d.getDname());
System.out.println(d.getLoc());
}
public void find1()
{
String hql="FROM Dept d";
Query q=session.createQuery(hql);
Dept d=(Dept)q.uniqueResult();
Set<Emp> emp=d.getEmp();
Iterator<Emp> it=emp.iterator();
while(it.hasNext())
{
Emp e=it.next();
System.out.println(e.getEname());
System.out.println(e.getHirdate());
System.out.println(e.getSaly());
}
}
public void find3()
{
String hql="FROM Emp e WHERE e.dept.id=1";
Query q=session.createQuery(hql);
List emp=q.list();
for(int i=0;i<emp.size();i++)
{
Emp e=(Emp)emp.get(i);
System.out.println(e.getEname()+" "+e.getSaly());
}
}
public static void main(String[] args) {
//new Test().doCreate();
new Test().find1();
}
}
分享到:
相关推荐
### Hibernate映射一对多关联关系 #### 知识点概览 - **概念解析**:一对多(One-to-Many)关联关系的概念及其在Hibernate中的实现方式。 - **域模型设计**:创建具有一个实体与多个实体关联的域模型。 - **关系...
“Hibernate 一对多,多对一,一对多双向关联”是指在Java持久化框架Hibernate中,实体间常见的三种关联关系。在数据库设计中,这种关联关系是常见的,例如一个用户可以有多个订单(一对多),一个订单对应一个用户...
在Java的持久化框架Hibernate中,双向一对多关联映射是一种常见的关系映射方式,它模拟了数据库中的外键关联,使得一个实体可以拥有多个另一个实体的实例。在这个注解版的实现中,我们将深入探讨如何使用Hibernate的...
在Java的持久化框架Hibernate中,多对多关联映射是一种常见的关系数据库模型映射方式,用于处理两个实体之间存在多个实例互相关联的情况。本文将深入探讨Hibernate如何实现多对多关联映射,并通过实际例子解析相关...
10. **最佳实践**:如避免过多的中间表查询,合理设计关联关系,以及在不必要时选择一对一或一对多替代多对多等。 总结来说,理解并能正确使用Hibernate中的多对多双向关联是Java开发中的重要技能,涉及到实体设计...
这个压缩包文件“HibernateORM”很可能包含了关于如何在实际项目中设置和使用Hibernate一对多双向关联的示例代码、配置文件或者详细教程。通过学习这些材料,开发者能够深入理解如何在Java应用中利用Hibernate来处理...
本主题聚焦于“Hibernate双向一对一关联映射”的注解实现,这是一种高级的数据库设计模式,用于处理两个实体之间一对一的关系。 在Hibernate中,一对一关联映射分为单向和双向。单向一对一映射通常涉及一个实体持有...
总结一下,Hibernate的一对多关联映射通过注解方式定义了对象间的关联关系,使得我们在编程时能够以面向对象的方式操作数据,而底层数据库的操作则由Hibernate自动完成。这种方式大大提高了开发效率,同时也降低了...
这篇博客文章“hibernate一对多关联映射(单向关联)”将深入讲解如何配置和使用这种映射关系。 在单向关联中,只有一个实体知道另一个实体的存在,也就是说,只有父实体("一"的一端)有对子实体("多"的一端)的...
在实体类之间,Hibernate支持多种关联关系,包括一对一(One-to-One)、一对多(One-to-Many)和多对多(Many-to-Many)。本资源主要探讨的是“hibernate一对一关联关系”。 一对一关联关系在现实世界中很常见,...
标题"Hibernate一对一主键关联映射(双向关联)"中的"主键关联"指的是两个实体通过共享相同的主键来建立关联。"双向关联"则意味着在两个实体类中,都可以直接访问到对方的实例,即在实体A中有一个对实体B的引用,...
标题 "Hibernate基于连接表的一对多单向关联" 涉及的是数据库对象关系映射(ORM)框架Hibernate中的一个重要概念。在Java开发中,Hibernate是广泛使用的工具,它允许开发者将Java类与数据库表进行映射,简化了数据...
本实例将深入探讨Hibernate中的三种基本关联关系:一对一(One-to-One)、一对多(One-to-Many)以及多对多(Many-to-Many)的实现方式。 1. **一对一关联**: 一对一关联通常出现在两个实体之间存在唯一对应关系...
在Java的持久化框架Hibernate中,一对多关系(OneToMany)是一种常见的对象关系映射(ORM)映射方式,它模拟了数据库中一个表的一条记录与另一表的多条记录之间的关联。本教程通过源代码的形式,讲解如何在Hibernate...
在这个“Hibernate一对多双向自身关联demo代码”中,我们将深入理解如何实现一个实体类与其自身进行一对多的双向关联。这种关联在实际应用中常见于例如用户的朋友关系、员工的上下级关系等场景。 首先,让我们了解...
在实现基于外键的一对多双向关联时,理解注解的含义和作用至关重要,同时还需要考虑性能优化和潜在的问题,确保数据的正确性和一致性。通过阅读源码和实践,我们可以更深入地掌握Hibernate的内在机制。
**标题:“Hibernate一对多单向关联映射”** 在Java持久化框架Hibernate中,一对多关系是常见的数据关联模式,它表示一个实体可以与多个其他实体相关联。在这个主题中,我们将深入探讨如何在Hibernate中实现一对多...
在Java的持久化框架Hibernate中,多对多关联映射是一种常见的关系模型,它用于处理两个实体类之间存在多个对应关系的情况。这篇博客"hibernate多对多关联映射(单项关联)"深入探讨了如何在Hibernate中实现这种映射...
本文将详细解析" Hibernate一对多关联实例 ",并涵盖关联的保存(save)、删除(delete)、查询(select)和更新(update)操作。 一、一对多关联概念 在数据库设计中,一对多关联表示一个表中的记录可以与另一个表中的多个...