hibernate 对象的三种关系:
one – to – one : 身份证<--->人
one – to – many : 部门 <---> 员工
many-to-one : 员工<--->部门
many-to-many : 学生<--->老师
在实际开发中,如果出现了many-to-many关系,我们应该将其转换成两个one-to-many 或者 many-to-one,这个程序好控制,同时不会有冗余.
单向多对一(Employee - Department)
Employee映射文件
<many-to-one name=”dept” column=”dept_id”/>
class Department{
private Integer id;
private String name;
}
class Employee{
private Integer id;
private String name;
private Department dept;
}
添加一个部门,并给部门加入二个人
public static void add() {
//把对象模型-》关系模型
//当你获取一个session ,就会让hiberate去读取
//hibernate.cfg.xml,这就会加载对象映射文件,从而完成创建
Session session=null;
Transaction ts=null;
try {
session=HibernateUtil.getThreadLocalSession();
ts=session.beginTransaction();
//添加一个记录
Department d1=new Department();
d1.setName("财务部");
Employee e1=new Employee();
e1.setName("张三");
e1.setDepartment(d1);
Employee e2=new Employee();
e2.setName("邵阳");
e2.setDepartment(d1);
session.save(d1);
session.save(e1);
session.save(e2);
ts.commit();
} catch (Exception e) {
e.printStackTrace();
if(ts!=null){
ts.rollback();
}
// TODO: handle exception
}finally{
if(session!=null&&session.isOpen()){
session.close();
}
}
}
简述: 当我们查询一个对象的时候,在默认情况下,返回的只是该对象的普通属性,当用户去使用对象属性时,才会向数据库发出再一次的查询.这种现象我们称为 lazy现象
.
解决方法可以这样:
显示初始化 Hibernate.initized(代理对象)
修改对象关系文件 lazy 改写 lazy=false
通过过滤器(web项目) openSessionInView
双向一对多(Department-Employee)
Department映射文件添加
<set name=”集合对象属性名”>
<key column=”外键名”/>
<one-to-many class=”集合放入的类名”/>
</set>
class Department{
private Integer id;
private String name;
private Set<Employee> emps
}
一对一(Person - IdCard)
1)基于主键的one-to-one(IdCard的映射文件)
<id name=”id”>
<generator class=”foreign
”><param name=”property”>person</param></generator>
<id>
<one-to-one name=” person” constrained=”true”/>
[没有constraned true将不会生成外键约束]
Person映射文件: <one-to-one name=“idCard” />
class Person{
private Integer id;
private String name;
private IdCard idCard
}
class IdCard{
private Integer id;
private java.util.Date useful_life;
private Person person
}
**添加案例***
session =HibernateUtil.getThreadLocalSession();
ts=session.beginTransaction();
//添加一个Person Idcard
Person p1=new Person();p1.setName("孙悟空");
IdCard id1=new IdCard();
id1.setUseful_time(new java.util.Date());
//这句话就可以表示id1是p1这个人.
id1.setPerson(p1);
session.save(p1);//insert
session.save(id1);//insert
2)基于外健的one-to-one,可以描述为多对一,加unique=“true”约束,
IdCard的映射文件 中:
<many-to-one
name=”person” column=”person_id” unique=”true”
not-null=”true”/>
<!-唯一的多对一,其实就便成了一对一了就会在Idcard表生成外键-->
class Person{
private Integer id;
private String name;
private IdCard idCard;
}
class IdCard{
private Integer id;
private Date validate,
private Person person;
}
多对多(student - course)
在操作和性能方面都不太理想,所以多对多的映射使用较少,实际使用中最好转换成一对多的对象模型;Hibernate会为我们创建中间关联表,转换成两个一对多。
public class Student {
private Integer id;
private String name;
private Set<StuCourse> stuCourses;
}
public class StuCourse {
private Integer id;
private Student student;
private Course course;
private Integer grade;
}
public class Course {
private Integer id;
private String name;
private Set<StuCourse> stuCourses;
}
<class name="Student">
<id name="id" type="java.lang.Integer">
<generator class="sequence">
<param name="sequence">stu_seq</param>
</generator>
</id>
<property name="name" type="java.lang.String">
<column name="name" length="64"/>
</property>
<!-- 这里我们配置了one-to-many 一个学生可以对应多个选课记录 -->
<set name="stuCourses">
<key column="student_id"/>
<one-to-many class="StuCourse"/>
</set>
</class>
<class name="StuCourse" >
<id name="id" type="java.lang.Integer">
<generator class="sequence">
<param name="sequence">stucourse_seq</param>
</generator>
</id>
<property name="grade" type="java.lang.Integer">
<column name="grade" length="3"/>
</property>
<many-to-one name="course" column="course_id"/>
<many-to-one name="student" column="student_id"/>
</class>
<class name="Course">
<id name="id" type="java.lang.Integer">
<generator class="sequence">
<param name="sequence">course_seq</param>
</generator>
</id>
<property name="name" type="java.lang.String">
<column name="name" length="64"/>
</property>
<!-- 配置one-to-many 表示一门课程可以对应多个选课记录 -->
<set name="stuCourses">
<key column="course_id"/>
<one-to-many class="StuCourse"/>
</set>
</class>
分享到:
相关推荐
以下是Hibernate对象的三种主要状态及其特点: 1) 临时状态(Transient State): 当通过`new`关键字创建一个新的对象时,该对象处于临时状态。在这个状态下,对象并未与任何Session关联,因此它的变化不会自动反映...
本文主要介绍了对象之间的对应关系,包含对象之间一对一,一对多双向,多对多的关系,另外简单介绍了二级缓存和分页
在Java的持久化框架Hibernate中,对象存在三种不同的状态,分别是持久态(Persistent)、自由态(Transient)和游离态(Detached)。这三种状态分别对应了对象与数据库的关联程度,理解它们对于高效地使用Hibernate...
- **双向关联**(标准关联):两个实体对象之间相互引用,如同远房亲戚互相认识。在Java代码中,这通常通过在两个类中设置相互的引用属性来实现,如`Wo`和`MeiNv`的例子。 - **单向关联**:仅有一方对象持有另一方...
**Hibernate对象关系详解** 在Java世界中,Hibernate作为一款强大的对象关系映射(ORM)框架,使得开发者可以方便地在Java对象与数据库表之间进行数据操作。本篇将深入探讨Hibernate中的对象关系映射,包括一对一...
“对应关系有一对一,多对一,多对多”则提示我们将深入学习这三种常见的数据库关联关系在Hibernate中的实现方式。 **Hibernate ORM详解** Hibernate是Java平台上的一个开源ORM框架,它通过提供数据持久化服务,...
以上就是关于Hibernate对象三状态以及OneToOne、OneToMany和ManyToMany关系映射的详细讲解,希望对你理解Hibernate的工作原理和实践有所帮助。在实际开发中,根据业务需求灵活运用这些关系映射,能够有效地管理和...
**hibernate对象关系映射案例demo** 在Java开发领域,对象关系映射(ORM)是一种将数据库中的数据与程序中的对象进行关联的技术,它极大地简化了数据操作。Hibernate作为一款流行的ORM框架,使得开发者无需关注底层...
在Java开发中,Hibernate是一个强大的对象关系映射(ORM)框架,它简化了数据库与Java对象之间的交互。本篇将详细讲解如何使用Hibernate来操纵持久化对象,这对于深入理解Hibernate的核心概念至关重要。 **一、...
《Java精通Hibernate对象持久化技术权威指南》是一本深度探讨Java开发中如何高效地使用Hibernate进行对象持久化的专业书籍。本书旨在帮助Java开发者熟练掌握Hibernate框架,实现数据库操作的简化和自动化,提升软件...
Hibernate对象有三种状态:瞬时状态(Transient)、持久状态(Persistent)和脱管状态(Detached)。理解这些状态对于优化数据操作和避免潜在的问题至关重要。 首先,瞬时状态(Transient)是指通过new关键字创建的...
2. **对象状态**:Hibernate管理的对象具有三种状态:瞬时态(Transient)、持久态(Persistent)和脱管态(Detached),它们的状态转换由Hibernate的Session负责。 3. **JMX集成**:允许通过JMX(Java Management ...
首先,我们来看一下Hibernate中持久化对象的三种基本状态: 1. **瞬时对象(Transient Objects)**: - 当使用`new`关键字创建一个新的Java对象时,该对象是瞬时的。这意味着它们与数据库没有任何关联。如果对象...
Hibernate作为一种强大的ORM(对象关系映射)框架,极大地简化了Java应用与数据库之间的交互。它通过将Java类映射到数据库表,实现了对象持久化,使得开发者可以像操作普通Java对象一样处理数据库中的数据,从而降低...
Hibernate通过将对象模型与关系数据库模型之间的映射进行自动化处理,极大地简化了数据访问层(DAO)的实现,让开发者可以专注于业务逻辑,而非底层的数据库操作。 Hibernate是什么? Hibernate是一个基于JDBC的ORM...
#### 三、JPA与Hibernate的关系 JPA和Hibernate之间存在着紧密的联系: 1. **标准与实现**:JPA是一种标准,而Hibernate是一种实现了这一标准的框架。这意味着任何符合JPA规范的应用都可以无缝地与Hibernate集成。...
6. **实体生命周期管理**:Hibernate自动管理对象的状态,包括瞬态、持久化、托管和脱管四种状态,以及它们之间的转换。 7. **多对一、一对多、多对多关系映射**:Hibernate支持复杂的关联关系映射,如单向关联、...