当前页面: 开发资料首页 → Java 专题 → Hibernate技术(1)
Hibernate技术(1)
摘要: Hibernate技术(1)
一、前言
刚刚接触java的数据库层次的技术的时候，使用的是JDBC，后来做的项目越
来越大了，觉得JDBC到处建立连接，或者使用直接的sql语句，修改或者项目变更起
来很不方便，于是打算自己写一个基于JDBC的上一层的程序，所有的访问都通过这
个程序转换为JDBC的代码来访问数据库。
client
DBAccess
JDBC
db
client
这种技术的采用确实给开发工作带来了十分的改观，所有的对数据库的操作变成了
对某个对象的操作，我采用了java语言特有的reflection机制，动态的取得某个
Javabean的属性，然后对应到(mapping)某个数据库的表中，这样，客户端的代码就
变得非常简单，例如：
DBAccess dba = new DBAccess();
Foo f = new Foo();
f.setBar(aBar);
…//Setting properties for class Foo
dba.insert(f);
只要简单的几步操作就可以完成插入数据库的操作。其实我在这里假定了一些设置
，比如大部分的java类型比如int,long,double,String我都mapping成为数据库的
String类型，而且为了知道某个javabean对应的table名称，以及主键的名字，我特
地在javabean里面添加了两个属性来记录这些信息。由于没有采用xml技术来配置这
些信息，使得我的项目管理十分麻烦。
Hibernate，它实际上是一个o/r mapping工具，把java class对应到数据库
的table中，采用了xml技术，java reflection技术等，基本的原理我觉得和我上面
介绍的类还是比较的类似的。
浅析另类O/R Mapping工具----hibernate
之所以说hibernate是一个比较另类的东西，是由于目前业界争吵不休的JDO技术，
JDO似乎正在成为一个标准，JBOSS也出了一个什么DO，大家都在争取成为事实上的
标准，但是在世界的另异域，有一些程序高手默默的维护着、发展着hibernate技术
。Hibernate技术本质上也是遵守的ODMG标准的，它的出色源于不断的升级、不断的
维护、修改。以及完善的文档、人气很旺的论坛。还有很重要的一点就是它的易学易用性。
这里我就举一个比较浅显的例子，相当于我们程序员都知道的HELLOWORLD程序。但
是这第一步也是非常重要的。
二、下载并且安装hibernate
hibernate是sourceforge的一个子项目，从google上面搜索hibernate你可
以搜索到hibernate的所有连接。具体的，你可以从
http://hibernate.sourceforge.net上面获得下载的连接，目前最新的release版本
是hibernate 2.0.1(2003-6-17)，当然，你也可以从cvs上面获得源代码，然后自行编译。
三、Hibernate基本概念
Hibernate技术本质上是一个提供数据库服务的中间件。它的架构如下图所示：
此图显示了hibernate的工作原理，它是利用数据库以及其他一些配置文件如
hibernate.properties，XML Mapping等来为应用程序提供数据持久服务的。它的
API中包含以下一些主要的类。
1、SessionFactory (net.sf.hibernate.SessionFactory)
包含已经编译的映射(mappings)，是制造session的工厂，可能含有一些可以在各个
事务(transaction)之间共享的数据。
2、Session (net.sf.hibernate.Session)
单线程的，短寿命的对象，代表了一次会话的过程。实际上是把一个JDBC
Connection打包了，它可以包含一些持久化对象的缓存。
3、Persistent Objects and Collections
单线程的，短寿命的对象，包含了各种属性字段以及一些商业逻辑，它们可能仅仅
是一些普通的javabeans，但是它必然在某个时刻只能和一个session相关联。
我就介绍这些吧，详细的大家可以看hibernate自带的文档，里面写的非常详细。
四、开始写程序吧
我准备用一个比较好的例子来简要的说明hibernate的强大功能。我的这个
程序使用了其他一些相关的技术如ANT,LOG4J,JUIT等等，如果大家希望得到这些技
术相关文档，可以和我联系。
在开始这个例子之前，我详细介绍一下这个例子程序的大概情况，我将循序
渐进的介绍hibernate的功能，为此，我将先写一个简单的例子程序，然后我们再把
它做复杂。
是这样的，我们假设：我们要写一个关于儿童（Child）的应用程序，主要
管理儿童的相关信息（如儿童玩具Toy），那么我们首先要建模。如下：
实际类的代码：
Child类，主要含有一个id,和一个toys属性，表示一个Child可以拥有多个toys，采
用的是数组形式。
public class Child {
public int getId(){
return id; }
public void setId(int id){
this.id = id; }
public void setToys(Toy[] toys) {
this.toys = toys; }
public Toy[] getToys() {
return toys; }
private int id;
private Toy[] toys; }
类Toy
public class Toy {
public int getToyId(){
return toyId; }
public void setToyId(int toyId){
this.toyId = toyId; }
public String getName(){ return name; }
public void setName(String name){ this.name = name; }
private int toyId;
private String name; }
我们可以看见，一个儿童可以具有很多玩具，这是一个明显的一对多关系，
在Hibernate里面有这样的标签与之对应
类写mapping.xml文件了，在hibernate里面，每个要持久化的类都要求有相应的
mapping文件，这样hibernate才会知道如何把java class property对应到table
columns里面了，有的时候我们不用自己指明java某个属性的类型，hibernate有
reflection机制，它可以在运行时动态的察觉某个属性的类型，然后对应到相应的
数据库类型中。
Hibernate技术（2） vipcowrie（原作）
关键字 java,hibernate
我们可以看见，一个儿童可以具有很多玩具，这是一个明显的一对多关系，在
Hibernate里面有这样的标签与之对应
写mapping.xml文件了，在hibernate里面，每个要持久化的类都要求有相应的
mapping文件，这样hibernate才会知道如何把java class property对应到table
columns里面了，有的时候我们不用自己指明java某个属性的类型，hibernate有
reflection机制，它可以在运行时动态的察觉某个属性的类型，然后对应到相应的
数据库类型中。
1、 配置hibernate.properties文件
你可以拷贝一份例子，然后稍加改动便可以使用了，关键在于以下几处：
配置数据库，如下
## Oracle
hibernate.dialect net.sf.hibernate.dialect.OracleDialect
hibernate.connection.driver_class oracle.jdbc.driver.OracleDriver
hibernate.connection.url jdbc:oracle:thin:@locahost:1521:oracle8i
hibernate.connection.username test
hibernate.connection.password test
设置开发模式
## print all generated SQL to the console
hibernate.show_sql true
这样，开发的时候可以看见实际运行的sql语句了。
2、 我们先建立一个名为Hibernate.cfg.xml的文件，这样，Hibernate就知道数据
库的属性以及要加载的mapping文件的位置了。
文件内容如下：
我来解释一下，hibernate-configuration为顶级元素，然后的property dialect告
诉了hibernate底层的数据库名称，对于不同的数据库hibernated都内建了相应的类
来对应，这些类都在net.sf.hibernate.dialet包中，为什么这样哪？因为每种数据
库都有不同的o/r mapping机制，况且处理主键的机制也很不相同，所以有必要这样
做。其实切换数据库对于hibernate来说也非常的方便，只要更换这个属性就可以了
。当然，如果你在其他的配置文件里面用到了数据库特定的配置，那么也必须做相应的修改。
接下来的mapping resource=””就表示了每个持久化的类对应的mapping文
件，当然，你也可以不用为每一个类写一个mapping 文件，如果可以的话，我建议
为逻辑上相关的类或者一个包写一个mapping文件就可以了。这样显得比较紧凑，不
会看见你的源代码里面到处都是xml文件了。当然，目前也有一个工具叫做xdoclet
，可以自动帮助你产生mapping文件，但是我想那样的自动化处理毕竟不是十分的灵
活，大部分使用hibernate的人都是采用自己手工写mapping文件的。所有我也推荐
大家在学习hibernate的时候，不要偷懒，一开始就使用xdoclet来产生mapping文件
，这样你的基础会很不牢靠。
还有一点，就是这个resource=value里面的value是和package的名字相对应
的。一般情况下，都把类和类的mapping文件放在一起。
3、 撰写mapping文件
大家或许比较关心到底hibernate是如何把java class对应到table column的哪？其
实在hibernate的文档里面，这一点介绍的比较清楚，里面专门有一章来介绍
mapping机制，因为这是应用hibernate的基础，以后你会发现，你的大部分时间都
将花在mapping上面，而不是写sql语句了。
先看Child类的mapping文件
database table中
SEQ_CHILD
里面需要注意的有以下几点：
1) 如果你采用了one-to-many的关系，并且使用了session.saveOrUpdate
()方法，那么你最好让
2) 注意，child-toy之间的one-to-many关系是通过外键关联上去的。这个
外键就是toy表里面的child_id字段。
3) 由于我们采用array来实现one-to-many的关系，所以我们必须制定一个
额外的字段来存储这个array的索引，这样你存进去的序号和你取出来的序号是一致
的，当然，如果你不想让hibernate记住序号就不用这个字段了，可以使用
4) 注意
属性为all，那么当save,update,delete一个Child类的时候，其属性toys也会相应
的得到save,update,或者delete，否则不会。当然你也可以使用实现hibernate自带
的接口LifeCycle来实现这个功能。但是没有必要。 注意，这个功能有一点要注意
，就是hibernate没有垃圾收集功能，当你删除了一个Child类里面的toys里面的某
个toy的时候，实际上数据库中并没有删除这个记录，你必须手动的删除它。这是目
前hibernate开发者们正在思考改进的一个问题。他们或许会采用JDO的机制
好了，再看Toy.hbm.xml文件
SEQ_TOY
相似的，Toy类制定了主键产生的方式，以及一个简单的属性name，由于数据库的字
段名称和Java类的属性名称一致，所以不用制定property 里面的column属性。
Hibernate技术（3） vipcowrie（原作）
关键字 java,hibernate
1、 撰写数据库的定义
hibernate需要底层数据库的支持。我们为了测试也要求先建立数据库的相关表格，
然后插入一些常用的数据来测试。
数据库的定义如下：
drop table TOY;
drop table CHILD;
drop table employers;
drop table employment_periods;
drop table employees;
create table CHILD (
ID NUMBER not null primary key );
create table TOY (
TOY_ID NUMBER not null primary key,
CHILD_ID NUMBER ,
POSN NUMBER default 0,
NAME varchar(20) default '',
constraint FK_CHILD foreign key (CHILD_ID) references CHILD (ID)
);
DROP SEQUENCE SEQ_TOY;
DROP SEQUENCE SEQ_CHILD;
CREATE SEQUENCE "SEQ_TOY" INCREMENT BY 1 START WITH 1 MAXVALUE 1.0E28
MINVALUE 1 NOCYCLE CACHE 20 NOORDER;
CREATE SEQUENCE "SEQ_CHILD" INCREMENT BY 1 START WITH 1 MAXVALUE 1.0E28
MINVALUE 1 NOCYCLE CACHE 20 NOORDER;
主要做了这些工作：申明主键，申明外键，创建主键对应的sequence，注意我们采
用的是oracle数据库。
2、 好了，我们可以写一个ant脚本来编译我们的程序了
主要的target如下:
定义环境变量：
编译：
3、 好了，我们现在可以使用我们的hibernate了。
例如我们插入一个Child，写了一个函数如下：
public int insertChild(Child c) throws HibernateException {
Transaction tx = null;
Session s = null;
try{
s = HibernateSessionFactory.openSession();
tx = s.beginTransaction();
s.save(c);
tx.commit();
}catch(HibernateException he){
if ( tx!=null ){
tx.rollback(); }
throw he;
}finally{
s.close(); }
return c.getId(); }
关键部分用红色标出。实际上我们调用了session类的save方法，session类还有很
多其他的方法可以调用，如下：update,load,delete等等。传入一个类的引用，便
可以保存了。作用类似于insert into …，然后我们的测试代码如下：
//首先实例化三个Toy类
Toy t1 = new Toy();
t1.setName("wawa1");
Toy t2 = new Toy();
t2.setName("wawa2");
Toy t3 = new Toy();
t3.setName("wawa3");
Toy[] toys1 = new Toy[] {t1,t2};
Toy[] toys2 = new Toy[] {t1,t2,t3};
Toy[] toys3 = new Toy[] {t1,t2};
Child c = new Child();
c.setToys(toys1);
ed.insert(c);//插入含有两个toy的Child
c = (Child)ed.findById(c.getClass(),1);//从数据库中取得这个Child类
this.assertEquals(2,c.getToys().length);//应该是两个toy
c.setToys(toys2);//重新设置toys属性
ed.update(c);//更新到数据库中
使用单元测试结果如下：
compile:
[echo] compiling...
test:
[echo] run test...
[java] .15:13:21,818 INFO Environment:378 - Hibernate 2.0 beta 6
[java] 15:13:21,878 INFO Environment:412 - loaded properties from
resource hibernate.properties:
{hibernate.connection.driver_class=oracle.jdbc.driver.OracleDriver,
hibernate.cglib.use_reflection_optimizer=true,
hibernate.dialect=net.sf.hibernate.dialect.OracleDialect,
hibernate.jdbc.use_streams_for_binary=true, hibernate.jdbc.batch_size=0,
hibernate.query.substitutions=true 1, false 0, yes 'Y', no 'N',
hibernate.query.imports=net.sf.hibernate.test, net.sf.hibernate.eg,
hibernate.connection.username=zhaocw,
hibernate.connection.url=jdbc:oracle:thin:@CCSERVER:1521:oracle8i,
hibernate.show_sql=true, hibernate.connection.password=zhaocw,
hibernate.statement_cache.size=25, hibernate.connection.pool_size=10}
[java] 15:13:21,898 INFO Environment:426 - using java.io streams to
persist binary types
[java] 15:13:21,898 INFO Environment:427 - using CGLIB reflection
optimizer
[java] 15:13:21,928 INFO Environment:437 - JVM proxy support: true
[java] 15:13:21,938 INFO Configuration:689 - Configuration
resource: /hibernate.cfg.xml
[java] 15:13:22,929 INFO Configuration:270 - Mapping resource:
hibernate/Child.hbm.xml
[java] 15:13:23,170 INFO Collection:174 - Mapping class:
hibernate.Child -> CHILD
[java] 15:13:23,340 INFO Configuration:270 - Mapping resource:
hibernate/Toy.hbm.xml
[java] 15:13:23,420 INFO Collection:174 - Mapping class:
hibernate.Toy -> TOY
[java] 15:13:24,411 INFO Configuration:871 - Configured
SessionFactory: null
[java] 15:13:24,411 INFO Collection:976 - Mapping collection:
hibernate.Child.toys -> TOY
[java] 15:13:25,242 INFO SessionFactoryImpl:140 - building session
factory
[java] 15:13:25,262 INFO Dialect:37 - Using dialect:
net.sf.hibernate.dialect.OracleDialect
[java] 15:13:25,272 INFO DriverManagerConnectionProvider:41 -
Hibernate connection pool size: 10
[java] 15:13:25,292 INFO DriverManagerConnectionProvider:70 - using
driver: oracle.jdbc.driver.OracleDriver at URL:
jdbc:oracle:thin:@CCSERVER:1521:oracle8i
[java] 15:13:25,292 INFO DriverManagerConnectionProvider:71 - connection properties: {user=zhaocw, password=zhaocw}
[java] 15:13:25,323 INFO PreparedStatementCache:60 - prepared
statement cache size: 25
[java] 15:13:25,333 INFO SessionFactoryImpl:170 - Use outer join
fetching: true
[java] 15:13:26,033 INFO SessionFactoryImpl:193 - Use scrollable
result sets: true
[java] 15:13:26,033 INFO SessionFactoryImpl:202 - echoing all SQL
to stdout
[java] 15:13:27,145 INFO SessionFactoryObjectFactory:82 - no JDNI
name configured
[java] 15:13:27,145 INFO SessionFactoryImpl:287 - Query language
substitutions: {no='N', true=1, yes='Y', false=0}
[java] Hibernate: select SEQ_CHILD.nextval from dual
[java] Hibernate: select SEQ_TOY.nextval from dual
[java] Hibernate: select SEQ_TOY.nextval from dual
[java] Hibernate: insert into CHILD (id) values (?)
[java] Hibernate: insert into TOY (name, TOY_ID) values (?, ?)
[java] Hibernate: update TOY set CHILD_ID=?, POSN=? where TOY_ID=?
[java] Hibernate: select child0_.id as id from CHILD child0_ where
child0_.id=?
[java] Hibernate: select toy0_.TOY_ID as TOY_ID__, toy0_.POSN as
POSN__, toy0_.TOY_ID as TOY_ID, toy0_.name as name from TOY toy0_ where
toy0_.CHILD_ID=?
[java] Hibernate: select SEQ_TOY.nextval from dual
[java] Hibernate: insert into TOY (name, TOY_ID) values (?, ?)
[java] Hibernate: update TOY set name=? where TOY_ID=?
[java] Hibernate: update TOY set CHILD_ID=null, POSN=null where
CHILD_ID=?
[java] Hibernate: update TOY set CHILD_ID=?, POSN=? where TOY_ID=?
[java] Hibernate: select child0_.id as id from CHILD child0_ where
child0_.id=?
[java] Hibernate: select toy0_.TOY_ID as TOY_ID__, toy0_.POSN as
POSN__, toy0_.TOY_ID as TOY_ID, toy0_.name as name from TOY toy0_ where
toy0_.CHILD_ID=?
[java] Hibernate: delete from TOY where TOY_ID=?
[java] Hibernate: update TOY set name=? where TOY_ID=?
[java] Hibernate: update TOY set CHILD_ID=null, POSN=null where
CHILD_ID=?
[java] Hibernate: update TOY set CHILD_ID=?, POSN=? where TOY_ID=?
[java] Time: 6.269
[java] OK (1 test)
可以看见实际上hibernate执行的sql语句，测试结果是成功的。
五、总结
实际上，Hibernate可以实现多层次继承的架构，经常用到的包括
件功能
大，效率也非常搞。建议大家在使用的过程中不断的总结经验，最好能够分享自己的经验。
相关连接：
hibernate论坛：http://sourceforge.net/forum/forum.php?forum_id=128638
hibernate主页：http://hibernate.sourceforge.net
FAQ: http://hibernate.bluemars.net/14.html?
cowiki=c39f9c2408fc3b0ae5d9eeadd0953905#9
↑返回目录
前一篇: Hibernate查询解决方案
后一篇: Hibernate 中文参考手册（3）