Hibernate 关系映射、多向关联
新建部门类
private int deptId;
private String deptName;
private Set emps = new HashSet(); //部门包含员工集合
新建员工类
private int empId;
private String empName;
private int empAge;
private Dept dept; //部门对象
新建Dept.hbm.xml
<class name="com.tfsoft.two.Dept">
<id name="deptId">
<generator></generator>
</id>
<property name="deptName" length="10"></property>
<!-- 一对多 -->
<set name="emps" inverse="true"><!-- 集合中使用，表示由对方维护主外键关系 -->
<key column="deptFk" not-null="true"></key>
<one-to-many class="com.tfsoft.two.Employee"/>
</set>
</class>
inverse=“false”是默认的值。
inverse只对集合起作用，也就是只对one-to-many或many-to-many有效（因 为只有这两种关联关系包含集合，而one-to-one和many-to-one只含有关系对方的一个引用）。
<one-to-many>中，建议inverse=”true”，由“many”方来进行关联关系的维护
<many-to-many>中，只设置其中一方inverse=”false”，或双方都不设置
新建Employee.hbm.xml
<class name="com.tfsoft.two.Employee">
<id name="empId">
<generator></generator>
</id>
<property name="empName" length="10"></property>
<property name="empAge"></property>
<!-- 多对一 -->
<!-- cascade默认属性，unsaved-value默认为Null -->
<many-to-one name="dept" class="com.tfsoft.two.Dept" lazy="false">
<column name="deptFk" not-null="true"></column><!-- 映射到数据库中的名称和设置 -->
</many-to-one>
</class>
新建测试类
public class Two {
private static Configuration cf = null;
private static SessionFactory sf = null;
static{
cf = new Configuration().configure();
sf = cf.buildSessionFactory();
}
//新增部门
public void saveOrUpdateDept(Dept dept){
Session session = sf.openSession();
Transaction ts = session.beginTransaction();
session.saveOrUpdate(dept);
ts.commit();
session.close();
}
//通过部门主键获取对象
public Dept getDeptById(int deptId){
Session session = sf.openSession();
Dept dept = (Dept)session.get(Dept.class, deptId);
session.close();
return dept;
}
//新增员工
public void saveOrUpdateEmp(Employee emp){
Session session = sf.openSession();
Transaction ts = session.beginTransaction();
session.saveOrUpdate(emp);
ts.commit();
session.close();
}
//通过员工主键获取对象
public Employee getEmpById(int empId){
Session session = sf.openSession();
Employee emp = (Employee)session.get(Employee.class, empId);
session.close();
return emp;
}
public static void main(String[] args) {
Two two = new Two();
/* Dept dept = new Dept(); 新增部门
dept.setDeptName("人事部");
two.saveOrUpdateDept(dept);*/
/* Employee emp = new Employee(); 新增员工，同时获取部门，添加到部门里面
emp.setEmpAge(20);
emp.setEmpName("张三");
Dept dept = two.getDeptById(1);
emp.setDept(dept);
two.saveOrUpdateEmp(emp);*/
/* Employee emp = two.getEmpById(1); 通过Id获取员工
System.out.println(emp.getEmpId()+"::"+emp.getEmpName());
Dept dept = emp.getDept(); 获取员工所在的部门
System.out.println(dept.getDeptId());
System.out.println(dept.getDeptName());*/ lazy="false"时，可以获取部门的名称，为true只能获取id
Dept dept = two.getDeptById(1); 通过Id 获取部门
System.out.println(dept.getDeptName());
Set emps = dept.getEmps(); 通过部门查询员工集合
Iterator it = emps.iterator(); 迭代器循环打印
while(it.hasNext()){
Employee emp = (Employee)it.next();
System.out.println(emp.getEmpName());
}
}
}
一对一
新建身份证类
private int CarId;
private String CarNum;
private Person person;
新建人类
private int perId;
private String perName;
新建Card.hbm.xml文件
<class name="com.hou.onetoone.Card" table="card">
<id name="carId" column="carId">
<generator></generator>
</id>
<property name="carNum" column="carNum" type="string" length="18"></property>
<one-to-one name="person" class="com.hou.onetoone.Person"
constrained="true">
</one-to-one>
</class>
constrained只能在one-to-one的映射中使用，（一般在主表的映射中，有外键的那个表）。如果constrained=true，则表明存在外键与关联表对应，并且关联表中肯定存在对应的键与其对应， 另外该选项最关键的是影响save和delete的先后顺序。例如增加的时候，如果constainted=true,则会先增加关联表，然后增加本表。删除的时候反之
one-to-one的单向关联中，如果constrained=false，则会在查询时就全部取出来，用left outer join的方式。如果constrained=true，hibernate即会延迟加载sql，只把本表的查出来，等有用到关联表的再发sql取。
one-to-one的双向关联中，必须设置constrained=true，要不然会有重复数据。
新建Person.hbm.xml文件
<class name="com.hou.onetoone.Card" table="card">
<id name="carId" column="carId">
<generator></generator>
</id>
<property name="carNum" column="carNum" type="string" length="18"></property>
<one-to-one name="person" class="com.hou.onetoone.Person"
constrained="true">
</one-to-one>
</class>
新建测试类
public class Onetoone {
private static Configuration cf = null;
private static SessionFactory sf = null;
static{
cf = new Configuration().configure();
sf = cf.buildSessionFactory();
}
//新增人
public void saveOrUpdatePerson(Person per){
Session session=sf.openSession();
Transaction ts=session.beginTransaction();
session.saveOrUpdate(per);
ts.commit();
session.close();
}
//新增身份证
public void saveOrUpdateCard(Card car){
Session session=sf.openSession();
Transaction ts=session.beginTransaction();
session.saveOrUpdate(car);
ts.commit();
session.close();
}
//通过Id获取人
public Person getPerById(int perId){
Session session=sf.openSession();
Transaction ts=session.beginTransaction();
Person per=(Person)session.get(Person.class, perId);
ts.commit();
session.close();
return per;
//通过Id获取身份证
}public Card getCarById(int CarId){
Session session=sf.openSession();
Transaction ts=session.beginTransaction();
Card car=(Card)session.get(Card.class, CarId);
ts.commit();
session.close();
return car;
}
public static void main(String[] args) {
Onetoone oto=new Onetoone();
Person per=new Person();/* 新增人
per.setPerName("侯强强");
oto.saveOrUpdatePerson(per);*/
/* Card car=new Card(); 获取人添加进身份证
car.setCarNum("12345678912");
car.setPerson(oto.getPerById(1));
oto.saveOrUpdateCard(car);*/
/* Card car=oto.getCarById(1); 获取Id
car.setCarNum("111"); 修改身份证号码
car.setCarId(1);
oto.saveOrUpdateCard(car);*/
Card car=oto.getCarById(1); 通过Id 获取对象
System.out.println(car.getPerson().getPerName()); 打印身份证对应的人的姓名，添加lazy=”false”
Constrained=”false”时，数据库外键不显示，查询时通过左连接查询出姓名
}
}
转载于:https://my.oschina.net/u/2353689/blog/476079
发表评论
相关推荐
hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,包含4个说明文档，分别详细解说了hibernate关联映射的关联关系，...
在Java的持久化框架Hibernate中，多对多关联映射是一种常见的关系数据库模型映射方式，用于处理两个实体之间存在多个实例互相关联的情况。本文将深入探讨Hibernate如何实现多对多关联映射，并通过实际例子解析相关...
本主题将深入探讨Hibernate集合映射与关联关系，包括"student与Score的Map集合关系"、"student与class的多对一"以及"一对多映射"的概念。 首先，让我们理解一下Hibernate中的集合映射。在关系型数据库中，一个实体...
### Hibernate映射一对多关联关系 #### 知识点概览 - **概念解析**：一对多（One-to-Many）关联关系的概念及其在Hibernate中的实现方式。 - **域模型设计**：创建具有一个实体与多个实体关联的域模型。 - **关系...
在这种映射关系中，我们只在一端维护关联关系。比如，在`Person`类中添加`IdCard`对象的引用，但`IdCard`类不持有`Person`对象的引用。这意味着我们只能从`Person`对象访问到对应的`IdCard`信息，而不能反向操作。...
本文将深入探讨“hibernate关联映射实例”中的关键知识点，包括一对多、多对多和继承映射，这些都是Hibernate中至关重要的概念。 1. **一对多关联映射**： 在现实世界中，一个实体可能会与多个其他实体相关联，...
Hibernate4中映射关系图解。
综上所述，Hibernate提供了丰富的关联关系映射机制，包括一对一、一对多和多对多关联，每种关联又可以细分为单向和双向，以及基于主键和基于外键的不同实现方式。正确理解和选择合适的关联关系对于构建高效、可维护...
在Java的持久化框架Hibernate中，多对多关联映射是一种常见的关系模型，它用于处理两个实体类之间存在多个对应关系的情况。这篇博客"hibernate多对多关联映射（单项关联）"深入探讨了如何在Hibernate中实现这种映射...
本文旨在深入探讨Hibernate中的实体关联关系映射技术，主要包括一对一、一对多、多对多等不同类型的关联关系及其在实际开发中的应用技巧。通过本文的学习，开发者可以更好地理解和掌握Hibernate框架下的实体关联关系...
"多对一"关系映射是Hibernate支持的四种基本关联类型之一，包括一对一、一对多、多对一和多对多。本篇将深入探讨“多对一”关系映射的概念、配置以及在实际web系统中的应用。 **一、“多对一”关系映射概念** 在...
Hibernate_关联关系映射配置详解，希望能帮助广大java爱好者
其中，“关联映射”是Hibernate中的一个重要概念，用于处理实体之间的关联关系，例如一对一、一对多、多对一以及多对多等。 #### 常用属性解析 为了更好地理解和运用Hibernate中的关联映射机制，我们需要深入了解...
然而，需要注意的是，由于这种关联是双向的，所以在处理关联关系时，要特别注意同步两个方向的引用，避免出现数据不一致的情况。 在实际开发中，我们可能还会遇到一些问题，比如懒加载（Lazy Loading）、EAGER加载...
5. Hibernate 一对多连接表单向关联： 类似于一对一的连接表关联，这里也是通过额外的连接表实现一对多关系。连接表会包含两个外键，一个指向父实体，另一个指向子实体。映射配置中，需要创建连接表实体，并使用 `...
【hibernate的关联关系映射】在Java持久化框架Hibernate中，关联关系映射是核心功能之一，它允许对象间的复杂关系与数据库中的表结构相匹配。在选课系统这个例子中，主要涉及到的对象包括课题(Course)、教师(Teacher...
在Java的持久化框架Hibernate中，一对多关联映射是一种常见的关系映射方式，它用于表示一个实体（如用户）可以拥有多个关联实体（如订单）。在这个场景中，"一"通常代表父实体，"多"代表子实体。这篇博客文章...
本资料包主要关注的是Hibernate中的关系映射，特别是多对多（ManyToMany）关系，这对于理解和实现复杂的数据库模型至关重要。在Spring+Hibernate+Struts框架下，这种映射关系的应用更是常见。 首先，我们需要了解在...
"hibernate关联关系映射"是Hibernate的核心概念之一，它定义了如何在Java对象和数据库表之间建立关系。以下是对这个主题的详细讲解： 一、一对一关系映射（One-to-One） 一对一关系是指一个实体对应另一个实体的...