当前页面: 开发资料首页 → Hibernate 专题 → Hibernate技术
Hibernate技术
摘要: 刚刚接触java的数据库层次的技术的时候,使用的是JDBC,后来做的项目越来越大了,觉得JDBC到处建立连接,或者使用直接的sql语句,修改或者项目变更起来很不方便,于是打算自己写一个基于JDBC的上一层的程序,所有的访问都通过这个程序转换为JDBC的代码来访问数据库。
一、前言
刚刚接触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里面有这样的标签与之对应<one-to-many>,然后,我们可以为这两个类写mapping.xml文件了,在hibernate里面,每个要持久化的类都要求有相应的mapping文件,这样hibernate才会知道如何把java class property对应到table columns里面了,有的时候我们不用自己指明java某个属性的类型,hibernate有reflection机制,它可以在运行时动态的察觉某个属性的类型,然后对应到相应的数据库类型中。
Hibernate技术(2) vipcowrie(原作)
关键字 java,hibernate
我们可以看见,一个儿童可以具有很多玩具,这是一个明显的一对多关系,在Hibernate里面有这样的标签与之对应<one-to-many>,然后,我们可以为这两个类写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>
<session-factory >
<property name="dialect">net.sf.hibernate.dialect.OracleDialect</property>
<mapping resource="hibernate/Child.hbm.xml"/>
<mapping resource="hibernate/Toy.hbm.xml"/>
</session-factory>
</hibernate-configuration>
我来解释一下,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文件
<hibernate-mapping>
<class name="hibernate.Child" table="CHILD"> //把java class对应到database table中
<id name="id" unsaved-value="0">//主键描述
<generator class="sequence">//采用oracle的sequence技术自动自增主键
<param name="sequence">SEQ_CHILD</param>
</generator>
</id>
<array name="toys" table="TOY" cascade="all">//描述和toy的一对多关系
<key column="CHILD_ID"/>
<index column="POSN"/>//之所以要写index,因为有array
<one-to-many class="hibernate.Toy"/>
</array>
</class>
</hibernate-mapping>
里面需要注意的有以下几点:
1) 如果你采用了one-to-many的关系,并且使用了session.saveOrUpdate()方法,那么你最好让<id>属性有unsaved-value=”0”属性,否则会抛出违背外键的异常。
2) 注意,child-toy之间的one-to-many关系是通过外键关联上去的。这个外键就是toy表里面的child_id字段。
3) 由于我们采用array来实现one-to-many的关系,所以我们必须制定一个额外的字段来存储这个array的索引,这样你存进去的序号和你取出来的序号是一致的,当然,如果你不想让hibernate记住序号就不用这个字段了,可以使用<set><bag>等来替换<array>
4) 注意<array>里面的cascade属性,这个属性很重要,它表示,如果这个属性为all,那么当save,update,delete一个Child类的时候,其属性toys也会相应的得到save,update,或者delete,否则不会。当然你也可以使用实现hibernate自带的接口LifeCycle来实现这个功能。但是没有必要。 注意,这个功能有一点要注意,就是hibernate没有垃圾收集功能,当你删除了一个Child类里面的toys里面的某个toy的时候,实际上数据库中并没有删除这个记录,你必须手动的删除它。这是目前hibernate开发者们正在思考改进的一个问题。他们或许会采用JDO的机制<delete-orphan>来实现垃圾收集。
好了,再看Toy.hbm.xml文件
<hibernate-mapping>
<class name="hibernate.Toy" table="TOY">
<id name="toyId" column="TOY_ID" unsaved-value="0">
<generator class="sequence">
<param name="sequence">SEQ_TOY</param>
</generator>
</id>
<property name="name"/>
</class>
</hibernate-mapping>
相似的,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如下:
定义环境变量:
<path id="myclasspath">
<fileset dir="${lib}">
<include name="*.jar"/>
<include name="*.zip"/>
</fileset>
<pathelement location="${build}"/>
</path>
编译:
<target name="compile" depends="init">
<echo message="compiling..." />
<javac srcdir="${src}" destdir="${build}" classpathref="myclasspath"/>
<copy todir="${build}" />
</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可以实现多层次继承的架构,经常用到的包括<many-to-one>,<one-to-many>,<one-to-one>,<subclass>,<joined-subclass>等等。还有组件功能<component>可以让某个属性类存储在父类中。总之,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 中文参考手册(4)
后一篇:
Hibernate综合查询解决方案