1.many-to-one

以学生和部门之间的关系为例:

Department.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 package="com.xidian.domain">
<class name="Department" lazy="false">
<!-- 配置主键属性 -->
<id name="id" type="java.lang.Integer">
<!-- 生成策略 -->
<generator class="identity">
</generator>
</id>
<property name="name" type="java.lang.String">
<column name="name" length="64" not-null="true"/>
</property>
</class>
</hibernate-mapping>

student.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 package="com.xidian.domain">
<class name="Student">
<id name="id" type="java.lang.Integer">
<generator class="identity">
</generator>
</id>
<property name="name" type="java.lang.String">
<column name="name" length="64"/>
</property>
<!-- 对于private Department dept;就不能使用property
column="dept_id" 表示将来自动生成的表的外键名-->
<many-to-one name="dept" column="dept_id"/>
</class>
</hibernate-mapping>

应用:

Student stu1=new Student();
stu.setName("宋江");

Student stu2=new Student();
stu.setName("宋江");

Department d=new Department();
d.setName("财务部");

stu1.setDept(d);//指定该学生是哪个部门

stu2.setDept(d);

s.save(d);
s.save(stu1);
s.save(stu2);
如果先保存学生再保存部门,也是可以的。在保存学生的时候部门还不存在,外键会设置为空,然后再保存部门,当commit提交事务的

时候发现它们具有映射关系,就会再来设置学生的外键引用(这种情况下hibernate会多一条update语句)。

在应用多对一的情况时会发现,只做了many到one单方向的映射,只是能将多个学生通过外键关系添加到一个部门中

问题:反过来如果需要通过一个部门号(1),来获取该部门的所有学生?如果用上面的many to one形式需要hql语句进行查询:

String hql=”from Student where dept.id=1”

这时就需要one-to-many的反方向查询

在这里引入懒加载的概念:

简述: 多表查询时,当我们查询一个对象的时候,在默认情况下,返回的只是该对象的普通属性,当用户去使用对象属性时,

才会向数据库发出再一次的查询.这种现象我们称为 lazy现象.

student=(Student) s.get(Student.class, 3);

System.out.println(student1.getName()+" 所在部门="
      +student1.getDept().getName());//当session还在,依然可以向数据库发sql语句。可是假若我们只是获取到student对象,

                   //没有对对象属性进行查询,当session关闭后就不可以再向数据库发sql语句,无法查询。

解决方法

1.显示初始化代理对象 Hibernate.initized( student.getdept())

2.修改对象关系文件 class属性 lazy  改写 lazy=false

3.通过过滤器(web项目) openSessionInView     (从上面的例子可以看出,当session关闭后,就不能向数据库发sql语句,那么就扩大session的范围

                    这个后面会详细介绍)

2.one-to-many

在one那一方配置<set ></set>

在many一方必须要一个外键指向one这方的属性,所以配置<many-to-one>是必须的。

而one这方是否配置<one-to-many>看是否需要指定一个集合属性指向回many一方,这样从主表一方获取从表的属性是非常方便的。

在这里再看通过获取到部门查看学生信息

Department department1=(Department) s.get(Department.class, 3);
//取出该部门的学生
Set<Student> stus= department1.getStus();
for(Student ss: stus){
System.out.println(ss.getName());

}

添加学生
Department department=new Department();
department.setName("业务部门");

Student stu1=new Student();
stu1.setName("顺平");
Student stu2=new Student();
stu2.setName("小明");

Set<Student> sets=new HashSet<Student>();
sets.add(stu1);
sets.add(stu2);
department.setStus(sets);

s.save(department);              //这里涉及到级联操作,需要在Department.hbml.xml中配置

               //<set name="stus" cascade="save-update">这样将在保存department的时候将

               //部门中的学生一并保存。

3.one-to-one

一对一有有两种方式  区别是基于主键的情况是会在主键之间形成映射关系

(从表的某一属性既是自身表的主键也是引用到其他表的外键,主键充当外键),基于外键是以非主键的外键形成映射关系。

(1) 基于主键的一对一

一定要设置constrained=true 才能形成外键约束关系

一对一关系中典型的问题是人与身份证的关系。

Person p1=new Person();
p1.setId(1224);
p1.setName("xkj");

IdCard idCard=new IdCard();
idCard.setValidateDte(new Date());

idCard.setPerson(p1);//表示idCard对象是属于p1这个对象.
           //p1.setIdCard(idCard);错误方式
s.save(p1);     //先保存人
s.save(idCard);

数据库中结果:

idCard表

person表

这里有两个注意问题

1.如果我使用p1.setIdCard(idCard)来指定person和idCard之间的关系会出错:

只能使用idCard.setPerson(p1)方式。关系应该是在idCard上有一个外键指向person,而不是相反。报错行在

说明在保存idCard的时候,外键person属性是空而导致错误。

2.如果调换保存顺序:

s.save(idCard); //先保存卡

s.save(p1);  

报出错误:

java.sql.SQLException: [Microsoft][SQLServer 2000 Driver for JDBC][SQLServer]

INSERT 语句与 FOREIGN KEY 约束"FKB8CDF6CB2A59F864"冲突。该冲突发生于数据库"test",表"dbo.person", column 'id'。  
解析理论:外键约束,比如B表存在一个字段b,有外键约束,引用于A表的主键a,那么在向B表插入数据时,

字段b必须为A表中a已经存在的值,如过向b中存放一个a中没有的值,则会报违反外键约束。

可是如果回头看one-to-many那个例子中却发现学生表中有外键指向部门的主键,先保存学生再保存部门也是可以的,

只是会多一个update语句,这是hibernate的优化机制。可是放在这个地方却不可以,why?

希望大家指点填坑!

(二)基于外键的一对一

只改动上面的IdCard.hbm.xml映射文件

<id name=”id” type=”java.lang.Integer”>

<generator class=”assigned” />

</id>

<property ame=”VaidateDate” type=”java.util.Date”>

<column name=”validateDate” />

</property>

<many-to-one  name=”person”  unique=”true” />   //person是外键 在idCard表中会生成这个外键,它指向的是主表的主键id

在idCard这边,可看成是many-to-one的一个特例,加unique保证唯一。

Person p1=new Person();
p1.setId(122);
p1.setName("xkj");

IdCard idCard=new IdCard();
idCard.setId(1905);
idCard.setValidateDte(new Date());

idCard.setPerson(p1);//表示idCard对象是属于p1这个对象.

s.save(p1); //先保存人
s.save(idCard);

数据库结果:

在这里我依然测试了前面出现的两个问题:

第一个问题没有报错,只是idCard的person外键为空。

第二个问题hibernate又给解决了,同样是多一句update语句。

4.many-to-many

学生和课程是经典的多对多的案例。

在实际开发中,如果出现了many-to-many关系,我们应该将其转换成两个one-to-many 或者 many-to-on, 这个程序好控制,同时不会有冗余。

在stucourse中有两个外键分别指向student和course

//添加一个学生,一门课程,选课
Student stu1=new Student();
stu1.setName("小明");

Course course=new Course();
course.setName("java");

StuCourse sc=new StuCourse();

sc.setCourse(course);
sc.setStudent(stu1);

//顺序保存.
s.save(stu1);
s.save(course);
s.save(sc);

数据库结果:

Hibernate(七)__多对一 、一对多、 一对一、多对多的更多相关文章

  1. Hibernate关联关系配置(一对多,一对一,多对多)

    一对多 创建两个类  Manager(一这一端) Worker(多这一端)  即一个经理下有多个员工 package com.hibernate.n21; import java.util.HashS ...

  2. 【转】hibernate映射(单向双向的一对多、多对一以及一对一、多对一)

    多对一关联映射:在多的一端加入一个外键指向一的一端,它维护的关系是多指向一 一对多关联映射:在多的一端加入一个外键指向一的一端,它维护的关系是一指向多 也就是说一对多和多对一的映射策略是一样的,只是站 ...

  3. Hibernate框架--关联映射,一对多,多对多 inverse cascade

    回顾Hibernate: 1. hibernate开发环境搭建 ----> 引入jar: hibernate.jar + required + jpa + 驱动包 ---> hiberna ...

  4. 2.2、Hibernate用注解方式实现一对多、多对多关系

    一.一对多关系 1.在上一篇日志中用.xml配置文件项目基础上,再往lib目录先添加一个包-hibernate-jpa-2.0-api-1.0.0.Final.jar 2.新建一个com.st.bea ...

  5. Hibernate用注解方式实现一对多、多对多关系

    一.一对多关系 1.在上一篇日志中用.xml配置文件项目基础上,再往lib目录先添加一个包-hibernate-jpa-2.0-api-1.0.0.Final.jar 2.新建一个com.st.bea ...

  6. Hibernate入门(三)—— 一对多、多对多关系

    一.一对多关系 1.概念 ​ 一对多关系是关系型数据库中两个表之间的一种关系.通常在数据库层级中,两表之间是有主外键关系的.在ORM中,如何通过对象描述表之间的关系,是ORM核心. 2.Hiberna ...

  7. hibernate:inverse、cascade,一对多、多对多详解

    1.到底在哪用cascade="..."? cascade属性并不是多对多关系一定要用的,有了它只是让我们在插入或删除对像时更方便一些,只要在cascade的源头上插入或是删除,所 ...

  8. Spring Boot 入门系列(二十八) JPA 的实体映射关系,一对一,一对多,多对多关系映射!

    前面讲了Spring Boot 使用 JPA,实现JPA 的增.删.改.查的功能,同时也介绍了JPA的一些查询,自定义SQL查询等使用.JPA使用非常简单,功能非常强大的ORM框架,无需任何数据访问层 ...

  9. 一对多(多对一)关系中的inverse和cascade属性

    转载请标明出处 http://www.cnblogs.com/haozhengfei/p/6049276.html 首先说一下inverse: "inverse" 直译过来就是&q ...

随机推荐

  1. Javascript快速入门(下篇)

    Javascript, cheer up. Ajax:其通过在Web页面与服务器之间建立一个额外的处理层,这个处理层就被称为Ajax引擎,它解释来自用户的请求,在后台以异步的方式处理服务器通信,其结构 ...

  2. 关于移动开发的一些想法和认识--Android和iOS

    微信公众账号很久没更新了,发一点自己最近的想法和内容. 之前和朋友做了一个项目,现在在跟一些风投,大公司里面的几家在谈合作和投资的事宜,从这个过程中也了解到了一些信息. 关于移动平台的应用开发与游戏开 ...

  3. HTTP与AJAX深入揭秘,不使用AJAX实现页面无刷新

    AJAX的原理是什么? 实际上就是发起HTTP请求,既然就是发起HTTP请求,那只要我们能够实现发起HTTP请求就可以在不使用AJAX的情况下实现相同的效果. 在前端有好多方式可以发起HTTP请求,比 ...

  4. CSS 性能

    http://boagworld.com/dev/why-you-should-care-about-css-page-performance/ http://css-tricks.com/effic ...

  5. 深入理解PHP内核(二)概览-PHP生命周期与Zend引擎

    本文参考自<深入理解PHP内核>,地址:https://github.com/reeze/tipi 本文链接:http://www.orlion.ml/232/ 1.SAPI接口 SAPI ...

  6. BOM之window对象

    双重角色 BOM的核心对象是window,它表示浏览器的一个实例.在浏览器中,window对象有双重角色,它既是通过Javascript访问浏览器窗口的一个接口,又是ECMAScript规定的Glob ...

  7. JSP网站开发基础总结《十四》

    对于JSP的知识总结,已经为大家分享的差不多了,本篇就为大家做一下最后总结,本篇总结的主题是文件上传和下载,在之前的随笔中也有为大家分享过文件上传和下载的知识,不过都是通过JAVA提供的上传下载类实现 ...

  8. Advice for students of machine learning--转

    原文地址:http://www.mimno.org/articles/ml-learn/ written by david mimno One of my students recently aske ...

  9. 材价看板(2)- 运行两周的kanban,改进的起点

    改进从何谈起?必须找到起点,那起点从哪来? 看板不需要像Scrum那样改变以往工作角色,简单通过任务上墙,配合敏捷的设计就能通过显示化日常工作来让问题自己蹦出来.在任何一个新采用看板的研发团队,执行一 ...

  10. Eclipse快捷键(转)

    Ctrl+1 快速修复(最经典的快捷键,就不用多说了)Ctrl+D: 删除当前行 Ctrl+Alt+↓ 复制当前行到下一行(复制增加)Ctrl+Alt+↑ 复制当前行到上一行(复制增加)Alt+↓ 当 ...