JAVA(Hibernate)一对多映射
数据库实体间一对多(多对一)、多对多关系处理

数据库实体间⼀对多(多对⼀)、多对多关系处理
数据库实体间有三种对应关系:⼀对⼀,⼀对多,多对多。
⼀对⼀关系⽰例:⼀个学⽣对应⼀个学⽣档案材料,或者每个⼈都有唯⼀的⾝份证编号。
⼀对多关系⽰例:⼀个学⽣只属于⼀个班,但是⼀个学院有多名学⽣。
多对多关系⽰例:⼀个学⽣可以选择多门课,⼀门课也有多名学⽣。
这三种关系在数据库中逻辑结构处理分析:
1.⼀对多关系处理:
我们以学⽣和班级之间的关系来说明⼀对多的关系处理⽅法。
假设现有基本表学⽣表(学号,姓名,……),班级表(班级号,备注信息,……)。
⽅法⼀:
新增⼀个关系表,⽤来表⽰学⽣与班级的属于关系,该关系表包含字段(学⽣号,班级号)。
通过学⽣号与班级号的对应关系表⽰学⽣属于的班级。
⽅法⼆:
在学⽣表中新增字段(班级号),该字段作为学⽣表的外键与班级表中的班级号关联。
每⼀个学⽣实体在班级号字段的值,表⽰该学⽣属于的班级。
⼩结:⼀般情况下,⼀对多关系采⽤⽅法⼆来处理。
⼀对多的两个实体间,在“多”的实体表中新增⼀个字段,该字段是“⼀”实体表的主键。
2.多对多关系处理:
在多对多关系中,我们要新增加⼀个关系表。
如在上⾯⽰例中,在学⽣表和课程表的基础上增加选课表来表⽰学⽣与课程之间的多对多关系。
在选课表中,必须含有的属性有学⽣号和课程号。
(学⽣号,课程号)这个属性集刚好也就是选课表的关键字。
hibernate核心,一对多,多对多映射讲解,看了就完全搞明白了

在many一方删除数据1
• 删除“五四大道”
inverse设为true,由many一方删除 从one一方去“删除”, Hibernate只是执行了 问题出在配置文件上 update语句。还是未删 没有配置set节点的inverse属性 除成功! 根本没有执行 Delete语句,数据 没有被删除!
– 配置Hibernate多对多关联,实现某OA系统项 目和人员对照关系的管理
本章目标
• 掌握单向many-to-one关联 • 掌握双向one-to-many关联 • 掌握many-to-many关联
实体间的关联
• 单向多对一
tblJd.getQx().getQxname();
• 单向一对多
TblJd jd = (TblJd)tblQx.getJds().get(0); jd.getJdname(); tblQx.getJds.add(jd);
小结
• 在租房系统中,房屋信息(Fwxx)与用户 (User)间也是多对一关系。如何配置映 射文件,使之可以通过下面的代码输出房 屋信息和发布该信息的用户名称? Fwxx fwxx = (Fwxx)super.get(Fwxx.class,1);
System.out.println( fwxx.getTitle() + "," + fwxx.getUser.getUname());
inverse是“反转”的意思,表示关联关系的控制权。 为true,表示由对方负责关联关系的添加和删除; 执行了delete语句, 为false,表示由自己负责维护关联关系。 删除成功
• 在many一方删除数据的正确做法:
hibernate最精细总结 java

Hibernate总结注:重点讲解关联映射总结人:张焕邮箱:zhang343489603@欢迎交流讨论。
目录1)核心接口简介2)Hibernate版本更新情况3)Hibernate关联映射4)简单属性查询5)Hibernate与延迟加载6)hibernate 中Criteria 的使用介绍7) Hibernate程序性能优化Hibernate优点:1、封装了jdbc,简化了很多重复性代码。
2、简化了DAO层编码工作,使开发更对象化了。
3、移植性好,支持各种数据库,如果换个数据库只要在配置文件中变换配置就可以了,不用改变hibernate代码。
4、支持透明持久化,因为hibernate操作的是纯粹的(pojo)java类,没有实现任何接口,没有侵入性。
所以说它是一个轻量级框架。
Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。
Hibernate可以应用在任何使用JDBC的场合,既可以在Java的客户端程序使用,也可以在Servlet/JSP的Web 应用中使用,最具革命意义的是,Hibernate可以在应用EJB的J2EE架构中取代CMP,完成数据持久化的重任。
1)核心接口简介:Hibernate的核心接口一共有6个,分别为:Session、SessionFactory、Transaction、Query、Criteria和Configuration。
这6个核心接口在任何开发中都会用到。
通过这些接口,不仅可以对持久化对象进行存取,还能够进行事务控制。
下面对这6个核心接口分别加以介绍。
Session接口Session接口负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流,包含了很多常见的SQL语句。
)。
但需要注意的是Session对象是非线程安全的。
同时,Hibernate的session不同于JSP应用中的HttpSession。
对象关系在模型中的实现案例

对象关系在模型中的实现案例—基础软件部吴春云一、案例介绍:在一个项目中,存在多个业务对象,各个业务对象间存在各种关系。
从结构上来看,对象关系可以分为依赖、继承、关联、聚合、组合,从数量上来看,对象关系可以分为一对一、一对多、多对多。
本案例主要介绍如何在开发中通过代码来表示对象间的各种关系,并基于这种关系进行前后端数据交互及持久化。
二、关系的概念及实现:1.结构关系1.1继承继承指的是一个类(称为子类、子接口)继承另外的一个类(称为父类、父接口)的功能,并可以增加它自己的新功能的能力。
所以继承关系,确切的说是类与类之间的关系,但是对象又是类的实例,所以就这个角度理解为对象之间的关系,例如父与子的关系,动物与狗的关系,汽车与大众的关系等。
工作流结构部分的实体类:SysNode(环节)、SysTransactNode (办理环节)、SysActivityNode(活动环节)、SysDecisionNode(决策环节)应用了这种继承关系,使得子类拥有了父类环节中的属性,但子类本身代码大大简化,结构清晰。
public class SysTransactNode extends SysNode{}public class SysActivityNode extends SysTransactNode{}public class SysDecisionNode extends SysTransactNode{}1.2依赖依赖就是一个对象A使用到了另一个对象B,而这种使用关系是具有偶然性的、临时性的、非常弱的,但是对象B的变化会影响到对象A。
比如某人要过河,需要借用一条船,此时某人与一条船之间的关系就是依赖。
表现在代码层面,一般指由局部变量、返回值建立的对于其他对象的调用关系,如对象B作为参数被对象A在某个方法中使用。
1.3关联关联体现的是两个类之间语义级别的一种强依赖关系,这种关系比依赖更强、不存在依赖关系的偶然性、关系也不是临时性的,一般是长期性的,而且双方的关系一般是平等的。
13-Hibernate关联关系映射:一对多孤儿删除

13-Hibernate关联关系映射:⼀对多孤⼉删除persist和merge是JPA提供的内容none是不使⽤级联,save-update是保存和更新的时候级联hibernate级联的取值none:不使⽤级联save-update:保存和更新时级联delete:删除的时候级联all:delete-orphan:孤⼉删除,孤⼦删除*仅限于⼀对多,只有⼀对多的时候才有类似⽗⼦关系的存在,才有⽗⼦表的存在。
认为⼀的⼀⽅是⽗⽅。
因为⼀个⽗亲是可以有多个孩⼦的。
多的⼀⽅是⼦的⼀⽅。
*当⼀个客户与某个订单解除关系,其实就是将外键置为null,如果你的订单没有所属的客户,那你的订单还有意义吗?订单没有了所属客户,就相当于⼀个孩⼦没有了⽗亲,将这种记录就删除了,这就叫做孤⼉删除。
*但是这只有在⼀对多的情况下才存在。
多对多的情况哪有这种关系,多对多就是多个⽗亲多个⼉⼦,这就不合理了。
⼀的⼀⽅是⽗⽅,多的⼀⽅是⼦⽅。
All-delete-orphan:我们现在想让1号客户和1号订单解除关系:⼀个部门可以有多个员⼯,⼀个员⼯只能属于⼀个部门。
解除关系就是把外键置为空了,就是把外键置为null了。
Hibernate:selectcustomer0_.cid as cid0_0_,customer0_.cname as cname0_0_fromcustomer customer0_wherecustomer0_.cid=?Hibernate:selectorder0_.oid as oid1_0_,order0_.addr as addr1_0_,order0_.cno as cno1_0_fromorders order0_whereorder0_.oid=?Hibernate:selectorders0_.cno as cno0_1_,orders0_.oid as oid1_,orders0_.oid as oid1_0_,orders0_.addr as addr1_0_,orders0_.cno as cno1_0_fromorders orders0_whereorders0_.cno=?Hibernate:updateorderssetcno=nullwherecno=?这个时候我们再看客户和订单都还在。
关系映射

T_person --------------------------------------Id name --------------------------------------1 张三 2 李四 T_idCard --------------------------------------Id cardNo --------------------------------------1 1234567890 2 2345678901
One2One fk1
<class name="com.sinoest.hibernate.IdCard" table="t_idCard"> <id name="id"> <generator class="native"/> </id> <property name="cardNo"/> </class>
many2one
public class User { private int id; private String name; private String name; private Group group; public int getId() { return id; } …. } } public int getId() { return id; } public void setId(int id) { this.id = id; } …. Public class Group{ prlass Classes { private int id; private String name; private Set students; public int getId() { return id; } public void setId(int id) { this.id = id; } ……. public class Student { private int id; private String name; public int getId() { return id; } public void setId(int id) { this.id = id; }
一对多,多对一关系映射
⼀对多,多对⼀关系映射 ⼀对多,多对⼀关系映射 现实⽣活中有很多1对多(多对1)的关系模型。
⽐如,⼀个⼈可以有0到多套房⼦,0到多辆汽车;⼀个⽗亲有0到多个孩⼦等等。
这种关系被称作1对多关系。
反过来,房⼦与⼈,汽车与⼈的关系,以及孩⼦与⽗亲的关系就是多对⼀的关系。
这⾥需要注意⼀点的是,多对⼀关系的⼀个前提是:⼀套确定的房⼦只能属于某个确定的⼈(不能属于多⼈);⼀个确定的孩⼦也只能属于某个确定的⽗亲。
下⾯我们就拿最简单的⽗亲和孩⼦的关系来说明1对多(多对1)模型的映射。
关系模型:⽗亲 vs 孩⼦(Father vs Son)。
关系映射:one-to-many反过来,关系模型:孩⼦ vs ⽗亲(Son vs Father)。
关系映射:many-to-one 很多初学者往往有这样的疑问,我什么时候需要定义映射关系呢? 答案很简单:按需求来确定。
就是说你需要哪种关系的时候就定义哪种映射,不需要的时候就可以不定义它们的关系映射了。
还是以上⾯的例⼦来说明。
如果你需要在取得孩⼦(Son)的时候,同时需要知道该孩⼦的⽗亲(Father)是谁,你就可以在孩⼦的实体类⾥定义孩⼦跟⽗亲的关系映射: @ManyToOne 。
同样,如果需要知道某⽗亲的所有孩⼦,就可以在⽗亲的实体类⾥定义⽗亲跟孩⼦的关系映射: @OneToMany 。
1.ManyToOne(多对⼀) 单向:不产⽣中间表,但可以⽤@Joincolumn(name=" ")来指定⽣成外键的名字,外键在多的⼀⽅表中产⽣!2.OneToMany(⼀对多) 单向:会产⽣中间表,此时可以⽤@onetoMany @Joincolumn(name=" ")避免产⽣中间表,并且指定了外键的名字(别看 @joincolumn在⼀中写着,但它存在在多的那个表中)3.OneToMany ,ManyToOne 双向( 两个注解⼀起⽤的):如果不在 @OneToMany 中加mappedy属性就会产⽣中间表,此时通常在 @ManyToOne 的注解下再添上注解 @Joincolumn(name=" ") 来指定外键的名字(说明:多的⼀⽅为关系维护端,关系维护端负责外键记录的更新,关系被维护端没有权利更新外键记录)!( @OneToMany(mappedBy="⼀对多中,多中⼀的属性") 出现mapby为被维护端|||默认为延迟加载)⽤例:1 @ManyToOne(fetch=ZY)2 @JoinColumn(name="child_id")3private OrderChild orderChild;45 @OneToMany(mappedBy="orderChild",fetch=ZY,cascade={CascadeType.MERGE})6 @NotFound(action=NotFoundAction.IGNORE)//代表可以为空,允许为null7private List<OrderChildGoods> goodsList; hibernate中@ManyToOne默认是⽴即加载,@OneToMany默认是懒加载但是如果加上了@NotFound之后设置的fetch=ZY是不起作⽤的,也就是设置@NotFound后变为了⽴即加载eager 下⾯举例详细说明⼀下@ManyToOne @ManyToOne注解的这端,是多端 1.在注释@ManyToOne(cascade=CascadeType.REFRESH,optional=true)中将属性optional设置为true,这可以使得即使外键为空时仍可以向表中添加数据。
javaee一对一,一对多,多对多的心得
JavaEE是一种用于开发企业级应用程序的技术评台,它构建在Java评台之上,提供了一系列的API和功能,从而使开发人员能够更加便利地构建出可靠、可扩展和安全的应用程序。
在JavaEE中,常见的关系模型有一对一、一对多和多对多,这三种关系模型在实际开发中具有重要的作用。
本文将深入探讨这三种关系模型在JavaEE中的应用,并结合实际开发经验,共享一些心得体会。
一、一对一关系1.1. 一对一关系概述在JavaEE中,一对一关系指的是两个实体之间的一对一映射关系,即一个实体实例只对应另一个实体实例。
这种关系模型在数据库设计和应用程序开发中经常会遇到,例如学生和唯一识别信息号码之间的关系就是一对一关系。
在JavaEE中,一对一关系通常通过OneToOne注解来进行表示。
1.2. 一对一关系的实际应用在实际开发中,一对一关系常常用于处理一些固定的关联关系,例如用户和用户详细信息、公司和公司详情等。
通过一对一关系的映射,可以方便地进行数据查询和管理,提高了系统的可维护性和可扩展性。
1.3. 一对一关系的心得体会在处理一对一关系时,需要注意合理设计数据库表结构和Entity对象之间的映射关系,避免出现冗余或不必要的数据。
还需要考虑数据查询的性能和效率,避免因为关联关系过多导致数据查询变慢。
一对一关系在JavaEE开发中具有重要的作用,需要合理使用和灵活运用。
二、一对多关系2.1. 一对多关系概述一对多关系指的是一个实体实例对应多个实体实例的关系模型,例如一个班级对应多个学生,一个订单对应多个商品等。
在JavaEE中,一对多关系通常通过OneToMany注解来进行表示。
2.2. 一对多关系的实际应用一对多关系在实际开发中非常常见,例如新闻和评论之间的关系、部门和员工之间的关系等。
通过一对多关系的映射,可以方便地进行数据操作和管理,提高了系统的灵活性和扩展性。
2.3. 一对多关系的心得体会在处理一对多关系时,需要注意数据的一致性和完整性,避免因为关联关系过于复杂而导致数据操作的困难和混乱。
java学习经验Hibernate总结
Hibernate工作原理及为什么要用?一原理:1.读取并解析配置文件2.读取并解析映射信息,创建SessionFactory3.打开Sesssion4.创建事务Transaction5.持久化操作6.提交事务7.关闭Session。
8.关闭SessionFactory为什么要用:1. 对JDBC访问数据库的代码做了封装,大大简化了数据访问层繁琐的重复性代码。
2. Hibernate是一个基于JDBC的主流持久化框架,是一个优秀的ORM实现。
他很大程度的简化DAO层的编码工作3. hibernate使用Java反射机制,而不是字节码增强程序来实现透明性。
4. hibernate的性能非常好,因为它是个轻量级框架。
映射的灵活性很出色。
它支持各种关系数据库,从一对一到多对多的各种复杂关系。
二Hibernate 的核心接口及其作用1 Configuration类:配置Hibernate启动Hibernate创建SessionFactory对象2 SessionFactory:初始化Hibernate创建Session对象线程安全—同一实例被多个线程共享重量级:代表一个数据库内部维护一个连接池2.1 openSession():总是创建新的session,需要手动close()2.2 getCurrentSession() : 必须在hibernate.cfg.xml设置session 上下文事务自动提交并且自动关闭session.从上下文环境中获得session,如果当时环境中不存就创建新的.如果环境中存在就使用环境中的,而且每次得到的都是同一个session (在session提交之前,提交之后就是新的了) 应用在一个session中有多个不同DAO操作处于一个事务时3 Session:负责保存、更新、删除、加载和查询对象轻量级--可以经常创建或销毁3.1 Load与get方法的区别:简单理解:load是懒加载,get是立即加载.load方法当使用查出来的对象时并且session未关闭,才会向数据库发sql, get会立即向数据库发sql返回对象3.3 merge(); 合并对象更新前会先select 再更新3.4clear()清空缓存,flush()将session中的数据同步到数据库两者组合使用于批量数据处理3.4Transaction commit() rollback()JPA: java persistence API 提供了一组操作实体bean的注解和API规范SchemaExporthiberante的生成数据库表(及其他ddl)的工具类可以通过这个工具类完成一些ddl四Hibernate查询查询语言主要有:HQL 、QBC (Query By Criteria条件查询) 、 Native SQLHql:1、属性查询2、参数查询、命名参数查询3、关联查询4、分页查询5、统计函数五优化抓取策略连接抓取(Join fetching)使用 OUTER JOIN(外连接)来获得对象的关联实例或者关联集合查询抓取(Select fetching)另外发送一条 SELECT 语句抓取当前对象的关联实体或集合另外可以配置hibernate抓取数量限制批量抓取(Batch fetching)另外可以通过集合过滤来限制集合中的数据量使用session.createFilter(topic.getReplies(),queryString).list();检索策略延迟检索和立即检索(优先考虑延迟检索)N+1问题指hibernate在查询当前对象时查询相关联的对象查询一端时会查询关联的多端集合对象解决方案:延迟加载连接抓取策略二级缓存集合过滤 BatchSize限制记录数量映射建议使用双向一对多关联,不使用单向一对多灵活使用单向一对多关联不用一对一,用多对一取代配置对象缓存,不使用集合缓存一对多集合使用Bag,多对多集合使用Set继承类使用显式多态表字段要少,表关联不要怕多,有二级缓存撑腰Hibernbate缓存机制性能提升的主要手段Hibernate进行查询时总是先在缓存中进行查询,如缓存中没有所需数据才进行数据库的查询.Hibernbate缓存:一级缓存 (Session级别)二级缓存(SessionFactory级别)查询缓存 (基于二级缓存存储相同参数的sql查询结果集)一级缓存(session缓存)Session缓存可以理解为session中的一个map成员, key为OID ,value为持久化对象的引用在session关闭前,如果要获取记录,hiberntae先在session缓存中查找,找到后直接返回,缓存中没有才向数据库发送sql三种状态的区别在于:对象在内存、数据库、session缓存三者中是否有OID临时状态内存中的对象没有OID, 缓存中没有OID,数据库中也没有OID 执行new或delete()后持久化状态内存中的对象有OID, 缓存中有OID,数据库中有OIDsave() load() get() update() saveOrUpdate() Query对象返回的集合游离(脱管)状态内存中的对象有OID, 缓存中没有OID,数据库中可能有OIDflush() close()后使用session缓存涉及三个操作:1将数据放入缓存2从缓存中获取数据3缓存的数据清理4二级缓存SessionFactory级别SessionFactory级别的缓存,它允许多个Session间共享缓存一般需要使用第三方的缓存组件,如: Ehcache Oscache、JbossCache等二级缓存的工作原理:在执行各种条件查询时,如果所获得的结果集为实体对象的集合,那么就会把所有的数据对象根据OID放入到二级缓存中。
Hibernate基础知识详解
Hibernate基础知识详解<hibernate-mapping><class name="*.*.*" table="t_customer" catalog="***"><id name="id" column="c_id"><generator class="identity"/></id><property name="name" column="c_name" length="20"/><set name="orders" inverse="false" cascade="save-update"><key column="c_customer_id"/></set></class></hibernate-mapping>(1)统⼀声明包名,这样在<class>中就不需要写类的全名。
(2)关于<class>标签配置name 属性:类的全名称table 表的名称,可以省略,这时表的名称就与类名⼀致catalog 属性:数据库名称可以省略.如果省略,参考核⼼配置⽂件中 url 路径中的库名称(3)关于<id>标签,<id>是⽤于建⽴类中的属性与表中的主键映射。
name 类中的属性名称column 表中的主键名称 column 它也可以省略,这时列名就与类中属性名称⼀致length 字段长度type 属性指定类型<generator>它主要是描述主键⽣成策略。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
1.Hibernate映射简介;
分为四种:一对多OneToMany;
多对一ManyToOne;
一对一OneToOne;
多对多ManyToMany;
2.一对多外键关联;
在数据库中,可以通过添加主外键的关联,表现一对多的关系;
通过在一方持有多方的集合实现,即在一的一端使用<set>元素表示持有多的一端的而对象;
例子;
1.创建hibernate项目
2.导入jar包;并调节到构建路径下(右击jar包名/Build Path/add to Build Path)
Jdbc驱动包:mysql-connoector.jar
junit测试包:junit.jar
hibernate内部包;
antlr.jar,
dom4j.jar,
hibernate-commons-annotatons.jar,
hibernate-core.jar,
hibernate-jpa.jar,
javassist.jar,
jboss-loggin.jar,
Jboss-logging-annotation.jar;
jboss-transaction-api.jar;
3.生成配置hibernate文件;
<session-factory>
<property name=”hibernate.connection.driver_class”>
com.mysql.jdbc.Driver
</property>
<property name=”ername”>roo</property>
<property name=”hibernate.connection.password”>rot</property>
<property name=”hibernate.connection.url”>
<![CDATA[
jdbc:mysql://localhost:3306/imooc?useUnicode=true&chara
cterEncodiing=utf8
]]>
</property>
<property name=”hibernate,dialect”>
org.hibernate.dialect.MYSQLDialect
</property>
<property name=”show_sql”>true</property>
<property name=”hbm2ddl.auto”>update</property>
</session-factory>
4.创建会话工具类;
public class HibernateUtil{
private static SessionFactory sf;
private static Session s;
static {
//创建hibernate的Configutation对象,读取hibernate.cfg.xml 文件,完成初始化;
Configuration config=new Configuration().configure();
StandardServiceRegistryBuilder ssr=new StandradServiceR
egistryBuilder().applySettings(config.getProperties());
StandradServiceRegistry ss=ssr.build();
Sf=config.buildSessionFactory(ss);
}
//获取SessionFactory
public static SessionFactory getSessionFactory(){
return sf;
}
//获取Session
public static Session getSession(){
s=sf.openSession();
return s;
}
//关闭Session
public static void closeSession(Session s){
if(s!=null){
s.close();
}
}
}
5.创建数据库
create table grade{
gid int primary key,
gname varchar(20) not null,
gdesc varchar(50)
};
create table student{
sid int primary key,
sname varchar(20) not null,
sex char(2),
gid int
};
alter table student add constraint fk_student_gid foreign key (gid) references grade(gid);
6.Grade.hbm.xml表中配置一对多关系
7.
3.多对一双向外键关联;
多对一的关系和关系数据库中的外键参照关系最匹配,即在己方的表中的一个外键参照另一个表的主键;
多方:多方持有一方的引用,即需要在多的一端使用<amny-to-one>配置;
@ManyToOne(cascade={CascadeType.ALL},fetch=FetchType.EAGER)
//cascade表示级联关系(ALL全级联),fetch表抓取策略(默认EAGER积极加载);
@JoinColumn(name=”cid”)
一方:一方持有多方集合;
@OneToMany(cascade={CascadeType.ALL},fetch=ZY)
//表示全级联关系以及懒加载;
@JoinColumn(name=”cid”)
Student.hbm.xml表中配置多对一关联关系:
测试类:
4.双向关联关系:两hbm.xml中各配置关联关系
Grade.hbm.xml中
Student.hbm.xml表中
测试类:
Inverse属性:
<set>节点的inverse属性指定关联关系的控制方向,默认由one方来维护;即inverse=“false”,为主动方,由主动方负责维护关联关系;
而在一对多关联中,只能设置one方的inverse为true,表示有多方维护关联关系,这将有助于性能的改善;
Cascade属性:
当设置cascade属性不为none时,Hibernate会自动持久化所关联的对象;
如保存班级信息,会自动级联添加更新的后该班级的学生信息;
Cascade属性的设置会带动性能上的变化,需小心设置;
执行双向关联后,即可以方便的由学生查找到对应班级信息,也可以方便的由班级查找到其所包含的学生信息;
5.总结:
1.实现单向一对多:
在one方的实体中添加保存many方的集合;并在one方的配置文件(.hbm.xml)中
添加<one-to-many>配置;
2.实现单向多对一:
在many方的实体中添加one方的引用;并在many方的配置文件(.hbm.xml)中添加
<many-to-one>配置;
3.<set>常用属性:
Cascade;设置级联关系;9
Inverse:设置由哪一方维护关联关系;默认为false(one方维护);
6.Other。