Hibernate关联关系映射介绍及其相应的应用示例
Hibernate关联关系映射目录
│
├─单向关联
│├─一对一外键单向关联
│├─一对一主键单向关联
│├─一对一连接表单向关联
│├─一对多外键单向关联
│├─一对多连接表单向关联
│├─多对一外键单向关联
│├─多对一连接表单向关联
│└─多对多单向关联
└─双向关联
├─一对一外键双向关联
├─一对一主键双向关联
├─一对一连接表双向关联
├─一对多外键双向关联
├─一对多连接表双向关联
└─多对多双向关联
本系列实例的开发环境：
Windows XP Professional 简体中文版
MySQL 5.0.45
Hibernate 3.12
Java SDK 1.5.06
系列实例中所用的Hibernate配置文件如下：
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"[url]https://www.doczj.com/doc/141227968.html,/hibernate-configuration-3.0.dtd[/url]">
系列实例中所用到Session工厂是：
public class HibernateUtil {
private static final SessionFactory sessionFactory;
static {
try {
// Create the SessionFactory from hibernate.cfg.xml
sessionFactory = new Configuration().configure().buildSessionFactory();
} catch (Throwable ex) {
// Make sure you log the exception, as it might be swallowed
System.err.println("初始化SessionFactory失败！" + ex);
throw new ExceptionInInitializerError(ex);
}
}
public static final ThreadLocal session = new ThreadLocal();
public static Session getCurrentSession() throws HibernateException {
Session s = (Session) session.get();
//当原Session为空或已关闭时，打开一个新的Session
if (s == null || !s.isOpen()) {
s = sessionFactory.openSession();
session.set(s);
}
return s;
}
public static void closeSession() throws HibernateException {
Session s = (Session) session.get();
session.set(null);
if (s != null) {
s.close();
}
}
}
Hibernate关联关系映射介绍及其相应的应用示例
Hibernate关联关系映射目录
│
├─单向关联
│├─一对一外键单向关联
│├─一对一主键单向关联
│├─一对一连接表单向关联
│├─一对多外键单向关联
│├─一对多连接表单向关联
│├─多对一外键单向关联
│├─多对一连接表单向关联
│└─多对多单向关联
└─双向关联
├─一对一外键双向关联
├─一对一主键双向关联
├─一对一连接表双向关联
├─一对多外键双向关联
├─一对多连接表双向关联
└─多对多双向关联
Hibernate 一对一外键单向关联
事实上，单向1-1与N-1的实质是相同的，1-1是N-1的特例，单向1-1与N-1的映射配置也非常相似。只需要将原来的many-to-one元素增加unique="true"属性，用于表示N的一端也必须是唯一的，在N的一端增加了唯一的约束，即成为单向1-1。
基于外键的单向1-1的配置将与无连接表N-1关联的many-to-one增加unique="true"属性即可。
一、模型介绍
一个人（Person）对应一个地址（Address）。
二、实体（省略getter、setter方法）
public class Person11fk {
private int personid;
private String name;
private int age;
private Address11fk address11fk;
｝
public class Address11fk {
private int addressid;
private String addressdetail;
｝
三、表模型
四、生成的SQL脚本
CREATE TABLE `address_11fk` (
`addressid` int(11) NOT NULL auto_increment,
`addressdetail` varchar(255) default NULL,
PRIMARY KEY (`addressid`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=gbk;
CREATE TABLE `person_11fk` (
`personid` int(11) NOT NULL auto_increment,
`name` varchar(255) default NULL,
`age` int(11) default NULL,
`addressId` int(11) default NULL,
PRIMARY KEY (`personid`),
KEY `FK68A8818F3F45AA77` (`addressId`),
CONSTRAINT `FK68A8818F3F45AA77` FOREIGN KEY (`addressId`) REFERENCES `address_11fk` (`addressid`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=gbk;
五、映射方法：
在Person中添加Address属性，映射配置为：
六、测试方法
public class Test_11fk {
public static void main(String[] args){
Person11fk p1=new Person11fk();
p1.setAge(21);
p1.setName("p1");
Address11fk add1=new Address11fk();
add1.setAddressdetail("山东农业大学");
p1.setAddress11fk(add1);
Session session= HibernateUtil.getCurrentSession();
Transaction tx=session.beginTransaction();
session.save(add1);
session.save(p1);
https://www.doczj.com/doc/141227968.html,mit();
HibernateUtil.closeSession();
}
}
七、测试结果
1) :正常保存. 推荐这么干!
session.save(add1);
session.save(p1);
Hibernate: insert into ADDRESS_11fk (addressdetail) values (?)
Hibernate: insert into PERSON_11fk (name, age, addressId) values (?, ?, ?)
2) :正常保存.
session.save(p1);
session.save(add1);
Hibernate: insert into PERSON_11fk (name, age, addressId) values (?, ?, ?) Hibernate: insert into ADDRESS_11fk (addressdetail) values (?)
Hibernate: update PERSON_11fk set name=?, age=?, addressId=? where personid=?
3) :正常保存.
// session.save(p1);
session.save(add1);
Hibernate: insert into ADDRESS_11fk (addressdetail) values (?)
4) : 发生异常,不能保存.
session.save(p1);
// session.save(add1);
Hibernate: insert into PERSON_11fk (name, age, addressId) values (?, ?, ?) Exception in thread "main" org.hibernate.TransientObjectException: https://www.doczj.com/doc/141227968.html,vasoft.dx._1_1_fk.Address11fk
Hibernate 一对一主键单向关联
1-1的关联可以基于主键关联，但基于主键关联的持久化类不能拥有自己的主键生成策略，它的主键由关联类负责生成。另外，增加one-to-one元素来关联属性，必须为one-to-one 元素增加constrained="true"属性，表明该类主键由关联类生成。
一、模型介绍
一个人（Person）对应一个地址（Address）。
二、实体（省略getter、setter方法）
public class Person11pk {
private int personid;
private String name;
private int age;
private Address11pk address11pk;
}
public class Address11pk {
private int addressid;
private String addressdetail;
}
三、表模型
四、生成的SQL脚本
CREATE TABLE `address_11pk` (
`addressid` int(11) NOT NULL auto_increment,
`addressdetail` varchar(255) default NULL,
PRIMARY KEY (`addressid`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=gbk;
CREATE TABLE `person_11pk` (
`presonid` int(11) NOT NULL,
`name` varchar(255) default NULL,
`age` int(11) default NULL,
PRIMARY KEY (`presonid`),
KEY `FK68A882C591BB393E` (`presonid`),
CONSTRAINT `FK68A882C591BB393E` FOREIGN KEY (`presonid`) REFERENCES `address_11pk` (`addressid`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;
五、映射方法：在Person中配置id生成策略为：
address11pk
......
address11pk
六、测试方法
public class Test_11pk {
public static void main(String[] args){
Person11pk p1=new Person11pk();
p1.setAge(21);
p1.setName("p1");
Address11pk add1=new Address11pk();
add1.setAddressdetail("山东农业大学");
p1.setAddress11pk(add1);
Session session= HibernateUtil.getCurrentSession();
Transaction tx=session.beginTransaction();
session.save(add1);
session.save(p1);
https://www.doczj.com/doc/141227968.html,mit();
HibernateUtil.closeSession();
}
}
七、测试结果
1) :正常保存. 推荐这么干!
session.save(add1);
session.save(p1);
Hibernate: insert into ADDRESS_11fk (addressdetail) values (?) Hibernate: insert into PERSON_11fk (name, age, addressId) values (?, ?, ?)
2) :正常保存.
session.save(p1);
session.save(add1);
Hibernate: insert into PERSON_11fk (name, age, addressId) values (?, ?, ?)
Hibernate: insert into ADDRESS_11fk (addressdetail) values (?)
Hibernate: update PERSON_11fk set name=?, age=?, addressId=? where personid=?
3) :正常保存.
// session.save(p1);
session.save(add1);
Hibernate: insert into ADDRESS_11fk (addressdetail) values (?)
4) : 发生异常,不能保存.
session.save(p1);
// session.save(add1);
Hibernate: insert into PERSON_11fk (name, age, addressId) values (?, ?, ?)
Exception in thread "main" org.hibernate.TransientObjectException: https://www.doczj.com/doc/141227968.html,vasoft.dx._1_1_fk.Address11fk
Hibernate 一对一连接表单向关联
这种情况很少见，但Hibernate同样允许采用连接表关联1-1.有连接表的1-1同样只需要将N-1的many-to-one元素增加unique="true"属性即可。
一、模型介绍
一个人（Person）对应一个地址（Address）。
二、实体（省略getter、setter方法）
public class Person11tab {
private int personid;
private String name;
private int age;
private Address11tab address11tab;
public class Address11tab {
private int addressid;
private String addressdetail;
三、表模型
四、生成的SQL脚本
CREATE TABLE `join_11tab` (
`personid` int(11) NOT NULL,
`address11tab` int(11) default NULL,
PRIMARY KEY (`personid`),
UNIQUE KEY `address11tab` (`address11tab`),
KEY `FK6B44BE20C4CC3D33` (`address11tab`),
KEY `FK6B44BE209049BB1F` (`personid`),
CONSTRAINT `FK6B44BE209049BB1F` FOREIGN KEY (`personid`) REFERENCES `person_11tab` (`personid`),
CONSTRAINT `FK6B44BE20C4CC3D33` FOREIGN KEY (`address11tab`) REFERENCES `address_11tab` (`addressid`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;
CREATE TABLE `address_11tab` (
`addressid` int(11) NOT NULL auto_increment,
`addressdetail` varchar(255) default NULL,
PRIMARY KEY (`addressid`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=gbk;
CREATE TABLE `person_11tab` (
`personid` int(11) NOT NULL auto_increment,
`name` varchar(255) default NULL,
`age` int(11) default NULL,
PRIMARY KEY (`personid`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=gbk;
五、映射方法：
在Person中添加Address属性，映射配置为：
六、测试方法
public class Test_11tab {
public static void main(String[] args){
Person11tab p1=new Person11tab();
p1.setAge(21);
p1.setName("p1");
Address11tab add1=new Address11tab();
add1.setAddressdetail("郑州市经三路");
p1.setAddress11tab(add1);
Session session= HibernateUtil.getCurrentSession();
Transaction tx=session.beginTransaction();
session.save(add1);
session.save(p1);
https://www.doczj.com/doc/141227968.html,mit();
HibernateUtil.closeSession();
}
}
七、测试结果
1) :正常保存. 推荐这么干!
session.save(add1);
session.save(p1);
Hibernate: insert into ADDRESS_11tab (addressdetail) values (?)
Hibernate: insert into PERSON_11tab (name, age) values (?, ?)
Hibernate: insert into join_11tab (address11tab, personid) values (?, ?)
2) :正常保存.
session.save(p1);
session.save(add1);
Hibernate: insert into PERSON_11tab (name, age) values (?, ?)
Hibernate: insert into join_11tab (address11tab, personid) values (?, ?)
Hibernate: insert into ADDRESS_11tab (addressdetail) values (?)
Hibernate: update join_11tab set address11tab=? where personid=?
3) :正常保存.
// session.save(p1);
session.save(add1);
Hibernate: insert into ADDRESS_11tab (addressdetail) values (?)
4) : 发生异常,不能保存.
session.save(p1);
// session.save(add1);
Hibernate: insert into PERSON_11tab (name, age) values (?, ?)
Hibernate: insert into join_11tab (address11tab, personid) values (?, ?)
Exception in thread "main" org.hibernate.TransientObjectException: https://www.doczj.com/doc/141227968.html,vasoft.dx._1_1_tab.Address11tab
Hibernate 一对多外键单向关联
这种情况很少见，但Hibernate同样允许采用连接表关联1-1.有连接表的1-1同样只需要将N-1的many-to-one元素增加unique="true"属性即可。
一、模型介绍
一个人（Person）对应多个地址（Address），比如家庭地址、公司地址。
二、实体（省略getter、setter方法）
public class Person1nfk implements Serializable {
private int personid;
private String name;
private int age;
private Set addresses=new HashSet();
public class Address1nfk implements Serializable {
private int addressid;
private String addressdetail;
三、表模型
四、生成的SQL脚本
CREATE TABLE `address_1nfk` (
`addressid` int(11) NOT NULL auto_increment,
`addressdetail` varchar(255) default NULL,
`addresses` int(11) default NULL,
PRIMARY KEY (`addressid`),
KEY `FK9B93456DC08D1667` (`addresses`),
CONSTRAINT `FK9B93456DC08D1667` FOREIGN KEY (`addresses`) REFERENCES `person_1nfk` (`personid`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=gbk;
CREATE TABLE `person_1nfk` (
`personid` int(11) NOT NULL auto_increment,
`name` varchar(255) default NULL,
`age` int(11) default NULL,
PRIMARY KEY (`personid`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=gbk;
五、映射方法：
在实体类Person里面添加Address的集合，即可形成一对多关系。
table="ADDRESS_1nfk" cascade="all" >
table="ADDRESS_1nfk" cascade="all" >
六、测试方法
public class Test_1nfk {
public static void main(String[] args){
Address1nfk add1=new Address1nfk();
Address1nfk add2=new Address1nfk();
Person1nfk p=new Person1nfk();
add1.setAddressdetail("郑州市经三路");
add2.setAddressdetail("合肥市宿州路");
p.setName("wang");
p.setAge(30);
p.getAddresses().add(add1);
p.getAddresses().add(add2);
Session session= HibernateUtil.getCurrentSession();
Transaction tx=session.beginTransaction();
session.save(add1);
session.save(add2);
session.save(p);
https://www.doczj.com/doc/141227968.html,mit();
HibernateUtil.closeSession();
}
}
七、测试结果
1) :正常保存.
// session.save(add1);
// session.save(add2);
session.save(p);
Hibernate: insert into PERSON_1nfk (name, age) values (?, ?) Hibernate: insert into ADDRESS_1nfk (addressdetail) values (?) Hibernate: insert into ADDRESS_1nfk (addressdetail) values (?) Hibernate: update ADDRESS_1nfk set personid=? where addressid=? Hibernate: update ADDRESS_1nfk set personid=? where addressid=?
2) :正常保存.
session.save(add1);
session.save(add2);
session.save(p);
Hibernate: insert into ADDRESS_1nfk (addressdetail) values (?) Hibernate: insert into ADDRESS_1nfk (addressdetail) values (?) Hibernate: insert into PERSON_1nfk (name, age) values (?, ?) Hibernate: update ADDRESS_1nfk set personid=? where addressid=? Hibernate: update ADDRESS_1nfk set personid=? where addressid=?
3) :正常保存.
session.save(add1);
session.save(add2);
// session.save(p);
Hibernate: insert into ADDRESS_1nfk (addressdetail) values (?) Hibernate: insert into ADDRESS_1nfk (addressdetail) values (?)
Hibernate中有两个配置文件 映射文件Xxx.hbm.xml 映射文件的的文件头DTD文件内容：
配置文件hibernate.cfg.xml 配置文件的文件头DTD文件内容： org.hibernate.dialect.MySQLDialect
Hibernate&EJB考试试题 1、下面关于Hibernate说法正确的是（）（选择两项） A）Hibernate是ORM的一种实现方式 B）Hibernate不要JDBC的支持 C）属于控制层 D）属于数据持久层 2、下面关于ORM的说法错误的是（)（选择两项） A）对象关系映射，让现实中的对象同数据库的表产生映射（类与表产生映射） B）对象关系映射，让类同表产生关系 C）对象关系映射，让类同记录产生关系（类的实例与记录（表中的一行数据）产生关系） D）对象关系映射，让类中的属性同表中的列产生关系 3、下面关于Hibernate中Session的说法正确的是（）（选择两项） A）Session是轻量级的，可以随意的创建和销毁 B）Session是重量级的，不能随意的创建和销毁 C）Session是线程安全的 D）Session不是线程安全的 4、在Hibernate中，以下（）不属于session的方法 A、close（） B. open() C. update() D. delete() 5、下面关于Hibernate中load和get方法说法正确的是（） A）这两个方法是一样的，没有任何的区别 B）这两个方法不一样，load先找缓存，再找数据库
C）这两个方法不一样，get先找缓存，再找数据库 D）以上说法都不对 注：load()和get()都是先找缓存，再找数据库。 不同点是在检索时： load()是延迟检索，先返回代理对象，访问对象时在发出sql命令Get()是立即检索，直接发出sql命令，返回对象 6、在Hibernate中修改对象的说话错误的是（） A）只能利用update方法来做修改 B）可以利用saveOrUpdate方法来做修改 C）可以利用HQL语句来做修改 D）不能利用HQL语句来修改 7、下面关于Hibernate中Transaction的使用说法正确的是（）(选择两项) A）Transaction是可有可无的 B）Transaction在做查询的时候是可有可无的 C）Transaction在做修改的时候是可有可无的 D）Transaction在做修改的时候是必须的 8、使用Hibernate技术实现数据持久化时，下面（）内容不在 Hibernate配置文件中配置(选择一项) A) 数据库连接信息 B) 数据库类型（dialect） C) show_sql参数 D) 数据库表和实体的映射信息
1.Java对象持久化概述 1.1.应用程序的分层体系结构 1.1.1.基于B/S的典型三层架构 说明： 1，展现层：提供与用户交互的界面。 2，业务逻辑层：实现各种业务逻辑。 3，数据访问层：负责存放和管理应用程序的持久化业务数据。 1.1. 2.数据访问层与Hibernate在Java应用程序中的 角色 数据访问层（持久化层）封装了数据访问的细节，为业务逻辑层提供了面向对象的API。完善的持久化层应该达到的目标： 1，代码重用性高，可完成所有的数据访问操作。 2，如果需要的话，能够支持多种数据库平台。 3，具有相对独立性，当持久化层变化时，不会影响上层实现。 在数据访问层（持久化层）中可以使用Hibernate框架以实现要求，如下图所示：
1.2.软件模型 1.2.1.各种模型的说明 概念模型： 模拟问题域中的真实实体。描述每个实体的概念和属性及实体间关系。不描述实体行为。实体间的关系有一对一、一对多和多对多。。 关系数据模型： 在概念模型的基础上建立起来的，用于描述这些关系数据的静态结构。有以下内容组成：1，若干表 2，表的所有索引 3，视图 4，触发器 5，表与表之间的参照完整性
域模型： 在软件的分析阶段创建概念模型，在软件设计阶段创建域模型。 组成部分： 1，具有状态和行为的域对象。 2，域对象之间的关联。 域对象(domain object)： 构成域模型的基本元素就是域对象。对真实世界的实体的软件抽象，也叫做业务对象（Business Object，BO）。域对象可代表业务领域中的人、地点、事物或概念。 域对象分为以下几种: 1，实体域对象：通常是指业务领域中的名词。（plain old java object，简单Java 对象）。 2，过程域对象：应用中的业务逻辑或流程。依赖于实体域对象，业务领域中的动词。如发出订单、登陆等。 3，事件域对象：应用中的一些事件（警告、异常）。 1.2.2.域对象间的关系 关联： 类间的引用关系。以属性定义的方式表现。
用MyEclipse如何自动生成hibernate的.hbm.xml文件(2010-07-29 17:36:01) 今天在网上看到很多人都不知道怎么用MyEclipse自动生成hibernate的.hbm.xml文件。我甚至看到有位兄弟竟然自己写出那个格式的文件来。首先我不得不佩服那位兄弟的记忆力。可是我这边有更直接的方法希望能对那些入门级别的人一点帮助！ 在hibernate中，每个数据表对应的其实是一个实体类，每个实体类有一个对应的hbm.xml 配置文件和你匹配，myeclipse中其实有个MyEclipse Database Explorer视图，它提供了myeclipse与数据库直接连接的内置窗口，并且通过此窗口可以生成hibernate的mapping文件。 1.在项目上点击右键选择MyEclipse选项，为应用增加Hibernate特性. 2.在出现的配置窗口中，选中“Add Hibernate 2.1 libraries to project?”，然后设定存放Hibernate 库文件的目录为：/WEB-INF/lib 目录，默认会选择创建一个新的Hibernate配置文件hibernate.cfg.xml。 3.点击下一步，进入Hibernate数据库连接配置界面，在Connection Profile选项中直接选择在MyEclipse Database Explorer中配置的vipdata选项，然后就会自动生成其他的配置，可以选择“Copy JDBC Driver and add to classpath”,这样就会将JDBC驱动拷贝到WEB-INF/lib目录中。： 4.点击下一步，来创建Hibernate的SessionFactory类，这是一个简单的集中管理Hibernate 会话的工厂类，填写类的全名称。 5.点击完成，然后MyEclipse就会将Hibernate相关的jar包拷贝到lib目录下，同时会生成Hibernate的配置文件：hibernate.cfg.xml，和SessionFactory类。 现在要利用MyEclipse Database Explorer视图中的工具来生成Hibernate的映射文件。切换到MyEclipse Database Explorer视图，在表vipdata上点击右键，选择Create Hibernate Mapping.
Hibernate（6）——一对多和多对多关联关系映射（xml和注解）总结 涉及的知识点总结如下： ?One to Many 映射关系 o多对一单向外键关联(XML/Annotation) o一对多单向外键关联(XML/Annotation) o懒加载和积极加载 o一对多双向外键关联(XML/Annotation) ?Many to Many 映射关系 o多对多单向外键关联(XML/Annotation) o多对多双向外键关联(XML/Annotation) o set的inverse元素详解 ?问题小结 ?关联关系的优缺点 多对一单向外键关联关系 注意多对一关联是多方持有一方的引用。看一个例子，去淘宝购物，那么一个淘宝用户可以对应多个购物订单，如图所示： 多的一方是Orders，持有一方的引用，也就是Users，而在Users中无需作任何定义，从订单到用户的关系是单向多对一关联。对应数据库就是： 还有比如说学生和班级的关系，多个学生可以属于同一个班级，这就是从学生到班级也是典型的单向多对一关系，看代码实现： 基于注解的多对一单向外键关联： 单向多对一关联中，多方需要持有一方的引用，那么多方（学生类）需要额外配置，需要对持有的一方引用使用注解@ManyToOne (cascade={CascadeType.ALL}, fetch=FetchType.EAGER)，设置为级联操作和饥渴的抓取策略，@JoinColumn(name="cid")，而一方（教室类）无需做任何多方的定义。 注意；多方必须保留一个不带参数的构造器！ import ; import ; import ; //班级类,在多对一关系中属于一的方，不持有其他多余的配置，反而是被多方持有
网络地址： 主题：如何根据hibernate的实体类和实体类配置文件生成数据库的表 内容部分 [c-sharp]view plaincopyprint? 1. 4.
1. Hibernate Annotation关系映射有下面几种类型： 1)一对一外键关联映射（单向） 2)一对一外键关联映射（双向） 3)一对一主键关联映射（不重要，有需要看下文档即可） 在实际中很少用，使用注解@PrimaryKeyJoinColumn 意思是说，我的主键去参考另外一张表中的主键，作为我的主键，但是在我测试使用 注解一对一主键关联映射，在生成表的时候，数据库中并没有生成关联，使用XML 映射可以生成。Annotation注解一对一主键关联映，有些bug。不过没空去研究它。 因为在实际开发中一对一很少用。在实际开发中我机会没有用过，主键关联就更少了 4)多对一关联映射（单向） 5)一对多关联映射（单向） 6)一对多关联映射（双向） 7)多对多关联映射（单向） 8)多对多关联映射（双向） 2.介绍各种映射用法 1）一对一外键关联映射（单向）Husband ---> Wife public 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 <---> Wife public 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）。mappedby="wife"需要指向与他关联对象的一个属性(即Husband类里面的wife属性)，这里的会在Husband表里面生成个外键wife_id字段，而Wife表里则不会生成。这里Husband作为维护端即主
利用轻量对象关系映射技术Hibernate提高开发效率 Enhancing Development Efficiency with Hibernate a Lightweight Object/Relational Mapping Technology 谢挺 周维民 （上海大学机电工程与自动化学院，上海 200072） 摘 要 Hibernate是一种轻量对象关系映射技术。文章通过实例，介绍了Hibernate的一些关键特性，并阐述了该技术的一些局限性。 关键词 Hibernate 对象关系映射企业级JavaBeans 持久化 Abstract Hibernate is a lightweight Object/Relational Mapping(ORM) technology. Some key features of Hibernate are illustrated, and some limits of this technology are expounded. Keywords Hibernate Object/Relational Mapping (ORM) EJB Permanence 0 引言 随着internet的发展，应用服务程序已经从集中式、C/S模式过渡到B/S、分布式模式；无论是用户或是供应商都迫切希望缩短开发周期、提高开发效率，Hibernate应运而生。 1 Hibernate简介 Hibernate是一个面向Java环境的对象/关系数据库映射工具。对象/关系数据库映射(Object/Relational Mapping , ORM)这个术语表示一种技术，用来把对象模型表示的对象映射到基于SQL的关系模型中去。 Hibernate不仅提高Java类到数据库的映射，还提供数据查询和获取数据的方法。Hibernate在英语中的意思是“冬眠”，顾名思义它使得商务逻辑的开发和数据库最大程度地分离，可以大幅度减少开发时人工使用SQL和JDBC处理数据的时间。Hibernate的目标是解放开发者通常与数据持久化相关的编程任务的95％。对于那些在基于Java的中间层应用中，它们实现面向对象的业务模型和商业逻辑的应用，Hibernate是很有用的。 图1是Hibernate的体系结构图，从图中可以Array看到，系统为3层B/S模式，应用程序在客户端运 行将持久化的对象交由Hibernate。Hibernate通过 properties属性设置和XML Mapping实现商务逻 辑，调用和存储低层数据库后将返回的结果送给 客户端。 Hibernate对每一种数据库都有对应的 Dialect进行操作优化,从而提高它在各种情况 下的效率。目前,它的版本为3.0、支持的数据 库有Oracle、DB2、MySQL、PostgreSQL、Sybase,Interbase、Pointbase、Microsoft SQL Server、
Hibernate映射解决问题 做Hibernate映射已经做了五天了,期间遇到了不少错误,有的时候错误很细小,很难发现.现在就来总结一下,常见的错误,有的也是在网上搜了看到的! 第一种问题:Could not execute JDBC batch update 网上说有两种可能: 1.因为Hibernate Tools（或者Eclipse本身的Database Explorer）生成*.hbn.xml工具中包含有catalog="***"（*表示数据库名称）这样的属性,将该属性删除就可以了 2.估计是你的列名里面有关键字的原因吧，命名列的时候不要单独使用date,ID...这种关键字 但是,我觉得他写得不完全啦!我遇到的就不是两种原因,而是List映射时,对应表的索引项没有设成主键,所以就出错了.虽然找了蛮长时间的.同样, 它也会出现Duplicate entry '1' for key 1的错误啦! 第二种问题(归纳下): 1．Caused by: org.dom4j.DocumentException: Invalid byte 2 of 2-byte UTF-8 sequence. Nested exception: Invalid byte 2 of 2-byte UTF-8 sequence. 如果出现这行错误说明你的XML配置文件有不规范的字符，检查下。 2．net.sf.hibernate.MappingException: Error reading resource: hibernate/Hello_Bean.hbm.xml 如果出现这行错误说明你的hibernate的XML配置文件有错 3．net.sf.hibernate.MappingException: Resource: hibernate/Hello_Bean.hbm.xml not found 如果出现这行错误说明hibernate的XML配置文件没有找到，你应该把XML文件放在与你的类文件同个目录下,一般跟同名的java持久化类放在一起，也就是跟Hello_Bean.class类文件一起。4．net.sf.hibernate.PropertyNotFoundException: Could not find a setter for property name in class hibernate.Hello_Bean 如果出现这行错误说明你的xml文件里设置的字段名name的值与Hello_Bean.Java类里的getXXX 或setXXX方法不一致。 5．net.sf.hibernate.HibernateException: JDBC Driver class not found: org.gjt.mm.mysql.Driver：没有找到数据库驱动程序 6．The database return no natively generate indentity value。主键没有添加增量 7．net.sf.hibernate.PropertyValueException:not-null property references a null or transient value:com.pack.Rordercontent. 异常产生原因：Rordercontent对象的非空属性Rordertable引用了一个临时对象。 8．net.sf.hibernate.TransientobjectException:objiect references an unsaved transient instance –save the transient instance before flushing: com.pack.Rordertable 持久化对象的某个属性引用了一个临时对象Rordertable https://www.doczj.com/doc/141227968.html,.sf.hibernate.MappingException
hibernate一对多关联映射—单向 一、简述 一对多关联映射（one-to-many） 1、在对象模型中，一对多的关联关系，使用集合表示 比如Classes（班级）和Student（学生）之间是一对多的关系 public class Classes{ private String id; private String name; private Set students; } public class Student{ public String id; public String name; } 2、我们以前学过学生对班级是多对一，返过来，班级对学生就是一对多。 3、我们多对一的关系是用户和组。返过来看，从组这边来看，就是一对多了。 下面学生的示例是班级和学生。和用户和组是一样的。 一个班级有多个学生，这是一对多的关系；返过来，多个学生属于一个班级，这就是多对一了。 4、建立对象模型 5、这两个对象模型之间是有关系的。我们现在讲的是一对多。一的一端是班级。多的一端是学生。那么怎么样能体现出这种关系呢？ 我们在学习多对一时，是在多的一端加上一个字段。这个字段做为外键关联一的一端。多对一，就是我们在看到学生的时候，能够知道这个学生是哪个班级的。或者是当我们看到用户的时候，知道这个用户是哪个组的。所以在用户里面持有组的引用。 6、那么一对多，就是一个组里面有多少个用户。所以要维护这种关系，必须在组里面持有用户的集合。 班级和学生也是一样的。一个班级有多少学生，所以在班级里面要持有相应的学生的集合。如下图 我们用Set，通常用户Set做映射。
箭头表示两者之间是有关系的。 7、上面的是对象模型，那么这种模型要映射成什么样呢？ 当我们定义多对一的关系时，在加载多的一端时，能够把1的一端加载上来。因为两者之间是有关系的。 同理，一对多也是一样的，它要维护这种关系。这种关系就是一对多。一的一端要指向多。在维护这种关系时，在加载一的时候，就会把一的一端加载上来。 也就是说，在我在加载班级时，这个班级有多少个学生，它会把所有的学生自动查询上来，放到Set集合里面。这就是维护这个关系的目的。 8、我们知道，实体类要映射成表。所在下面画两个表。 依我们来看，是先有班级。再分配学生。 学生有了，班级有了。要保证知道一个班级有多少学生。 因为students这个集合是在Classes上，要映射它的时候，那么我们是要在t_classes表上加一个字段，然后将所有的学生用，表达式表达出来吗？可是这样做不符合数据库的设计范式。 9、所以说，这种关系的维护应该是在t_student这一端。也就是说，在t_student表中加一个字段，这个字段就是classesid。 也就是说，一对多关联映射，要把两个表的关联字段加到多的一端。 10、所以说，一对多与多对一的映射是一样的。没有区别。都在多的一端加一个外键，指向一的一端。 但是两者也是有区别的。区别就是关系。如果维护的是多对一，则加载多的时候，能把1加上来。如果维护的是一对多，则加载班级时，能把WHSD1011对应的两个学生加载上来。 我的理解：对于要相关联的表来说，如果一个表想要看到对方的表内容，则就要在自己的实体类中持有对方的引用。 如果只有一方看到另一方，就是单向的。 如果要双方都看到，就要在实体模型中彼此都持有对方的引用。
hibernate映射文件property 元素属性 property 元素 name：映射类属性的名字 可选属性： 1.column：对应数据库表的字段名默认值为属性名 2.type：字段的类型 3.update：update操作时是否包含本字段的数据默认值为true 4.insert：insert操作时是否包含本字段的数据默认值为true 5.formula：定义一个SQL来计算这个属性的值 6.access：Hibernate访问这个属性的策略默认值为property 7.unique：设置该字段值是否唯一默认值为false 8.not-null：设置该字段值是否可以为空默认值为false 9.property-ref：设置关联类的属性名，此属性和本类的关联相对应默认 值为关联类的主键 10.optimistic-lock：指定此属性做更新操作时是否需要乐观锁定默认值为 true https://www.doczj.com/doc/141227968.html,zy：指定是否采用延迟加载及加载策略默认值为proxy通过代理进行 关联可选值为 true此对象采用延迟加载并在变量第一次被访问时抓 取、false此关联对象不采用延迟加载 12.not-found：指定外键引用的数据不存在时如何让处理默认值为 exception产生异常可选值为ignore对不存在的应用关联到null 13.entity-name：被关联类的实体名 hibernate映射文件one-to-one 元素属性 1.one-to-one 元素 属性： https://www.doczj.com/doc/141227968.html,：映射类属性的名字 2.class：映射的目标类 3.cascade：设置操作中的级联策略可选值为 all所有操作情况均进行级 联、none所有操作情况均不进行级联、save-update执行更新操作时级联、delete执行删除操作时级联 4.constrained：表明当前类对应的表与被关联的表之间是否存在着外键约 束默认值为false
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 使用
①先保存一的一端Customer，后保存多的一端Order。 Save.java 打印SQL： Output 结论：发送了3条INSERT 语句。 ②先保存多的一端Order，再保存一的一端Customer。 Save2.java 打印SQL： Output2 结论：发送了3条INSERT 语句，2条UPDATE 语句。 总结：在单向多对一的关联关系下，先插入 1 的一端会减少SQL 语句的执行，性能更高。 <2>删除 先删除1的一端。 Delete.java 控制台打印： Cannot delete or update a parent row: a foreign key constraint fails (`hibernate`.`order`, CONSTRAINT `FK_m6q2ofkj1g5aobtb2p00ajpqg` FOREIGN KEY (`customer_id`) REFERENCES `customer` (`customer_id`)) 结论：在不设置级联关系的前提下，不能删除 1 的一端。 <3>更新 Update.java Output <4>查询 ①查询n 的一端，但是不使用查询出来关联的 1 的一端的对象。 @Test public void testMany2OneGet() { Order order = (Order) session.get(Order.class, 1); System.out.println(order.getCustomer().getClass().getName()); } 复制代码
Hibernate考试试题（题库） 1、在Hibernate中，下列说法正确的有（）。【选三项】 A．Hibernate是一个开放源代码的对象关系映射框架 B．Hibernate对JDBC进行了轻量级的对象封装 C．Hibernate可以大大减少操作数据库的工作量 D．Hibernate提供了数据查询机制，但没有提供恢复机制 2、关于Hibernate，下列说法错误的是（）。 A．Hibernate是一个对象-关系映射工具 B．在MVC模式中，Hibernate属于控制层 C．Hibernate在JDBC的方式上进行封装，以简化JDBC方式繁琐的编码工作 D．在Hibernate中，可以通过xml格式的配置文件保存对象-关系的映射信息 3、在Hibernate中，下列关于SessionFactory说法正确的有（）。【选两项】 A．它是线程安全的 B．它不是线程安全的 C．它是轻量级的 D．一个SessionFactory实例对应一个数据存储源 4、在Hibernate中，下列关于Session说法正确的有（）。【选三项】 A．它是线程安全的 B．它不是线程安全的 C．它是轻量级的 D．Session也被称为持久化管理器，它提供了和持久化相关的操作 5、在Hibernate中，下列关于Transaction说法正确的有（）。【选三项】 A．事务Transaction为应用程序指定以原子操作单元为范围的对象 B．在对数据库进行增加、修改和删除操作时一定要加上Transaction C．在对数据库进行查询操作时一定要加上Transaction D．获得Transaction的方法：Transactiontr=session.beginTransaction(); 6、在Hibernate中，如果数据库是MySql或者SQLServer，则generator属性值不可 以使用（）。 A．hilo B．native C．sequence D．indentity 7、在Hibernate中，如果数据库是Oracle或者DB2，则generator属性值不可以使用 （）。 A．hilo B．native C．sequence D．indentity 8、在Hibernate中，下列哪个选项不属于Session的方法（）。 A．load B．save C．open
对象关联关系 一对一 单向：一方引用，在引用方加入被引用对象字段，注解@OneToOne 默认引用外键字段名为“被引用类名_id”，使用@JoinColumn(name=”your_name”)更改外键字段名 联合主键： @JoinColumns({ @JoinColumn(name="add_id",referencedColumnName="id"), @JoinColumn(name="add_code",referencedColumnName="areaCode") }) 双向：双方各自引用，都加入对方的引用，注解@OneToOne，表之间各自外键引用，不符合设计要求，通常一方引用，所以在被引用方法注解： @OneToOne(MappedBy=”引用方字段名”)。双向一般都设MappedBy 组件映射：一对一关系通常处理为在同一张表中存储数据，若程序端需要拆分成多个实体，使用组件映射方式@Embeded(在包含实体中注解) 若需要属性重写（改列名）： @AttributeOverrides({ @AttributeOverride(name="fname",column=@Column(name="firstname")), @AttributeOverride(name="lname",column=@Column(name="lastname")) }) 多对一和一对多 多对一单向：在多方有一方的引用，注解@ManyToOne 一对多单向：在一的一方存在多方的集合（set），在一方注解@OneToMany 注意，Hibernate将一对多处理为多对多的特例，默认为两个关系表建中间表关联，所以加@JoinColumn 双向：多方注解@ManyToOne，一方注解@OneToMany(mappedBy="st")（st为多方引用一方对象名），注意一方不需再注解@JoinColumn 多对多 单向：在其中一方引用另外一方，类型为集合(set),注解@ManyToMany，若要改变中间表的表名及列名， 注解@JoinTable(name,joinColumns={@JoinColumn(name=”table1_id”)}, reverseJoinColumns={@JoinColumn(name=””)}) 双向：
总结的：在ECLIPSE中用HIBERNATE工具生成映射文件有截图 我们都知道HIBERNATE提供了工具供我们在ECLIPSE中使用生成对应的映射文件，但我一直用的都是myeclipse，兼容了需要导入的包，所以我对eclipse操作根本不熟，现在我在网上找了个案例，以后就不会头痛过了，(*^__^*) 嘻嘻…… 1.首先当然是从HIBERNATE官网上把工具下下来，放在ECLIPSE的对应的插件目录下 2.新建一个项目 3.把相应的JAR包加到你项目里 4.右击项目-〉new->Hibernate 选择Hibernate Configuration File(cfg.xml) 创建hibernate.cfg.xml文 件 5.（5）填写对应的数据库连接信息 如：Database dialet, connection URL, Default Schema, username, password等 记着：把下面那个Create a console configuration前面的钩钩上，下面会用它来创建映设文件 （6）点击NEXT，给你的Console Configuration 命个名，如test （7）FINISH你的hibernate.cfg.xml文件就建好了 下面是利用你的配置文件生成对应的映射JAVA文件 （8）进入hibernate Code Generation控制台，在Console configuration里选中你刚建的Console Configuration,如test （9）然后创建hibernate.reveng.xml 文件，选择新建 点击Refresh按钮，你的DB中的TABLE会列出来，然后将你要映射的表用INCLUDE按钮包含到右边的TABLE FILTERS中，点击FINISH （10）如下图，看看你要生成那些代码，把对应的钩打上，Apply-> Run ，OK，你对应的JAVA代码生成好了 注意：在我做以上步骤时曾发生过一下错误，重视下：
Hibernate之one-to-one主键关联映射one-to-one映射的例子为一个人拥有一个身份证，一个身份证属于一个人。 先创建po类 Person.java 1.package po; 2. 3.public class Person { 4.private int id; 5.private String name; //姓名 6.public int getId() { 7.return id; 8. } 9.public void setId(int id) { 10. this.id = id; 11. } 12. public String getName() { 13. return name; 14. } 15. public void setName(String name) { 16. https://www.doczj.com/doc/141227968.html, = name; 17. } 18. 19.} Card.java
1.package po; 2. 3.public class Card { 4.private int id; //身份证ID 5.private String number; //身份证号码 6.private Person person; //一个身份证号对应一个人 7. 8.public int getId() { 9.return id; 10. } 11. public void setId(int id) { 12. this.id = id; 13. } 14. public String getNumber() { 15. return number; 16. } 17. public void setNumber(String number) { 18. this.number = number; 19. } 20. public Person getPerson() { 21. return person; 22. } 23. public void setPerson(Person person) { 24. this.person = person; 25. } 26. 27. 28. 29. 30.}
Hibernate一对一映射配置详解 雪飘寒 目录 Hibernate一对一映射配置详解 (1) 一、xml文件配置 (2) 1. 主键关联 (3) 2. 单方外键关联 (4) 3. 双方外键关联 (5) 二、注释方式配置（Annotation） (6) 1、主键关联 (6) 2. 单方外键关联 (7) 3. 双方外键关联 (8)
一对一关联分为主键关联与外键关联。 主键关联：不必加额外的字段，只是主表和辅表的主键相关联，即这两个主键的值是一样的。 外键关联：辅表有一个额外的字段和主表相关联，或者两个表都有额外的字段与对应表的相关联。一、xml文件配置 官方文档解释 (1) name: 属性的名字。 (2) class (可选 - 默认是通过反射得到的属性类型)：被关联的类的名字。 (3) cascade(级联) (可选)：表明操作是否从父对象级联到被关联的对象。 (4) constrained(约束) (可选)：表明该类对应的表对应的数据库表，和被关联的对象所对应的数据库表之间，通过一个外键引用对主键进行约束。这个选项影响save()和delete()在级联执行时的先后顺序以及决定该关联能否被委托(也在schema export tool中被使用). (5) fetch (可选 - 默认设置为选择): 在外连接抓取或者序列选择抓取选择其一. (6) property-ref (可选):指定关联类的属性名，这个属性将会和本类的主键相对应。如果没有指定，会使用对方关联类的主键。 (7) access (可选 - 默认是 property): Hibernate用来访问属性的策略。 (8) formula (可选):绝大多数一对一的关联都指向其实体的主键。在一些少见的情况中，你可能会指向其他的一个或多个字段，或者是一个表达式，这些情况下，你可以用一个SQL公式来表示。（可以在org.hibernate.test.onetooneformula找到例子） (9) lazy (可选 - 默认为 proxy): 默认情况下，单点关联是经过代理的。lazy="no-proxy"指定此属性应该在实例变量第一次被访问时应该延迟抓取（fetche lazily）（需要运行时字节码的增强）。lazy="false"指定此关联总是被预先抓取。注意，如果constrained="false", 不可能使用代理，Hibernate会采取预先抓取！ (10) entity-name (可选): 被关联的类的实体名。