站内搜索: 请输入搜索关键词

当前页面: 开发资料首页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综合查询解决方案