Hibernate-16多对多关联映射-双向

合集下载

Hibernate映射---多对多----将多对多拆分成两个一对多

Hibernate映射---多对多----将多对多拆分成两个一对多订单和商品的关系就是多对多,一个订单包含多个商品,一个商品可以生成多个订单.如果要想将订单和商品关联起来,还需要一张中间表,来表示二者的关联关系.那么当你需要查询某个订单下的商品时,需要关联查询三张表,这样的查询效率就比较低,所以使用时也要谨慎下面以订单和商品为例,学习多对多关联关系多对多双向关联拆分成两个一对多关联---查询订单下所有的产品Myeclipse在开发上对双向关联提供了支持.在表中设置好主键和外键关系在之前多对多双向关联中,只是一个订单对应产品数量为1,并且价格就是产品定价.那么如何实现下面的变化呢?第一:商品数量有变化,不是一个,而是10个或100个第二:商品价格的变化,早上和晚上是不一样的那么如何实现呢?在中间表中添加两个字段,分别是产品数量quantity,商品售出价格purchasePrice;下面我们来实现这个功能第一步:创建数据库.并建立好主外键关系第二步:选择三张表,生成映射文件和持久化类将多对多关联关系拆分成两个一对多关联关系.在生成映射文件和持久化类时,不要选择many-to-many实时监测选项,如下图;生成映射文件和持久化类如下图:第三步:修改Orders.java类和持久化文件,通常我们根据订单查找其下的产品,很少会根据产品查询该产品在哪个订单下.因此我们没有必要为product添加关联,修改后的文件如下:第四步:修改OrderItem.java文件和OrderItem.hbm.xml文件删除OrderItemId.java持久化类文件,然后修改OrderItem.java 文件,具体如下:第五步:编写测试类package com.entity;import java.util.Set;import org.hibernate.Session;import com.util.HibernateSessionFactory;public class HibernateTest {/*** @param args*/public static void main(String[] args) {HibernateTest hibernateTest = new HibernateTest();hibernateTest.get();}/*** 添加订单和产品*/public void add(){Session session = HibernateSessionFactory.getSessionFactory().getCurrentSession( );session.beginTransaction();Orders order = new Orders();order.setRealname("刘备");order.setAddress("武汉");order.setPhone("999");order.setPostcode("4567");Product product1 = (Product) session.get(Product.class, 1);Product product2 = (Product) session.get(Product.class, 2);OrderItem item1 = new OrderItem(order,product1,100,195.00);OrderItem item2 = new OrderItem(order,product2,200,98.00);double total = 100*195.00+200*98.00;order.getOrderItems().add(item1);order.getOrderItems().add(item2);order.setTotal(total);session.save(order);session.beginTransaction().commit();}/*** 查询订单下的产品*/public void get(){Session session = HibernateSessionFactory.getSessionFactory().getCurrentSession( );session.beginTransaction();Orders order = (Orders) session.get(Orders.class, 3);System.out.println(order.getRealname());System.out.println(order.getTotal());Set<OrderItem> items = order.getOrderItems();System.out.println("===================订单下的产品=======================");for(OrderItem i:items){System.out.println("产品名称:"+i.getProduct().getName());System.out.println("实际价格:"+i.getProduct().getPrice());System.out.println("购买价格:"+i.getPurchaseprice());System.out.println("购买数量:"+i.getQuantity());}session.beginTransaction().commit();}}----------------------------------------新增数据结果:。

hibernate各种关联关系

一、多对一关联映射<many-to-one>会在多的一端加入一个外键，指向一的一端，这个外键是由<many-to-one> 中的column属性定义的，如果忽略了这个属性那么默认的外键与实体的属性一致<many-to-one>标签的定义示例：* <many-to-one name="group" column="groupid"/>二、一对一主键关联1、一对一主键关联单向t_userid | name | groupid1 | 菜10 | 12 | 容祖儿| 1t_groupid | name1| 尚学堂t_personid | name1| 菜102| 容祖儿t_idcardid | cardNo1 | 88888888882 | 9999999999hibernate 一对一主键关联映射（单向关联Person---->IdCard ）一对一主键关联映射:让两个实体对象的id 保持相同，这样可以避免多余的字段被创建具体映射： <id name="id">  <generator class="foreign"> <param name="property">idCard</param> </generator> </id> <property name="name"/>  <one-to-one name="idCard" constrained="true"/>2、一对一主键关联双向hibernate 一对一主键关联映射（双向关联Person<---->IdCard ）需要在idcard 映射文件中加入<one-to-one>标签指向person ，指示hibernate 如何加载person 默认根据主键加载t_personid | name3| 菜10 4| 容祖儿 t_idcard id | cardNo 1 | 8888888888 2 | 9999999999三、一对一外键关联1、一对一外键关联单向hibernate一对一唯一外键关联映射（单向关联Person---->IdCard）一对唯一外键关联映射是多对一关联映射的特例可以采用<many-to-one>标签，指定多的一端的unique=true，这样就限制了多的一端的多重性为一通过这种手段映射一对一唯一外键关联2、一对一外键关联双向t_personid | name | idcard 5| 菜10 | 100 6| 容祖儿| 200 t_idcardid | cardNo 100 | 8888888888 200 | 9999999999t_personid | name | idcard 7| 菜10 | 100 8| 容祖儿| 200 t_idcardid | cardNo 100 | 8888888888 200 | 9999999999hibernate 一对一唯一外键关联映射（双向关联Person<---->IdCard ）一对一唯一外键关联双向，需要在另一端（idcard ），添加<one-to-one>标签，指示hibernate 如何加载其关联对象，默认根据主键加载person ，外键关联映射中，因为两个实体采用的是person 的外键维护的关系，所以不能指定主键加载person ，而要根据person 的外键加载，所以采用如下映射方式：<one-to-one name="person" property-ref="idCard"/>四、一对多关联映射 1、一对多关联映射单向hihernate 一对多关联映射（单向Classes----->Student ）一对多关联映射利用了多对一关联映射原理多对一关联映射：在多的一端加入一个外键指向一的一端，它维护的关系是多指向一一对多关联映射：在多的一端加入一个外键指向一的一端，它维护的关系是一指向多也就是说一对多和多对一的映射策略是一样的，只是站的角度不同<set name ="students"><key column ="classesid"/> <one-to-many class ="Students"/> </set >在一一端维护关系的缺点： * 如果将t_student 表里的classesid 字段设置为非空，则无法保存 * 因为不是在student 这一端维护关系，所以student 不知道是哪个班的，所以需要发出多余的update 语句来更新关系t_classesid | name1 | 尚学堂t_student id | name | classesid 1 | 10 | 1 2 | 祖儿 | 12、一对多关联映射双向hihernate 一对多关联映射（双向Classes<----->Student ）一对多双向关联映射： * 在一一端的集合上使用<key>，在对方表中加入一个外键指向一一端 * 在多一端采用<many-to-one>注意：<key>标签指定的外键字段必须和<many-to-one>指定的外键字段一致，否则引用字段的错误如果在”一“一端维护一对多关联关系，hibernate 会发出多余的udpate 语句，所以我们一般在多的一端来维护关联关系关于inverse 属性： inverse 主要用在一对多和多对多双向关联上，inverse 可以被设置到集合标签<set>上，默认inverse 为false ，所以我们可以从”一“一端和”多“一端维护关联关系，如果设置成inverse 为true ，则我们只能从多一端来维护关联关系注意：inverse 属性，只影响数据的存储，也就是持久化inverse 和cascade * inverse 是关联关系的控制方向t_classesid | name1 | 尚学堂t_student id | name | classesid 1 | 10 | 1 2 | 祖儿 | 1* cascade操作上的连锁反应五、多对多关联关系1、多对多关联关系单向hibernate多对多关联映射(单向User---->Role)具体映射方式：<set name="roles" table="t_user_role"><key column="userid"/><many-to-many class=".bjsxt.hibernate.Role" column="roleid"/></set>2、多对多关联关系双向t_userid | name1 | 102 | 祖儿3 | 杰伦t_roleid | name1 | 数据录入人员2 | 商务主管3 | 大区经理t_user_roleuserid | roleid1| 11| 22| 22 | 33 | 13 | 23 | 3t_userid | name1 | 102 | 祖儿3 | 杰伦t_roleid | name1 | 数据录入人员2 | 商务主管3 | 大区经理t_user_roleuserid | roleid2| 13| 24| 22 | 33 | 13 | 23 | 3hibernate多对多关联映射(双向User<---->Role)映射方法：<set name="roles" table="t_user_role"><key column="userid"/><many-to-many class=".bjsxt.hibernate.Role" column="roleid"/></set>table属性值必须和单向关联中的table属性值一致<key>中column属性值要与单向关联中的<many-to-many>标签中的column属性值一致在<many-to-many>中的column属性值要与单向关联中<key>标签的column属性值一致六、继承关联映射1、每棵继承树映射成一表每棵继承树映射成一表id name sex weight height type1 猪猪true 100 P2 鸟鸟false 50 B每棵继承树映射成一表（1）、理解如何映射因为类继承树肯定是对应多个类，要把多个类的信息存放在一表中，必须有某种机制来区分哪些记录是属于哪个类的。

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中双向关联在级联情况下save对象讨论

hibernate中双向关联在级联情况下save对象讨论一般在双向关联的情况下，都要在一方设置mappedBy(name="xxx")，由对方主导映射关系。

在多对一的情况下，一般在多的一方设置主导映射的关系（为了方便叙述，就这么叫它了，呵呵）。

所谓主导这种映射关系，如group，user，就是由多的一方（user）里面产生一个外键参考一的一方（group）的主键，这时候user就是主导的一方，写mappedBy是被主导的一方。

在多对多的情况下，随便由那方主导，在数据库表的结构上都是一样的，都会产生一个中间表，中间表有两个字段的联合主键，分别作为外键参考两个多的一方。

在一对多和多对多的双向关联的情况下，并且在cascade=CascadeType.ALL情况下，save 不同方面（如主导关系一方或被主导的一方）在级联的具体表现上是不同的。

分别来讨论一下。

先看一对多的双向关联关系，这里就拿group和user举例。

Group类如下：[java]view plain copy1.package com.chen.hibernate.ormapping;2.3.import java.util.HashSet;4.import java.util.Set;5.6.import javax.persistence.CascadeType;7.import javax.persistence.Entity;8.import javax.persistence.FetchType;9.import javax.persistence.GeneratedValue;10.import javax.persistence.Id;11.import javax.persistence.OneToMany;12.import javax.persistence.Table;13.14.@Entity15.@Table(name = "t_group")16.public class Group {17.private int id;18.private String name;19.private Set<User> users = new HashSet<User>();20.21.@Id22.@GeneratedValue23.public int getId() {24.return id;25. }26.27.public void setId(int id) {28.this.id = id;29. }30.31.public String getName() {32.return name;33. }34.35.public void setName(String name) { = name;37. }38.39.// 设置mappedBy是被主导的一方40.@OneToMany(mappedBy = "group", cascade = { CascadeType.ALL }, fetch = FeZY)41.public Set<User> getUsers() {42.return users;43. }44.45.public void setUsers(Set<User> users) {ers = users;47. }48.}User类如下：[java]view plain copy1.package com.chen.hibernate.ormapping;2.3.import javax.persistence.CascadeType;4.import javax.persistence.Entity;5.import javax.persistence.FetchType;6.import javax.persistence.GeneratedValue;7.import javax.persistence.Id;8.import javax.persistence.JoinColumn;9.import javax.persistence.ManyToOne;10.import javax.persistence.Table;11.12.@Entity13.@Table(name = "t_user")14.public class User {15.private int id;16.private String name;17.private Group group;18.19.@Id20.@GeneratedValue21.public int getId() {22.return id;23. }24.25.public void setId(int id) {26.this.id = id;27. }28.29.public String getName() {30.return name;31. }32.33.public void setName(String name) { = name;35. }36.37.//设置fetch为lazy，多的一方默认问eager38.@ManyToOne(cascade = { CascadeType.ALL }, fetch = FetchType.EAGER)39.@JoinColumn(name = "groupId")40.public Group getGroup() {41.return group;42. }43.44.public void setGroup(Group group) {45.this.group = group;46. }47.}junit测试类[java]view plain copy1.package com.chen.hibernate.ormapping;2.3.import org.hibernate.Session;4.import org.hibernate.SessionFactory;5.import org.hibernate.cfg.AnnotationConfiguration;6.import org.hibernate.tool.hbm2ddl.SchemaExport;7.import org.junit.AfterClass;8.import org.junit.BeforeClass;9.import org.junit.Test;10.11.public class CRUDTest {12.private static SessionFactory sessionFactory = null;13.14.@BeforeClass15.public static void beforeClass() {16.new SchemaExport(new AnnotationConfiguration().configure()).create(17.false, true);18. sessionFactory = new AnnotationConfiguration().configure()19. .buildSessionFactory();20. }21.22.@Test23.public void testSaveUser() {24. User user = new User();25. user.setName("u1");26. Group group = new Group();27. group.setName("g1");28.29.// 这里仅仅把group加到user中，而不需要group.getUsers().add(user);把当前的对象加入到group的set里30. user.setGroup(group);31.32. Session session = sessionFactory.getCurrentSession();33. session.beginTransaction();34. session.save(user);35. session.getTransaction().commit();36. }37.38.// 再看看save被主导的一方会如何。

跟我学Hibernate框架技术——多对多的实体映射实现相关的应用技术

5、师者：“传道、授业和解惑”
多对多的实体映射实现技术（O/R Mapping for Many to Many Relation）
ቤተ መጻሕፍቲ ባይዱ
1、多对多关联映射的各种实现方案（1）方案一类似“一对多”情形中的最常用方案，为关联的双方增加到对方的外键此方法操作比较简单，但缺点是会造成数据冗余；（2）方案二新增一张包含关联双方主键的关联表在取数据时，需要链接该关联表和数据表，优点是没有数据冗余，缺点是带来了一定的时限复杂度。
2、注意的问题（1）“多对多”由于使用了中间数据库表，在查询效率方面比
较低（2）并且在对象模式上，“多对多”会使得对象与对象之间彼此依赖，因此该种设计并不是一个良好的设计方式（3）我们在系统的数据访问层的设计上应尽可能避免使用“多对多”关系。
3、多对多的关联同样也是采用Set、List 等多种方式的属性标签
4、基于中间连接表的“多对多”关联的映射文件的示例
中间连接表
注意<many-to-many>标签的定义
本讲的简要回顾
1、子曰：“学而不思则罔，思而不学则殆。” “学而时习之”
2、子曰：“知之者不如好之者,好之者不如乐之者”
3、子曰：“三人行,必有我师焉”
4、子曰：“我非生而知之者,好古,敏以求之者也”

hibernate关联映射详解

hibernate关联映射详解一对多关系 1.一对多关系（单向）：在一端映射文件中加入：name= student keyumn= classes / one-to-many > /set 2.一对多关系（双向）：（1）.在一端映射文件中加入： setname= student keycolumn= classesid / one-to-many > /set （2）.在多的一端加入： many-to-onename= classes column=classesid /many-to-one 多对一关系在多的一端加入：many-to-one name= classes column= classesid / 一对一关系 1. 一对一外键关联单向：（它其实就是一个多对一映射的一个特例，只是设置ue=”ue”）在维护关系一端的映射文件中加入：many-to-onename= card unique= true cascade= all /many-to-one 双向：在维护关系一端的映射文件中加入： many-to-onename= card unique= true cascade= all /many-to-one 在另一段的映射文件中加入： one-to-onename= users property-ref= card /one-to-one 因为 one-to-one name 标签默认是找关联主键，所以在这里需要property-ref= card 配置关联属性。

Cascade属性是级联的意思。

2. 一对一主键关联 a) 单向在维持关系一端的代码： classname= er_pk idname= id generator > paramname= property card_pk /param /generator /id propertyname= name unique= true /property one-to-onename= card_pk constrain= true /one-to-one /class 设置generator > constrained= true 设置该实体的主键是card_p的外键。

Hibernate 映射关联关系

Hibernate 映射关联关系一、映射多对一关联关系。

1.单向的多对一（1）以Customer 和Order 为例：一个用户可以发出多个订单，而一个订单只能属于一个客户。

从Order 到Customer 是多对一关联关系。

（2）创建Customer 和Order 表。

Create（3）用Intellij Idea 自动生成关联关系，以及对应的Entitiy.hbm.xml 和持久化类。

说明：其中Type 是用来修饰对应的Attribute Name 的。

在Order 端，定义Customer 类，一个订单属于一个客户。

而在Customer 端，一个客户可以有多个订单，因为是单向的，所以这里放弃属性的添加。

在Join Columns 定义了Order 和Customer 之间的关联关系，order 表中的customer_id 外键和customer 表中的customer_id 主键关联。

来看生成的Schema：没有勾选customer_id，是因为Intellij Idea 没法直接映射为Customer 类型的customer。

Order.hbm.xml使用<many-to-one> 节点来维护多对一关联关系。

name 属性：多这一端关联的一那一端的属性的名称。

class 属性：关联的一端的属性的类型。

column 属性：一那一端在多的一端对应的数据表中的外键。

可以任意命名，但需要和数据表中的字段对应。

（4）单向多对一的CRUD 以及需要注意的问题。

<1> 新增①先保存一的一端Customer，后保存多的一端Order。

Save.java打印SQL：Output结论：发送了3条INSERT 语句。

②先保存多的一端Order，再保存一的一端Customer。

Save2.java打印SQL：Output2结论：发送了3条INSERT 语句，2条UPDATE 语句。

总结：在单向多对一的关联关系下，先插入 1 的一端会减少SQL 语句的执行，性能更高。

Hibernate单向多对多

Hibernate单向多对多 -电脑资料2019-01-01最近做一个OA系统，用到了Hibernate框架，我发现，权限和角色的关系是一种多对多的关系，一个权限可以分配给多个角色，一个角色拥有多个权限，。

多对多关系有两种，一种是单向的，一种是多向的。

对于这个问题，曾经让我很犯难。

单纯在语言上理解，会比较复杂，而从代码上理解，可能就会明白了。

下面模拟为角色授权的过程：1，Hibernate使用Annotation2，使用Junit进行测试。

3，使用Mysql作为后台数据库。

4，Hibernate不使用自动建表，也不采用反向工程。

过程：1，建表：数据表结构采用如图所示：SQL语句：?1234567891011121314151617CREATE TABLErole( #角色表RoleId INT PRIMARY KEY AUTO_INCREMENT , #角色IDRoleName VARCHAR(20) NOT NULL #角色名称) ;CREATE TABLEprivilege( #权限表PrivilegeId INT PRIMARY KEY , #权限IDPrivilegeName VARCHAR(45) NOT NULL #权限表) ;CREATE TABLE privilege_role( #权限_角色中间表RoleId INT ,PrivilegeId INT ,PRIMARY KEY (RoleId,PrivilegeId) ,CONSTRAINT fk_privilege_role FOREIGN KEY(RoleId) REFERENCES role(RoleId) ,CONSTRAINT fk_role_privilege FOREIGN KEY(PrivilegeId) REFERENCES privilege(PrivilegeId)) ;2，hibernate.cfg.xml文件：?123456789101112131415com.mysql.jdbc.Driverjdbc:mysql://localhost:3306/hibernaterootxxxxorg.hibernate.dialect.MySQL5InnoDBDialect true。

Hibernate一对多、一对一、多对多映射

一、一对多/多对一1.确定谁是一方，谁是多方。

某表的主键在另一表中为外键，则某表为一方。

如学生和班级的对应关系，一个班级对应多个学生，所以班级为一方，学生为多方。

2.一方和多方po中部分代码的书写ClassInfo一方：set<多方类型> 的属性代码如：private Set<Student> stuSet;Student多方:一方类型的属性注意：不写外键字段。

代码如：private ClassInfo classInfo;3、配置ClassInfo一方：<set name="student" > 子元素：<key column="哪个字段是别人的外键(class_id)" /> <one-to-many class=”Student”></set>Student多方：<many-to-one name="classInfo" class="ClassInfo"column="class_id" >4、测试添加记录时的dao一部分代码ClassInfo c=new ClassInfo();c.setCname("aaa");Student s=new Student();s.setStuName("gsc");s.setAge(12);s.setEmail("gsc@");Set<Student> stuSet=new HashSet<Student>();stuSet.add(s);c.setStuSet(stuSet);Session session = HibUtil.getSession();Transaction tx = session.beginTransaction();session.save(c);mit();session.close();二一对一1.外键关联：一对多的基础上在外键字段上加个唯一约束构成1对1的关系。

Hibernate(V)——一对多与多对多关联关系映射(xml与注解)总结

Hibernate(V)——一对多与多对多关联关系映射(xml与注解)总结引言简要介绍Hibernate框架以及关联关系映射在数据库设计中的重要性。

Hibernate关联关系映射概述关联关系的重要性讨论在现实世界中对象间关系的重要性以及如何在数据库中表示这些关系。

Hibernate关联关系类型列举Hibernate支持的关联关系类型，包括一对一、一对多、多对一和多对多。

一对多关联关系映射概念解释解释一对多关联关系的概念，例如一个部门拥有多个员工。

XML映射方式详细描述如何在XML映射文件中配置一对多关联关系。

实体类定义展示一对多关系中实体类的Java代码示例。

XML映射文件提供一对多关系映射的XML配置示例。

注解映射方式详细描述如何使用注解配置一对多关联关系。

实体类定义展示使用注解的一对多关系中实体类的Java代码示例。

注解配置提供一对多关系映射的注解配置示例。

多对多关联关系映射概念解释解释多对多关联关系的概念，例如学生和课程之间的关联。

XML映射方式详细描述如何在XML映射文件中配置多对多关联关系。

实体类定义展示多对多关系中实体类的Java代码示例。

XML映射文件提供多对多关系映射的XML配置示例。

注解映射方式详细描述如何使用注解配置多对多关联关系。

实体类定义展示使用注解的多对多关系中实体类的Java代码示例。

注解配置提供多对多关系映射的注解配置示例。

关联关系映射的高级特性级联操作讨论级联保存、更新和删除的概念及其配置。

双向关系管理解释如何管理双向关联关系，确保数据的一致性。

延迟加载与即时加载讨论延迟加载和即时加载的概念及其在关联关系中的应用。

实践案例分析一对多关联关系案例通过一个具体的一对多关联关系案例，展示映射配置和数据操作。

多对多关联关系案例通过一个具体的多对多关联关系案例，展示映射配置和数据操作。

常见问题与解决方案一对多关联关系常见问题列举一对多关联关系映射中可能遇到的问题及其解决方案。

hibernate关系映射注解配置

1. Hibernate Annotation关系映射有下面几种类型：1)一对一外键关联映射（单向）2)一对一外键关联映射（双向）3)一对一主键关联映射（不重要，有需要看下文档即可）在实际中很少用，使用注解@PrimaryKeyJoinColumn意思是说，我的主键去参考另外一张表中的主键，作为我的主键，但是在我测试使用注解一对一主键关联映射，在生成表的时候，数据库中并没有生成关联，使用XML映射可以生成。

Annotation注解一对一主键关联映，有些bug。

不过没空去研究它。

因为在实际开发中一对一很少用。

在实际开发中我机会没有用过，主键关联就更少了4)多对一关联映射（单向）5)一对多关联映射（单向）6)一对多关联映射（双向）7)多对多关联映射（单向）8)多对多关联映射（双向）2.介绍各种映射用法1）一对一外键关联映射（单向）Husband ---> Wifepublic class Husband{private Wife wife;@OneToOne(cascade=CascadeType.ALL)@JoinColumn(name="wife_id",unique=true)public Wife getWife(){…}…}public class Wife{}一对一外键关联，使用@OneToOne，并设置了级联操作@JoinColum设置了外键的名称为wife_id（数据库字段名），如果不设置，则默认为另一类的属性名+ _id外键的值是唯一的(unique)，不可重复，与另一类的主键一致2）一对一外键关联映射（双向）Husband <---> Wifepublic class Husband{private Wife wife;@OneToOne(cascade=CascadeType.ALL)@JoinColumn(name="wife_id",unique=true)public Wife getWife(){…}...}public class Wife{private Husband husband;@OneToOne(mappedBy="wife",cascade=CascadeType.ALL)public Husband getHusband(){…}...}一对一双向关联关系，使用@OneToOne注意：需要加上mappedBy="wife"，如果不加上的话，Wife也会生成一个外键（husband_id）。

hibernate映射关系讲解

Hibernate框架Hibernate接口Configuration接口用于Hibernate的配置，读取配置文件创建SessionFactory。

SessionFactory接口用于产生Session对象，一个SessionFactory代表一个数据库Session接口提供对数据持久对象的操作的方法，可以看成一个缓冲区，hibernate可以自动检测缓冲区的持久对象是否已经改变，并及时刷新数据库，以保证Session中的对象和数据一致。

Transaction接口在hibernate轻量级框架中，不依赖于容器而是自己的API来调用底层事务API如JDBCAPI 、JTA做到事务处理的目的。

Query和Criteria接口Query接口提供对数据库及持久对象进行查询的方法，Criteria接口提供面向对象的标准化查询Hibernate对象-关系映射主要讲一下关联关系映射一对一（主键关联）两个实体域对象一个是客户类Customer 一个是客户身份正信息类IdCard关系一对一的下例讲解一对一主键关联类图结构数据库表的结构从类图可以看出一对一主键关联的 Customer 类中有IdCard 的一个对象属性 IdCard 类中有Customer 的一个对象属性、这就是你中有我我中有你数据库中都有一个C_ID 的字段映射配置文件<?xml version ="1.0" encoding ="UTF-8"?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd" > <hibernate-mapping > <class name ="类路径" table ="对应的表名"> <id name ="c_id" type ="ng.Integer"> <column name ="C_ID"/><generator class ="assigned"/></id ><property name ="name" type ="ng.String" column ="NAME"/> <one-to-one name ="对方包含在本方中的属性名称idCard" class ="类路径"cascade ="all"/></class ></hibernate-mapping >上面是Customer 类的映射文件其中要包含一个one to one 的节点IdCard类的映射文件<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd" ><hibernate-mapping><class name="类路径" table="对应的表名"><id name="c_id" type="ng.Integer"><column name="C_ID"/><generator class="foreign"><param name="property">本类中的对方类名称customer</param> </generator></id><property name="carNo" type="ng.String"column="CARDNO"/><one-to-one name="对方包含在本方中的属性名称customer" class="类路径"constrained="true"/></class></hibernate-mapping>配置文件就完了由于是一对一的主键关联IdCard类的主键需要通过Customer类的主键来生成，所以在IdCard的映射文件中是试用foreign生成其中param 指定IdCard类中所引用的属性这里说的是Customer业务类调用的代码片段Customer cs = new Customer();cs.setC_id(1);cs.setName(“lifei”);IdCard idCard = new IdCard();idCard.setCarNo(“510125……”);cs.setIdCard(idCard);idCard.setCustomer(cs);ts = session.beginTransaction();session.save(cs);mit();执行过后到数据库中就可以看出我们并没有保存IdCard 但是同样在数据库中可以找到IdCard 的记录这就是一对一主键关联的配置放发一对一唯一外键关联类图跟一对一主键关联没有区别数据库表Customer映射文件<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd" ><hibernate-mapping><class name="类路径" table="对应的表名"><id name="c_id" type="ng.Integer"><column name="C_ID"/><generator class="assigned"/></id><property name="name" type="ng.String" column="NAME"/><many-to-one name="对方包含在本方中的属性名称idCard" class="类路径"cascade="all"/></class></hibernate-mapping>注意这里是many-to-one了IdCard映射文件<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd" ><hibernate-mapping><class name="类路径" table="对应的表名"><id name="id" type="ng.Integer"><column name="ID"/><generator class="foreign"/></id><property name="carNo" type="ng.String"column="CARDNO"/><one-to-one name="对方包含在本方中的属性名称customer" class="类路径"Property-ref=”idCard”/></class></hibernate-mapping>在one-to-one时要指明Customer类中的idCard属性，表明需要通过外加加载业务类调用的代码片段Customer cs = new Customer();cs.setC_id(1);cs.setName(“lifei”);IdCard idCard = new IdCard();IdCard.setId(1);idCard.setCarNo(“510125……”);cs.setIdCard(idCard);idCard.setCustomer(cs);ts = session.beginTransaction();session.save(cs);mit();比起主键关联就多了行代码为IdCard设置ID 生成的SQL语句会有三句多对一关联实体客户和订单的关系类图表结构图在customer 的配置文件中就配置id 和单个属性的映射就可以了不存在什么many-to-one 或者其他表示关系的节点在多方order中<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd" ><hibernate-mapping><class name="类路径" table="对应的表名"><id name="id" type="ng.Integer"><column name="ID"/><generator class="foreign"/></id><property name="orderNo" type="ng.String"column="CARDNO"/><many-to-one name="对方包含在本方中的属性名称customer" class="类路"column="C_ID"/></class></hibernate-mapping>在多方中配置many-to-one节点column就只指定数据库中外键的映射这里是单向的关系还有一种单向的配置关系就是多方配置到了一方上那就是一对多类图数据库多方hbm配置文件中的内容很简单就是对其自身属性的一个映射（这里的多方是ORDER）一方的配置文件也是先将自的属性先映射后用Set来映射<set name="一方中包含的多方属性名称order" table="ORDER" cascade="all"> <key column="C_ID外键"/><one-to-many class="一方包含多方对象的类路径"/></set>这个就是对一方的配置以上两种都是一对多多对一的单向映射还有一种就是双向的类图数据库数据库结构不变配置文件是讲上面2中的结合一方中<set name="一方中包含的多方属性名称order" table="ORDER" cascade="all"> <key column="C_ID外键"/><one-to-many class="一方包含多方对象的类路径"/></set>多方中<many-to-one name="对方包含在本方中的属性名称customer" class="类路"column="C_ID"/>这就行成了双向的关系多对多假如有2个类一个Customer 类一个Server 类典型的多对多关系类图数据库数据库表也是典型的多对多关系表多对多是三张表中间的只有主键被引用的就是中间表，就是靠这个来维持两个对象之间的关系也是两个HBM配置文件Customer中其他的本身属性映射不变<set name="多方中包含的多方属性名称server" table="中间表"cascade="save-update"><key column="C_ID中间表引用的字段"/><many-to-many class="对方的类路径" column="S_ID对方的主键"/> </set>Set节点下的写法Server中其他的本身属性映射不变<set name="多方中包含的多方属性名称customer" table="中间表"cascade="save-update"><key column="S_ID中间表引用的字段"/><many-to-many class="对方的类路径" column="C_ID对方的主键"/> </set>那么多对多的关系配置就是这样的上面只是简单的阐述了hibernate的集中映射关系其他的比如还有继承映射继承映射属于高级部分就不在本篇文章中提到了总结Hibernate中可以使用Set、List、Map 进行集合映射为了进行Set映射需要试用<Set>标签List要在映射文件中使用<index>来说明下标位置Map与List类似在关系数据库中只存在外间参照关系，且总是从多方参照一方，这样的好处是消除数据冗余一对一主键关联是让两个对象具有相同的主键值，以表明他们是一对一的关系如果加上唯一性的限制后，外间关联也可以用于一对一的关联关系外键关联多用于多对多映射为了避免一方的更新操作造成数据库同步更新多方，在一对多的关联情况下一端的inverse 属性设置为true多对多关联关系可以通过中间表映射的方式实现。

Hibernate多对多关联映射

7.
<id name="id">
8.
<generator class="native"></generator>
3 / 10
9.
</id>
10.
<property name="name"></property>
11. </class>
12. </hibernate-mapping>
生成的表结构和测试数据
8.
return id;
9. }
2 / 10
10. public void setId(int id) {
11.
this.id = id;
12. }
13. public String getName() {
14.
return name;
15. }
16. public void setName(String name) {
8.
9. private Set roles;
10.
11. public int getId() {
12.
return id;
13. }
14. public void setId(int id) {
15.
this.id = id;
16. }
17. public Set getRoles() {
18.
4 / 10
多对多关联映射，在实体类中，跟一对多关联映射一样，也是用集合来表示的。<set>标签中用 table 属性重命名中间表名称，<key>标签定义当前表的主键，用<many-to-many>标签来关联另一张表。双向的多对多关联映射（双向 User<--->Role）对象模型

Java EE轻量级框架应用开发第6章 Hibernate的关联映射

Hibernate: insert into shop.rucedrO
Osrtdoemre=rn(nawe Omred)evalues;)(r (?)
Order.setOrderNumber("0001");
Hibernate: update shop.O/r/d关er联se订t 单cu和 st客 ome户r_id=?, orderNumber=?, price=? where id=?
· true：一直使用外连接来抓取关联 · false：永远不使用外连接来抓取关联 · ⑥ update、insert（可选，默认为true）：指定对应的字段是否在用于 UPDATE和/或INSERT的SQL语句中包含。如果二者都是false，则这是一个纯粹的“衍生（Derived）”关联，它的值是通过映射到同一个（或多个）字段的某些其他属性得到的，或者通过Trigger（触发器），或者其他程序 · ⑦ property-ref：（可选）：指定关联类的一个属性，这个属性将会和本外键相对应。如果没有指定，会使用对方关联类的主键
也会对所关联的持久化对象执行evict()和lock()操作 · delete-orphan ：删除所有和当前对象解除关联关系的对象 · all-delete-orphan ：包含all 和delete-orphan的行为
· outer-join（外连接）（可选，默认为自动）：当设置 e_outer_join时，对这个关联允许外连接抓取。outer-join参数允下列3个不同值 · auto（默认）：如果被关联的对象没有代理（Proxy），使用外连接抓取关联（对象）
新当时对象时,级联保存所有关联的新建的临时对象,并且级联更新所有关联的游离对象 · delete：当通过Session 的delete()方法删除当前对象时,级联删除所有关联的对象

hibernate单双向关联、数据库乱码、主外键关系等

hibernate单双向关联、数据库乱码、主外键关系等1、首先解释什么是单向一对多关联和双向一对多关联在Hibernate中用的最多的就是一对多(多对一)的关系，这是根据现实情况抽象而出，也是符合面向对象的思想的。

下面我来解释一下单向、双向两种关联关系的关系。

(1)单向一对多关系：单向关联就是在一张表中可以查到另外一张表的信息，但反过来查就不行了，即引用外键的一方可以查到另一方的信息。

举个例子：有个user表，还有个group表，它们是多对一关系。

在数据库里，user表会有一个group_id字段，是个外键，用来指向group表的id，但在实体类里，如果你只配了多对一单向，即只配置了user表里的多对一关系，那你查询的时候可以这样查，select u.group from User u where ="张三"，但你不能这样查，select ers from Group g where ="管理员" 。

(2)双向一对多关系：还是那个例子，如果你在hibernate的映射文件中配置了双向关联关系，那么上面的sql语句就都可以查询到结果。

在实际应用中，推荐使用双向关联关系。

原因如下：(1)、使用双向关联效率高于单向关联(hibernate不用发出多余的update语句)。

(2)、没有sql语句的限制。

2、双向一对多关联中inverse的作用hibernate中默认inverse="false",一般将inverse设置为true,将主外键的关系维护交给多的一方维护，这个很容易理解：在一个班级中，是老师认识班上的所有同学容易还是同学认识老师容易。

3、解决hibernate存储汉字在mysql数据库乱码问题在hibernate的配置文件中设置编码格式：<propertyname="hibernate.connection.url">jdbc:mySQL://localhost:3306/ oa?useUnicode=true&characterEncoding=GBK</property> 然后打开sql命令窗口，输入：set names gbk; 即可。

Hibernate 注解方式配置多对多

Hibernate 注解方式配置多对多,学生，课程，学生与课程的关联，配置后会自动生成三张表。

恩根据经验应该是这样的，代码是转的，哪个敢扔我。

要转就转全吧，方便大家学习，呵呵。

学生：package com.hibernate.many2many;import java.util.Set;import javax.persistence.CascadeType;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Id;import javax.persistence.JoinColumn;import javax.persistence.JoinTable;import javax.persistence.ManyToMany;import javax.persistence.Table;@Entity@Table(name="t_student")public class Student {@Id@GeneratedValueprivate Integer id;private String name;@ManyToMany(targetEntity=com.hibernate.many2many.Course.class ,cascade={CascadeType.MERGE,CascadeType.PERSIST})@JoinTable(name="student_course",joinColumns={@JoinColumn(name="student_id")},inverseJoinColumns={@JoinColumn(name="course_id")})private Set course;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}public Set getCourse() {return course;}public void setCourse(Set course) {this.course = course;}}课程package com.hibernate.many2many;import java.util.Set;import javax.persistence.CascadeType; import javax.persistence.Entity;import javax.persistence.GeneratedValue; import javax.persistence.Id;import javax.persistence.ManyToMany;import javax.persistence.Table;@Entity@Table(name="t_course")public class Course {@Id@GeneratedValueprivate Integer id;private String name;@ManyToMany(cascade={CascadeType.PERSIST,CascadeType.MERGE},mappedBy="course",targetEntity=com.hibernate.many2many.Student.class)private Set student;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}public Set getStudent() {return student;}public void setStudent(Set student) {this.student = student;}}测试类：public void testsave2(){Session session = null;try{session = HibernateUtil.getSession();session.beginTransaction();Student s = new Student();Student s2 = new Student();Grade g = new Grade();g.setName("g2");s.setGrade(g);s.setName("long2");s2.setName("long3");s2.setGrade(g);session.save(g);session.save(s);session.save(s2);session.getTransaction().commit();}catch(Exception e){session.getTransaction().rollback();e.printStackTrace();}}。

Hibernate中用注解配置一对多双向关联和多对一单向关联

Hibernate中⽤注解配置⼀对多双向关联和多对⼀单向关联Hibernate中⽤注解配置⼀对多双向关联和多对⼀单向关联Hibernate提供了Hibernate Annotations扩展包，使⽤注解完成映射。

在Hibernate3.3之前，需单独下载注解开发包配置持久化类配置关联关系下⾯我们先从多对⼀单向关联关系讲起，多对⼀单向关联就是在多的⼀⽅植⼊⼀的⼀⽅的主键作为外键，下⾯我们先进⾏初始配置，在配置的过程中我们会遇到⼀个问题就是⽆论⽤load还是get都不会出现延迟加载，那么我们应该如何设置为要延迟加载，这样做的好处是可以在⽤的时候才加载对应的信息，节约内存中，延迟加载⼤致可以分为两类，⼀类是延迟属性加载，另⼀类是延迟关联实体加载。

普通属性：分两种情况，⼀种是集合属性，⼀种是⾮集合属性（如String、Integer......）集合属性的延迟加载通过PersistentSet、 PersistentList、PersistentBag、PersistentMap、PersistentSortedMap、 PersistentSortedSet作为代理类来实现，代理类中保存了session以及owner属性，owner属性表⽰了集合属性所属的one 侧的实体。

⾮集合类属性的延迟加载相对⽐较复杂。

仅通过@Basic(fetch = ZY)注解是⽆法实现延迟加载的。

需要让实体实现FieldHandled接⼝，声明FieldHandler属性，通过拦截器原理注⼊对应的FieldHandler属性，起到类似于上述代理类的作⽤，FieldHandler 同样也保持了session，以及需要延迟加载的属性。

我们发现对⾮集合属性即时设置了@Basic(fetch = ZY)仍⽆法实现延迟加载，可以看⽣成的sql语句接下来我们会对⼀对多单向关联进⾏测试，验证对集合类属性，是否可以起到延迟加载的功能注意：不可以对有关联关系的属性设置@Transient配置多对⼀的单向关联关系⽰例1 package cn.happy.entity;23 import javax.persistence.Basic;4 import javax.persistence.Column;5 import javax.persistence.Entity;6 import javax.persistence.FetchType;7 import javax.persistence.GeneratedValue;8 import javax.persistence.GenerationType;9 import javax.persistence.Id;10 import javax.persistence.JoinColumn;11 import javax.persistence.ManyToOne;12 import javax.persistence.SequenceGenerator;13 import javax.persistence.Table;14 import javax.persistence.Transient;1516 @Entity17 @Table(name = "EMP")18public class Emp {19 @Id20 @Column(name = "EMPNO")21 @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "emp_num")22 @SequenceGenerator(name = "emp_num", sequenceName = "emp_num_id", allocationSize = 1, initialValue = 1)23private Integer empNo;2425 @Column(name = "EMPNAME")26private String empName;2728 @ManyToOne()29 @JoinColumn(name = "DEPTNO")30/*@Basic(fetch=ZY)*/31private Dept dept;323334public Emp() {35 super();36 }3738public Emp(Integer empNo, String empName) {39 super();40this.empNo = empNo;41this.empName = empName;42 }4344public Integer getEmpNo() {45return empNo;46 }4748public void setEmpNo(Integer empNo) {49this.empNo = empNo;50 }5152public String getEmpName() {5556public void setEmpName(String empName) {57this.empName = empName;58 }5960public Dept getDept() {61return dept;62 }6364public void setDept(Dept dept) {65this.dept = dept;66 }67 }1package cn.happy.entity;23import java.util.HashSet;4import java.util.Set;56import javax.persistence.CascadeType;7import javax.persistence.Column;8import javax.persistence.Entity;9import javax.persistence.GeneratedValue;10import javax.persistence.GenerationType;11import javax.persistence.Id;12import javax.persistence.JoinColumn;13import javax.persistence.OneToMany;14import javax.persistence.SequenceGenerator;15import javax.persistence.Table;16import javax.persistence.Transient;1718import org.hibernate.annotations.Cascade;1920 @Entity21 @Table(name = "DEPT")22public class Dept {23 @Id24 @Column(name = "DEPTNO")25 @GeneratedValue(strategy=GenerationType.SEQUENCE,generator="dept_num")26 @SequenceGenerator(name="dept_num",sequenceName="dept_num_no",allocationSize=1,initialValue=1) 27private Integer deptNo;2829 @Column(name = "DEPTNAME")30private String deptName;313233public Integer getDeptNo() {34return deptNo;35 }3637public void setDeptNo(Integer deptNo) {38this.deptNo = deptNo;39 }4041public String getDeptName() {42return deptName;43 }4445public void setDeptName(String deptName) {46this.deptName = deptName;47 }48 }1/**2 * 注解测试多对⼀映射员⼯表（多）对应部门表（⼀）的映射,即只在员⼯表中植⼊部门表的信息3 * */4 @Test5public void manytooneSingle(){67/**8 * 查询操作9 * **/10/*SessionFactory sf=new AnnotationConfiguration().configure().buildSessionFactory();11 Session session = sf.openSession();1213 Emp emp=(Emp)session.load(Emp.class, 4);1415 System.out.println(emp.getEmpName()+"\t"+emp.getDept().getDeptName());*/1617/**20 SessionFactory sf=new AnnotationConfiguration().configure().buildSessionFactory();21 Session session = sf.openSession();22 Transaction tx = session.beginTransaction();23 Dept dept = (Dept)session.load(Dept.class, 3);2425 Emp emp=new Emp();26 emp.setEmpName("户梦艳");27 emp.setEmpNo(001);28 emp.setDept(dept);2930 Emp emp2=new Emp();31 emp2.setEmpName("户梦艳2");32 emp2.setEmpNo(002);33 emp2.setDept(dept);3435 session.save(emp);36 session.save(emp2);37 mit();38 session.close();394041 }⼀对多双单向配置1 package cn.happy.entity;23 import java.util.HashSet;4 import java.util.Set;56 import javax.persistence.CascadeType;7 import javax.persistence.Column;8 import javax.persistence.Entity;9 import javax.persistence.GeneratedValue;10 import javax.persistence.GenerationType;11 import javax.persistence.Id;12 import javax.persistence.JoinColumn;13 import javax.persistence.OneToMany;14 import javax.persistence.SequenceGenerator;15 import javax.persistence.Table;16 import javax.persistence.Transient;171819 @Entity20 @Table(name="Dept")21public class Dept {22 @Id23 @GeneratedValue(strategy=GenerationType.SEQUENCE,generator="dept_num")24 @SequenceGenerator(name="dept_num",sequenceName="dept_num_no",allocationSize=1,initialValue=1) 25private Integer deptNo;26 @Column27private String deptName;282930 @OneToMany(cascade={CascadeType.ALL})31 @JoinColumn(name="deptno")32private Set<Emp> emps=new HashSet<Emp>();3334public Set<Emp> getEmps() {35return emps;36 }3738public void setEmps(Set<Emp> emps) {39this.emps = emps;40 }4142public Integer getDeptNo() {43return deptNo;44 }4546public void setDeptNo(Integer deptNo) {47this.deptNo = deptNo;48 }4950public String getDeptName() {51return deptName;52 }5354public void setDeptName(String deptName) {55this.deptName = deptName;57 }1 package cn.happy.entity;23 import javax.persistence.Basic;4 import javax.persistence.Column;5 import javax.persistence.Entity;6 import javax.persistence.FetchType;7 import javax.persistence.GeneratedValue;8 import javax.persistence.GenerationType;9 import javax.persistence.Id;10 import javax.persistence.JoinColumn;11 import javax.persistence.ManyToOne;12 import javax.persistence.SequenceGenerator;13 import javax.persistence.Table;14 import javax.persistence.Transient;1516 import org.hibernate.bytecode.javassist.FieldHandled;17 import org.hibernate.bytecode.javassist.FieldHandler;181920 @Entity21 @Table(name = "EMP")22public class Emp {23242526 @Id27 @GeneratedValue(strategy=GenerationType.SEQUENCE,generator="emp_num")28 @SequenceGenerator(name="emp_num",sequenceName="emp_num_no",allocationSize=1,initialValue=9) 29private Integer empNo;3031 @Column32private String empName;333435// @ManyToOne36// @JoinColumn(name="deptno")37// @Basic(fetch=ZY)38// private Dept dept;39//40// public Dept getDept() {41// return dept;42// }43//44// public void setDept(Dept dept) {45// this.dept = dept;46// }4748public Emp() {49 super();50 }5152public Emp(Integer empNo, String empName) {53 super();54this.empNo = empNo;55this.empName = empName;56 }5758public Integer getEmpNo() {59return empNo;60 }6162public void setEmpNo(Integer empNo) {63this.empNo = empNo;64 }6566public String getEmpName() {67return empName;68 }6970public void setEmpName(String empName) {71this.empName = empName;72 }737475 }2 * 测试⼀对多单向添加操作3 * */4 @Test5public void insertOneToManySingle(){6 Emp emp=new Emp();7 emp.setEmpName("李⼩鹏");89 Emp emp2=new Emp();10 emp2.setEmpName("王想想");1112 Dept dept=new Dept();13 dept.setDeptName("教务部");14//设置级联操作15 dept.getEmps().add(emp);16 dept.getEmps().add(emp2);1718 session.save(dept);19 mit();20 System.out.println("insert ok");2122 }1/**2 * 测试⼀对多单向查询操作3 * */4 @Test5public void selectOneToManySingle(){6 Dept dept = (Dept)session.load(Dept.class, 1);7 System.out.println("======================");8 System.out.println("部门名称:"+dept.getDeptName());9 System.out.println("=======================");10//体现了延迟加载11for (Emp emp : dept.getEmps()) {12 System.out.println("雇员名称："+emp.getEmpName());13 }14//Emp emp = (Emp)session.load(Emp.class, 1);151617 }⼀对多双向配置1 package cn.happy.entity;23 import java.util.HashSet;4 import java.util.Set;56 import javax.persistence.CascadeType;7 import javax.persistence.Column;8 import javax.persistence.Entity;9 import javax.persistence.GeneratedValue;10 import javax.persistence.GenerationType;11 import javax.persistence.Id;12 import javax.persistence.JoinColumn;13 import javax.persistence.OneToMany;14 import javax.persistence.SequenceGenerator;15 import javax.persistence.Table;16 import javax.persistence.Transient;171819 @Entity20 @Table(name="Dept")21public class Dept {22 @Id23 @GeneratedValue(strategy=GenerationType.SEQUENCE,generator="dept_num")24 @SequenceGenerator(name="dept_num",sequenceName="dept_num_no",allocationSize=1,initialValue=1) 25private Integer deptNo;26 @Column27private String deptName;282930 @OneToMany(mappedBy="dept",cascade={CascadeType.ALL})3132private Set<Emp> emps=new HashSet<Emp>();3340 }4142public Integer getDeptNo() {43return deptNo;44 }4546public void setDeptNo(Integer deptNo) {47this.deptNo = deptNo;48 }4950public String getDeptName() {51return deptName;52 }5354public void setDeptName(String deptName) {55this.deptName = deptName;56 }57 }1 package cn.happy.entity;23 import javax.persistence.Basic;4 import javax.persistence.Column;5 import javax.persistence.Entity;6 import javax.persistence.FetchType;7 import javax.persistence.GeneratedValue;8 import javax.persistence.GenerationType;9 import javax.persistence.Id;10 import javax.persistence.JoinColumn;11 import javax.persistence.ManyToOne;12 import javax.persistence.SequenceGenerator;13 import javax.persistence.Table;14 import javax.persistence.Transient;1516 import org.hibernate.bytecode.javassist.FieldHandled;17 import org.hibernate.bytecode.javassist.FieldHandler;181920 @Entity21 @Table(name = "EMP")22public class Emp {23242526 @Id27 @GeneratedValue(strategy=GenerationType.SEQUENCE,generator="emp_num")28 @SequenceGenerator(name="emp_num",sequenceName="emp_num_no",allocationSize=1,initialValue=9) 29private Integer empNo;3031 @Column32private String empName;333435 @ManyToOne36 @JoinColumn(name="deptno")37 @Basic(fetch=ZY)38private Dept dept;3940public Dept getDept() {41return dept;42 }4344public void setDept(Dept dept) {45this.dept = dept;46 }4748public Emp() {49 super();50 }5152public Emp(Integer empNo, String empName) {53 super();54this.empNo = empNo;55this.empName = empName;56 }5764 }6566public String getEmpName() {67return empName;68 }6970public void setEmpName(String empName) {71this.empName = empName;72 }737475 }1/**2 * 双向⼀对多的添加操作3 * */4 @Test5public void oneToManyDouble(){6 Dept dept=new Dept();7 dept.setDeptName("财务部");89 Emp emp=new Emp();10 emp.setEmpName("邹乐");11 emp.setDept(dept);1213 Emp emp2=new Emp();14 emp2.setEmpName("范⼦阳");15 emp2.setDept(dept);161718 dept.getEmps().add(emp);19 dept.getEmps().add(emp2);2021 session.save(dept);22 mit();23 }241/**2 * 双向⼀对多的查询操作3 * */4 @Test5public void selectOneToManyDouble(){67 Dept dept = (Dept)session.load(Dept.class, 1);8 System.out.println("部门名称："+dept.getDeptName());9for (Emp emp : dept.getEmps()) {10 System.out.println("职⼯姓名："+emp.getEmpName());11 }1213 System.out.println("==================================================");1415 Emp emp = (Emp)session.load(Emp.class, 1);16 System.out.println("职⼯姓名："+emp.getEmpName()+"\t部门名称："+emp.getDept().getDeptName());17 }18。

Hibernate_关联关系映射

Hibernate关联关系映射配置 (2)一、一对一单向外键关联： (2)1.1目录结构 (2)1.2 Annotation方式 (2)1.3 XML方式 (4)1.4 Hibernate配置文件 (7)二、一对一双向外键关联 (7)2.1 Annotation方式 (7)2.2 XML方式 (9)三、一对一单向主键关联（不重要） (12)3.1 Annotation方式 (12)3.2 XML方式 (14)四、一对一双向主键关联（不重要） (16)4.1 Annotation方式 (16)3.2 XML方式 (19)五、组件映射 (21)5.1 Annotation方式 (21)5.2 XML方式 (23)六、多对一单向关联 (25)6.1 Annotation方式 (25)6.2 XML方式 (27)七、一对多单向关联 (29)7.1 Annotation方式 (29)7.2 XML方式 (31)八、一对多、多对一双向关联 (34)8.1 Annotation方式 (34)8.2 XML方式 (36)九、多对多单向关联 (39)8.1 Annotation方式 (39)8.2 XML方式 (41)十、多对多双向关联 (44)8.1 Annotation方式 (44)8.2 XML方式 (46)Hibernate 关联关系映射配置一、一对一单向外键关联：1.1目录结构图1-1 目录结构图1.2 Annotation 方式1.2.1类图图1-2 类关联关系图1.2.2数据库表结构FK133651BB21A8E0C8H_HUSBAND_ID NAME WIFE_ID NUMBER(4)VARCHAR2(30 char)NUMBER(4)<pk><fk>H_WIFE_ID NAME NUMBER(4)VARCHAR2(30 char)<pk>图1-3数据库表结构图1.2.3 实体类package com.rongqq.hibernate3.annotation.entity;import java.math.BigDecimal;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.GenerationType;import javax.persistence.Id;import javax.persistence.OneToOne;import javax.persistence.SequenceGenerator;@Entity(name="H_HUSBAND_")@SequenceGenerator(name="husband_seq_gene", sequenceName="HUSBAND_SEQ", allocationSize=1) public class Husband {private BigDecimal id;private String name;private Wife wife;@Id@Column(precision=4, scale=0)@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="husband_seq_gene")public BigDecimal getId() {return id;}@Column(length=30)public String getName() {return name;}@OneToOne//@JoinColumn(name="wife_id")//不写也没问题，自动生成的字段也叫wife_idpublic Wife getWife() {return wife;}public void setId(BigDecimal id) {this.id = id;}public void setName(String name) { = name;}public void setWife(Wife wife) {this.wife = wife;}}package com.rongqq.hibernate3.annotation.entity;import java.math.BigDecimal;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.GenerationType;import javax.persistence.Id;import javax.persistence.SequenceGenerator;@Entity(name="H_WIFE_")@SequenceGenerator(name="wife_seq_gene", sequenceName="WIFE_SEQ")public class Wife {private BigDecimal id;private String name;@Id@Column(precision=4)@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="wife_seq_gene")public BigDecimal getId() {return id;}public void setId(BigDecimal id) {this.id = id;}@Column(length=30)public String getName() {return name;}public void setName(String name) { = name;}}1.3 XML方式1.3.1 类图图1-4 类关联关系图1.3.2 数据库表结构FKBE32645CF8BD16F4H_HUSBAND_XMLID NAME WIFE_ID NUMBER(4)VARCHAR2(30 char)NUMBER(19,2)<pk><ak,fk>H_WIFE_XMLID NAME NUMBER(4)VARCHAR2(30 char)<pk>图1-5数据库表结构图1.3.3 实体类package com.rongqq.hibernate3.xml.entity; import java.math.BigDecimal; public class XML_Husband { private BigDecimal id ; private String name ; private XML_Wife wife ; public BigDecimal getId() { return id ;}public String getName() { return name ; }public XML_Wife getWife() { return wife ; }public void setId(BigDecimal id) { this .id = id; }public void setName(String name) { this .name = name; }public void setWife(XML_Wife wife) { this .wife = wife; }}package com.rongqq.hibernate3.xml.entity; import java.math.BigDecimal; public class XML_Wife { private BigDecimal id ; private String name ; public BigDecimal getId() { return id ;}public void setId(BigDecimal id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}}1.3.4 对象关系映射文件<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd"><hibernate-mapping package="com.rongqq.hibernate3.xml.entity"><class name="XML_Husband"table="H_HUSBAND_XML"dynamic-update="true"><id name="id"type="big_decimal"><column name="id"precision="4"scale="0" /><generator class="sequence"><param name="sequence">H_STUDENT_SEQ_XML</param></generator></id><property name="name"length="30"></property><many-to-one name="wife"column="wife_id"unique="true"not-null="true" /> </class></hibernate-mapping><?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd"><hibernate-mapping package="com.rongqq.hibernate3.xml.entity"><class name="XML_Wife"table="H_Wife_XML"dynamic-update="true"><id name="id"><column name="id"precision="4"scale="0" /><generator class="sequence"><param name="sequence">H_STUDENT_SEQ_XML</param></generator></id><property name="name"length="30" /></class></hibernate-mapping>1.4 Hibernate配置文件<?xml version='1.0'encoding='utf-8'?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/hibernate-configuration-3.0.dtd"><hibernate-configuration><session-factory><property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property><property name="connection.url">jdbc:oracle:thin:@127.0.0.1:1521:silence</property><property name="ername">cnuser</property><property name="connection.password">cn830306</property><property name="connection.pool_size">1</property><property name="current_session_context_class">thread</property><property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property><property name="show_sql">true</property><property name="format_sql">true</property><property name="dialect">org.hibernate.dialect.Oracle9Dialect</property><mapping class="com.rongqq.hibernate3.annotation.entity.Husband" /><mapping class="com.rongqq.hibernate3.annotation.entity.Wife" /><mapping resource="com/rongqq/hibernate3/xml/entity/XML_Husband.hbm.xml" /><mapping resource="com/rongqq/hibernate3/xml/entity/XML_Wife.hbm.xml" /> </session-factory></hibernate-configuration>二、一对一双向外键关联2.1 Annotation方式2.1.1 类图图2-1类关联关系图2.1.2 数据库结构图FK133651BB21A8E0C8H_WIFE_ID NAME NUMBER(4)VARCHAR2(30 char)<pk>H_HUSBAND_ID NAME WIFE_ID NUMBER(4)VARCHAR2(30 char)NUMBER(4)<pk><fk>图2-2数据库表结构图2.1.3 实体类@Entity(name="H_HUSBAND_")@SequenceGenerator(name="husband_seq_gene", sequenceName="HUSBAND_SEQ", allocationSize=1) public class Husband {private BigDecimal id;private String name;private Wife wife;@Id@Column(precision=4, scale=0)@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="husband_seq_gene")public BigDecimal getId() {return id;}@Column(length=30)public String getName() {return name;}@OneToOne//@JoinColumn(name="wife_id")//不写也没问题，自动生成的字段也叫wife_idpublic Wife getWife() {return wife;}public void setId(BigDecimal id) {this.id = id;}public void setName(String name) { = name;}public void setWife(Wife wife) {this.wife = wife;}}@Entity(name="H_WIFE_")@SequenceGenerator(name="wife_seq_gene", sequenceName="WIFE_SEQ")public class Wife {private BigDecimal id;private String name;private Husband husband;@Id@Column(precision=4)@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="wife_seq_gene")public BigDecimal getId() {return id;}public void setId(BigDecimal id) {this.id = id;}@Column(length=30)public String getName() {return name;}public void setName(String name) { = name;}@OneToOne(mappedBy="wife")public Husband getHusband() {return husband;}public void setHusband(Husband husband) {this.husband = husband;}}2.2 XML方式2.2.1 类图图2-3 类关联关系图2.2.2 数据库结构图FKBE32645CF8BD16F4H_WIFE_XMLID NAME NUMBER(4)VARCHAR2(30 char)<pk>H_HUSBAND_XMLID NAME WIFE_ID NUMBER(4)VARCHAR2(30 char) NUMBER(4,2)<pk><fk>2.2.3 实体类package com.rongqq.hibernate3.xml.entity;import java.math.BigDecimal;public class XML_Husband {private BigDecimal id;private String name;private XML_Wife wife;public BigDecimal getId() {return id;}public String getName() {return name;}public XML_Wife getWife() {return wife;}public void setId(BigDecimal id) {this.id = id;}public void setName(String name) { = name;}public void setWife(XML_Wife wife) {this.wife = wife;}}package com.rongqq.hibernate3.xml.entity;import java.math.BigDecimal;public class XML_Wife {private BigDecimal id;private String name;private XML_Husband husband;public BigDecimal getId() {return id;}public void setId(BigDecimal id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}public XML_Husband getHusband() {return husband;}public void setHusband(XML_Husband husband) {this.husband = husband;}}2.2.4 对象关系映射文件<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd"><hibernate-mapping package="com.rongqq.hibernate3.xml.entity"><class name="XML_Husband"table="H_HUSBAND_XML"dynamic-update="true"> <id name="id"type="big_decimal"><column name="id"precision="4"scale="0"/><generator class="sequence"><param name="sequence">H_STUDENT_SEQ_XML</param></generator></id><property name="name"length="30"></property><many-to-one name="wife"unique="true"not-null="true"><column name="wife_id"precision="4"></column></many-to-one></class></hibernate-mapping><?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd"><hibernate-mapping package="com.rongqq.hibernate3.xml.entity"><class name="XML_Wife"table="H_Wife_XML"dynamic-update="true"><id name="id"><column name="id"precision="4"scale="0"/><generator class="sequence"><param name ="sequence">H_STUDENT_SEQ_XML </param ></generator ></id ><property name ="name" length ="30" /><one-to-one name ="husband" property-ref ="wife" /></class > </hibernate-mapping >三、一对一单向主键关联（不重要）3.1 Annotation 方式3.1.1类图图3-1 类关联关系图3.1.2 数据库表结构H_WIFE_ID NAME NUMBER(4)VARCHAR2(30 char)<pk>H_HUSBAND_ID NAME NUMBER(4)VARCHAR2(30 char)<pk>图3-2 数据库表结构图3.1.3 实体类package com.rongqq.hibernate3.annotation.entity; import java.math.BigDecimal; import javax.persistence.Column; import javax.persistence.Entity;import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.OneToOne;import javax.persistence.PrimaryKeyJoinColumn; import javax.persistence.SequenceGenerator; @Entity (name="H_HUSBAND_")@SequenceGenerator (name="husband_seq_gene", sequenceName="HUSBAND_SEQ", allocationSize=1) public class Husband {private BigDecimal id ;private String name;private Wife wife;@Id@Column(precision=4, scale=0)@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="husband_seq_gene") public BigDecimal getId() {return id;}@Column(length=30)public String getName() {return name;}@OneToOne@PrimaryKeyJoinColumnpublic Wife getWife() {return wife;}public void setId(BigDecimal id) {this.id = id;}public void setName(String name) { = name;}public void setWife(Wife wife) {this.wife = wife;}}package com.rongqq.hibernate3.annotation.entity;import java.math.BigDecimal;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.GenerationType;import javax.persistence.Id;import javax.persistence.SequenceGenerator;@Entity(name="H_WIFE_")@SequenceGenerator(name="wife_seq_gene", sequenceName="WIFE_SEQ")public class Wife {private BigDecimal id;private String name;@Id@Column(precision=4)@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="wife_seq_gene") public BigDecimal getId() {return id;}public void setId(BigDecimal id) {this.id = id;}@Column(length=30)public String getName() {return name;}public void setName(String name) { = name;}}注：只生成了表，但是没有外键约束，具体实现还需要查找3.2 XML方式3.2.1 类图图3-3 类关联关系图3.2.2 数据库表结构FKBE32645CA8BE0706H_WIFE_XMLID NAME NUMBER(4)VARCHAR2(30 char)<pk>H_HUSBAND_XMLID NAME NUMBER(4)VARCHAR2(30 char)<pk,fk>图3-4 数据库表结构图3.2.3 实体类package com.rongqq.hibernate3.xml.entity;import java.math.BigDecimal;public class XML_Husband {private BigDecimal id;private String name;private XML_Wife wife;public BigDecimal getId() {return id;}public String getName() {return name;}public XML_Wife getWife() {return wife;}public void setId(BigDecimal id) {this.id = id;}public void setName(String name) { = name;}public void setWife(XML_Wife wife) {this.wife = wife;}}package com.rongqq.hibernate3.xml.entity;import java.math.BigDecimal;import com.rongqq.hibernate3.annotation.entity.Husband;public class XML_Wife {private BigDecimal id;private String name;public BigDecimal getId() {return id;}public void setId(BigDecimal id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}}3.2.4 对象映射文件<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd"><hibernate-mapping package="com.rongqq.hibernate3.xml.entity"><class name="XML_Husband"table="H_HUSBAND_XML"dynamic-update="true"> <id name="id"type="big_decimal"><column name="id"precision="4"scale="0"/><generator class="foreign"><param name="property">wife</param></generator></id><property name="name"length="30"></property><one-to-one name="wife"constrained="true"></one-to-one></class></hibernate-mapping><?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd"><hibernate-mapping package="com.rongqq.hibernate3.xml.entity"><class name="XML_Wife"table="H_Wife_XML"dynamic-update="true"><id name="id"><column name="id"precision="4"scale="0"/><generator class="sequence"><param name="sequence">H_STUDENT_SEQ_XML</param></generator></id><property name="name"length="30"/></class></hibernate-mapping>四、一对一双向主键关联（不重要）4.1 Annotation方式4.1.1 类图图4-1 类关联关系图4.1.2 数据库表结构H_WIFE_ID NAME NUMBER(4)VARCHAR2(30 char)<pk>H_HUSBAND_ID NAME NUMBER(4)VARCHAR2(30 char)<pk>图4-2 数据库表结构图4.1.3 实体类package com.rongqq.hibernate3.annotation.entity;import java.math.BigDecimal;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.GenerationType;import javax.persistence.Id;import javax.persistence.OneToOne;import javax.persistence.PrimaryKeyJoinColumn;import javax.persistence.SequenceGenerator;@Entity(name="H_HUSBAND_")@SequenceGenerator(name="husband_seq_gene", sequenceName="HUSBAND_SEQ", allocationSize=1) public class Husband {private BigDecimal id;private String name;private Wife wife;@Id@Column(precision=4, scale=0)@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="husband_seq_gene")public BigDecimal getId() {return id;}@Column(length=30)public String getName() {return name;}@OneToOne@PrimaryKeyJoinColumnpublic Wife getWife() {return wife;}public void setId(BigDecimal id) {this.id = id;}public void setName(String name) { = name;public void setWife(Wife wife) {this.wife = wife;}}package com.rongqq.hibernate3.annotation.entity;import java.math.BigDecimal;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.GenerationType;import javax.persistence.Id;import javax.persistence.OneToOne;import javax.persistence.PrimaryKeyJoinColumn;import javax.persistence.SequenceGenerator;@Entity(name="H_WIFE_")@SequenceGenerator(name="wife_seq_gene", sequenceName="WIFE_SEQ")public class Wife {private BigDecimal id;private String name;private Husband husband;@Id@Column(precision=4)@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="wife_seq_gene") public BigDecimal getId() {return id;}public void setId(BigDecimal id) {this.id = id;}@Column(length=30)public String getName() {return name;}public void setName(String name) { = name;}@OneToOne@PrimaryKeyJoinColumnpublic Husband getHusband() {return husband;}public void setHusband(Husband husband) {this.husband = husband;}注：同样不产生关联关系，具体实现待查3.2 XML方式4.2.1 类图图4-3 类关联关系图4.2.2 数据库表结构FKBE32645CA8BE0706H_WIFE_XMLID NAME NUMBER(4)VARCHAR2(30 char)<pk>H_HUSBAND_XMLID NAME NUMBER(4)VARCHAR2(30 char)<pk,fk>图4-4 数据库表结构图4.2.3 实体类package com.rongqq.hibernate3.xml.entity;import java.math.BigDecimal;public class XML_Husband {private BigDecimal id;private String name;private XML_Wife wife;public BigDecimal getId() {return id;}public String getName() {return name;}public XML_Wife getWife() {return wife;}public void setId(BigDecimal id) {this.id = id;}public void setName(String name) { = name;}public void setWife(XML_Wife wife) {this.wife = wife;}}package com.rongqq.hibernate3.xml.entity;import java.math.BigDecimal;public class XML_Wife {private BigDecimal id;private String name;private XML_Husband husband;public BigDecimal getId() {return id;}public void setId(BigDecimal id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}public XML_Husband getHusband() {return husband;}public void setHusband(XML_Husband husband) {this.husband = husband;}}4.2.4 对象映射文件<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd"><hibernate-mapping package="com.rongqq.hibernate3.xml.entity"><class name="XML_Husband"table="H_HUSBAND_XML"dynamic-update="true"> <id name="id"type="big_decimal"><column name="id"precision="4"scale="0"/><generator class="foreign"><param name="property">wife</param></generator></id ><property name ="name" length ="30"></property ><one-to-one name ="wife " constrained ="true "></one-to-one ></class > </hibernate-mapping > <?xml version ="1.0"?><!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd"> <hibernate-mapping package ="com.rongqq.hibernate3.xml.entity"> <class name ="XML_Wife" table ="H_Wife_XML" dynamic-update ="true"> <id name ="id"> <column name ="id" precision ="4" scale ="0" /> <generator class ="sequence"><param name ="sequence">H_STUDENT_SEQ_XML </param ></generator ></id ><property name ="name" length ="30" /><one-to-one name ="husband" property-ref ="wife "></one-to-one ></class > </hibernate-mapping >五、组件映射5.1 Annotation 方式5.1.1类图图5-1 类关联关系图5.1.2 数据库表结构H_HUSBAND_ID NAME AGEWIFENAMENUMBER(4)VARCHAR2(30 char)NUMBER(3)VARCHAR2(255 char)<pk>图5-2 数据库表结构图5.1.3 实体类package com.rongqq.hibernate3.annotation.entity; import java.math.BigDecimal;import javax.persistence.Column;import javax.persistence.Embedded;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.GenerationType;import javax.persistence.Id;import javax.persistence.SequenceGenerator;@Entity(name="H_HUSBAND_")@SequenceGenerator(name="husband_seq_gene", sequenceName="HUSBAND_SEQ", allocationSize=1) public class Husband {private BigDecimal id;private String name;private Wife wife;@Id@Column(precision=4, scale=0)@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="husband_seq_gene")public BigDecimal getId() {return id;}@Column(length=30)public String getName() {return name;}@Embeddedpublic Wife getWife() {return wife;}public void setId(BigDecimal id) {this.id = id;}public void setName(String name) { = name;}public void setWife(Wife wife) {this.wife = wife;}}package com.rongqq.hibernate3.annotation.entity;import java.math.BigDecimal;import javax.persistence.Column;public class Wife {private String name;private BigDecimal age;@Column(name="wifeName")public String getName() { return name ;}public void setName(String name) { this .name = name; }@Column (precision=3) public BigDecimal getAge() { return age ; }public void setAge(BigDecimal age) { this .age = age; }}5.2 XML 方式5.2.1类图图5-3 类关联关系图5.2.2 数据库表结构H_HUSBAND_XMLID NAMEWIFENAME AGENUMBER(4)VARCHAR2(30 char)VARCHAR2(255 char)NUMBER(3,2)<pk>图5-4 数据库表结构图5.2.3 实体类package com.rongqq.hibernate3.xml.entity; import java.math.BigDecimal; public class XML_Husband { private BigDecimal id ; private String name ; private XML_Wife wife ; public BigDecimal getId() { return id ;}public String getName() { return name ;}public XML_Wife getWife() {return wife;}public void setId(BigDecimal id) {this.id = id;}public void setName(String name) { = name;}public void setWife(XML_Wife wife) {this.wife = wife;}}package com.rongqq.hibernate3.xml.entity;import java.math.BigDecimal;public class XML_Wife {private String name;private BigDecimal age;public String getName() {return name;}public void setName(String name) { = name;}public BigDecimal getAge() {return age;}public void setAge(BigDecimal age) {this.age = age;}}5.2.4 对象映射文件<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd"><hibernate-mapping package="com.rongqq.hibernate3.xml.entity"><class name="XML_Husband"table="H_HUSBAND_XML"dynamic-update="true"> <id name="id"type="big_decimal"><column name="id"precision="4"scale="0"/><generator class="foreign"><param name="property">wife</param></generator></id><property name ="name" length ="30"></property > <component name ="wife"> <property name ="name" column ="WIFENAME " /><property name ="age" column ="AGE" precision ="3" /></component ></class > </hibernate-mapping >六、多对一单向关联6.1 Annotation 方式6.1.1 类图（说明：一个人具备多套房子的所有权，这么多套房子属于这个人）图6-1 类关联关系图6.1.2 数据库表结构FK5822AD3634FDD6C8H_PERSON_ID NAME NUMBER(21)VARCHAR2(255 char)<pk>H_HOUSE_ID POSITION PERSON_ID NUMBER(20)VARCHAR2(255 char)NUMBER(21)<pk><fk>图6-2 数据库表结构图6.1.3 实体类package com.rongqq.hibernate3.annotation.entity; import java.math.BigDecimal; import javax.persistence.Column; import javax.persistence.Entity;import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id;import javax.persistence.JoinColumn; import javax.persistence.ManyToOne; import javax.persistence.SequenceGenerator; @Entity (name="H_HOUSE_")。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

id | name userid | roleid id | name
----------------- ------------------- --------------------
1 | 张三 1 | 2 1 | 经理
<many-to-many calss="com.softeem.Role" column="roleid"/>
</set>
</class>
Role.hbm.xml
-----------------------------------------------------------------
<set name="roles" table="tb_user_role">

<key column="userid"/>

<class class="com.softeem.Role">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>

<class class="er">
<id name="id">
<generator class="native"/>
</id>
<properபைடு நூலகம்y name="name"/>

2 | 李四 1 | 3 2 | 主管
3 | 王五 2 | 1 3 | 领班
User.hbm.xml
-----------------------------------------------------------------
roles:Set users:Set
多对多关联映射通常要采用第三方表，用来存放两者之间的关系
tb_user tb_user_role tb_role
----------------- ------------------- --------------------
<set column="users" table="tb_user_role">
<key column="roleid"/>
<many-to-many class="er" column="userid"/>
</set>
</class>
一个用户对用多个角色，一个Role也对用多个用户：User<---->Role
User Role
-------------- --------------
id:int id:int
name:String name:String