hibernate学习笔记

Hibernate学习笔记

1．          Hibernate 介绍 @$ I;q
  
h[sAOP>  
Hibernate 是一个开放源代码的 O/R Mapping ( 对象关系映射框架 ) ，它对 JDBC 进行了轻量级的对象封装，使 Java 程序员可以随心所欲的使用对象编程思维来操纵数据库。 C5t#'@nk6  
v~;w+F==rf  

Hibernate 是一个面向 Java 环境的对象 / 关系数据库映射工具。对象 / 关系数据库映射 (object/relational mapping (ORM)) 这个术语表示一种技术，用来把对象模型表示的对象映射到基于 SQL 的关系模型结构中去。 Hibernate 不仅仅管理 Java 类到数据库表的映射，还提供数据查询和获取数据的方法，可以大 {<j;4R D  

幅度减少开发时人工使用 SQL 和 JDBC 处理数据的时间。 Hibernate 的目标是对于开发者通常的数据持久化相关的编程任务，解放其中的 95% 。 s},z]  

Hibernate 开发准备工作需要准备工具 : u')byK_V  
iFC %3v1b  
Hibernate 工具，下载地址 :[url]http://www.hibernate.org.cn/download/[/url] i,g<s(:  
bb,Cb-a)  
hibernate-2.1.2.zip ，然后将其解压缩。假设放到 C:\hibernate-2.1 目录下（我们在这里设置环境变量 HIBERNATE_HOME= C:\hibernate-2.1 ）。让我们看看 Hibernate 的包情况，首先在 %HIBERNATE_HOME% 目录下有一个 hibernate n+.[m59M  
I$x+wCa5  
2.jar ，该包就是我们进行 Hibernate 开发所需要用到的 Hibernate 工具包，当然 Hibernate 本身还需要其他 lib 的支持，这些支持包都在 %HIBERNATE_HO x^!-\n e9  
LJx~vw1 6  
ME%\lib 下面。请看表 1-1 ， Hibernate 的第三方库 -tC2U n  
1,a+omt  

库名称 h$0:})# L:	说明 5I._:(t4
dom4j ( 必需） =%$ XxF"f	Hibernate 在解析XML 配置和XML 映射元文件时需要使用dom4j。 `+b|OmZ
CGLIB ( 必需） s/K)_"e+[	Hibernate 在运行时使用这个代码生成库强化类（与Java 反射机制联合使用）。 I[D<'`
Commons collection,Commons logging ||Q<EsX{N|	Hibernat 使用Apache Jakarta Commons 项目提供的多个工具类库。 ]G)uZB9     ^ ,on<;
ODMG4 ^HlZ?Fc%t	Hibernate 提供了一个可选的ODMG 兼容持久化管理界面。如果你需要映射集合，你就需要这个类库，就算你不是为了使用ODMG API。 fR$dB3v
Log4j ~C&U1p	Hibernate 使用Commons Logging API,后者可以使用Log4j 作为实施log 的机制。如果把Log4j 库放到上下文类目录中，Commons Logging就会使用Log4j 和它在上下文类路径中找到的 log4j.properties 文件。在Hibernate 发行包中包含有一个示例的properties 文件。所以，也把log4j.jar 拷贝到你的上下文类路径去吧。 `d^#9gAt
其他文件是不是必须的 >0#(oB Yy	请察看Hibernate 发行包中的/lib/README.txt 文件。这是一个 kO wS67   Hibernate 发行包中附带的第三方类库的列表，总是保持更新。你可以在那里找到所有必需或者可选的类库的列表。 =brZu-S

表 1-1 /+,
|#w  

2．                Hibernate 的配置 zp?*~#  
2Z/z<V0cc}  
首先，让我们看看 Hibernate 的全局配置文件，这个配置文件可以有两种形式，每种形式都可以完成 Hibernate 的配置工作，分别是 hibernate.properties 或者 hibernate.cfg.xml ，这个文件需要放到上下文路径下面（假设在一个 Web 应用下，需要放到 WEB-INF/classes 下面） , 但请注意，虽然 hibernate 官方说法是必须放到该目录下，其实是可以放在别的路径下面，只需要在 buildSessionFactory 的时候加入配置文件的路径就可以了。关于配置文件的内容，可以参看 %HIBERNATE_HOME%\src 目录中 hibernate.properties 文件，而关于其含义解释，可以参看 :  !|ffD92c  
[url]http://www.javajia.com/article.php?id=901[/url] 32@OWw_e/  
w~k9E]d{  
[url]http://www.hibernate.org.cn/53.html[/url] |oR S@b~>  
:Rjd_Sj  
  J"JZz(9=e  
T6A7w(e^  
在进入 Hibernate 例程之前还需要其他一些准备工作。下载应用服务器 JBoss3.2.6 ，其下载地址为： lL
cd`;}a  
REFG*tfDJ  
[url]http://voxel.dl.sourceforge.net/sourceforge/jboss/jboss-3.2.6.zip[/url] E%Kv$"wf  
"ZX|m%'  
下载 mysql5.0.0 ，其下载地址为： ] OFFh.[!  
^u7k
yH*`M  
[url]http://mysql.linuxforum.net/Downloads/MySQL-5.0/mysql-5.0.0a-alpha-win.zip[/url] R(0Aa|;Sz+  
Se<i^
q  
以及 mysl 数据库的 jdbc 数据库连接包，下载地址： ^Hyah;'^)  
>vNj{U  
[url]http://dev.mysql.com/get/Downloads/Connector-J/mysql-connector-java-3.1.4-beta.zip[/url] *s/ADVS  
/
+dO-R  
当然，你还必须确定你已经安装了 j2sdk1.4.2 ，如果没有请下载安装： XUdefm n  
t6KcL71[k  
[url]http://java.sun.com/j2sk/1.4.2/download.html[/url]  t;5 _is  
WJfvxV.S  
还有就是你必须确定，您已经将 JAVA_HOME ， JBOSS_HOME ， classpath 等环境变量设置齐全。最好将 mysql 的 jdbc 连接包，放到 %JBOSS_HOME%\ (?$#BFTmL  
OdhtV4Ia  
server\default\lib 下面。 !YW_DD  
<! 'Hrb  
此外，你还需要在 mysql 数据库中建立一个 test 库，并且在该库中建立一张名为 courses 的表，其创建语句为： 02|j Ka[  
TYQ!5I!p  
create database if not exists `test`; Cj[]p" Eg  
*a^k~ac-  
use `test`; Rj>39(C  
^f&9&A4L  
drop table if exists `courses`; uzaatnhyY  
1k< ~RoD  
CREATE TABLE `courses` ( O2j2Qih<  
Le?9c^zp  
  `CourseId` varchar(32) NOT NULL default '', =V%:Tz3Wf  
D`-YxhcD  
  `name` varchar(32) default NULL, +YBH1`&;?  
Y{dazNXm&  
  PRIMARY KEY  (`CourseId`) 5O8 4:-=  
7~?[m
O3>  
) ENGINE=MyISAM DEFAULT CHARSET=latin1; h79Yz<FC  
G_S"E&t  
INSERT INTO `courses` VALUES -r)"`w#t  
Hp/mnz)O  
('2313213213','eeeeeee'), iM9G AWW  
m>W \rxC  
('12345656','Jacky'), L])`5y{/  
fbY}:K  
('Bonnie','Bonnie'); rOAy@"  
^~Z&U9\E  
这样就创建了我们例程所需要的表和测试数据。此外我们还需要配置 JBoss 的数据源，在此之前，请启动 JBoss ，如若不能正常启动，请查看环境变量配置情况，或者查看 JBoss 网站。找到 %JBOSS_HOME%\server\default\deploy 目录，查看该目录下是否有 mysql-ds.xml 的 mysql 数据源配置文件。如果没有请新建该文件，该文件内容如下： CJ>yS"3B  
]HCRCs,  
<?xml version="1.0" encoding="UTF-8"?> dn(wG4bJ  
j9 .ZDvm&  
<datasources> URD ~nDs+L  
q*Z`!siTZ  
<local-tx-datasource> v9-kK^&  
2s?9GFn  
      <jndi-name>MySqlDS</jndi-name> H<_A#}  
F .P^S NC  
      <connection-url>jdbc:mysql://localhost:3306/test</connection-url> Haoz+)M  
82jf.AB  
      <driver-class>org.gjt.mm.mysql.Driver</driver-class> h!rM_0#_  
_FS/}o8HW  
      <user-name>root</user-name> a^ D8.  
}sR1{K~@  
      <password></password> iGmqy#  
MU j__F  
</local-tx-datasource> SRWS E;z  
U02x#hn  
</datasources> b-pY$fj7  
JG3U]ZZ!8  
这样就配置好了 Jboss 的 jdbc 数据源。其名称为 MySqlDS 。启动 JBoss ，注意控制台输出信息，已经将数据源邦定到 java:/MySqlDS 的 JNDI 名称。 ]!>{|Fwd&  
I=SVG+c  
3．          Hibernate 例程 hs sXOu:0;  
Z*:^U{.Bz  
a)    打开 JBuilder 新建一个 Project ，将其命名为 TestHibernate 。然后 aZ4xeb  
)QLF-q  
将 %HIBERNATE_HOME%\hibernate2.jar 以及 %HIBERNATE_HOME%\lib 下面所有以上提到的包（你也可以将其下所有的包）放到一个 JBuilder library 下，将这个 library 引入 TestHibernate 工程的 classpath 下面。这样就将所有 hibernate 所需要的包引入了。 X-p)2B xn  
jPqyzzT  
b)    建立第一个可持久化类。新建一个类，将其 package 设 com.hibernate IyvEc2Hhe  
C:23~/*o @  
并且将其命名为 Cours.java ，其代码如下 : pC+s{  
qQ=,um=q5  
package com.hibernate; 9leW X.  
e$&8Q$  
import java.util.Set; 96eS/+6  
-lS}ilh|  
/** ,$Qf.y  
\Ow4ag0  
* 在 hibernate 中代表了 Course 表的类。 LFD0j;$ [  
sR mDo,5  
*/ G|l|2G-Lw  
TR|
4CPD  
public class Cours i0{3>|>:  
&a nq=H  
{ ,\o sSl;$?  
nu`Q ?  
  /** 每个属性和表的一个字段对应 **/ TTFI:bc  
#6vlwvj  
  private String courseId; d]Os}-&  
h ! #H`  
  private String name; o=%hIYOR  
TxVO~x#h  
  /**students 表示 course 中的学生，在后面才会用到，暂时不管 **/ @$zO N$u  
zI3eC:*p  
  private Set students; *s6RZ~  
|#%Ks@L  
  /** 属性的访问方法 **/ tSLhCW"&+  
fu6KO'  
public void setCourseId(String string) { )=2*YG-p  
IXWoTeS  
courseId = string; [ u]=bK  
<j2N6;z  
} K, ::?e  
WI i3  
  P~ CG?_R  
I22LG")f  
public String getCourseId() { #iLBYz  
_#11G:  
return courseId;  a8iM7.+  
1Y6Vhv1A  
} 
Q>s_>@  

opTjcc*^  
  ptT
& wLQQ  
i :k.Nd01[  
public void setName(String name){ `P)-a   
vHw/ E;7  
this.name=name; W)^7+v4g]w  
]e7U&m.8)2  
} FM o;0N  
GN|%<p4N  
public String getName(){ :JUX v  
zlGfl0mUU  
return this.name; qYpskrpGe)  
f]8s3)  
} 8?Eu\>d  
mNIK {z  
public void setStudents(Set stud){ edE$ejU3  
jbv_fe  
this.students=stud; oBCkosatx  
L~? ~} {  
} @0~DuS#Kaa  
h41ziIn  
public Set getStudents(){ ixLFvBJ>(n  
*c or*(  
return this.students; G)SL}yv~  
8Xt(zC4-  
} BujNeBc  
]'ieMT"$_  
} 9-@DVJ]  
0]nq-")~  
      c) 建立一个 Jsp 页面以便 JBuilder 生成 defaultroot 目录结构，编译 java 源文件。 -sG~~  
*X8z:_@w  
      d) 这个时候我们就可以找到该 JBuilder 工程所在的目录，找到 defaultroot 下面的 classes 目录，在该目录中手工建立一个 Hibernate 配置文件 hibernate.cfg.xml ，现在我们来看配置该文件。 ]}(P=  
=Eksjgnq^  
<!DOCTYPE hibernate-configuration =DB^R}}~  
' ?;aPXh  
    PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN" U77r\jhw  
$4M'="N5  
    "[url]http://hibernate.sourceforge.net/hibernate-configuration-2.0.dtd[/url]"> HWnaO?m  
k :)S1AT5B  
  _,

9  
%-cnuc2fz  
<hibernate-configuration> j]8n\pXI  
W:&$iv~D  
    <session-factory> 87n% dB  
&3CmP;=;  
        <property name="connection.datasource">java:/MySqlDS</property> J mdOkZbq  
iU,L,`}!g  
        <property name="show_sql">false</property> gIbmg2kY:  
h lGzR% 7  
        <property name="dialect">net.sf.hibernate.dialect.MySQLDialect</property> P5g!+l6^  
W3lm#"0yg|  
        <property name="jndi.class">org.jnp.interfaces.NamingContextFactory</property> qpG|e<m/  
s&/by79EC  
        <property name="jndi.url">jnp://localhost:1099/</property> k*%Vm^zR   
v Czq lp  
  sDNmT5a!  
?@;mld8m  
        <!-- Mapping files --> '\+hCJ(:  
iO!+Hu?W  
        <mapping resource="Cours.hbm.xml"/> ^d+ZmfxZ/  
qYz=8r~B  
    </session-factory> 9HT>d $'q!  
DW@Ts-v  
</hibernate-configuration> E`,v,H  
z_*Av^T-  
首先我们要确保 Hibernate 会连接到 MySql 数据库，参考前文提到的 Hibernate 配置文档，这是就需要我们配置 hibernate.dialect 方言属性，该属性说明 hibernate 需要连接的数据库类型，在此我们设置为 MySql 类型。将 hibernate.dialect 设置成 net.sf.hibernate.dialect.MySQLDialect 。 P)Z7cCB$R  
>y6\ |t-  
而访问数据库的数据源，我们在此设置成了 java:/MySqlDS 。我们需要注意， Hibernate 自带一个连接池配置方案 (hibernate.properties 方案 ) ： ms|b}_*  
PjnH=f/  
hibernate.dialect net.sf.hibernate.dialect.MySQLDialect y;&Cpg~  
v0FSe '  
hibernate.connection.driver_class com.mysql.jdbc.Driver n 8,Kk9  
/i_gr2c|  
hibernate.connection.url jdbc:mysql:///test /w?At7=  
#G[a vU|  
hibernate.connection.username root jmn-6j>/  
IbPik[  
hibernate.connection.password Go3D%
:d2  
V=62So%~  
      如果你去研究 Hibernate 的源代码，会发现 Hibernate 自带的连接池方案是一个非常原始的连接池，所以我们在此不用。 Hibernate 总共有三种连接吃方案： Hibernate 自带连接池、 Hibernate 带的 DBCP 连接池、 App Server 的连接池。当然，我们选择的是最后一种方案，采用 App Server 提供连接池的方案。 z5<AF/$B^  
k;F8d#tF  
      而 hibernate.show_sql 属性是让用户能够购在调试程序的时候通过控制台看到 sql 语句的输出，以便用户调试，在这里我们选择了关闭该输出，当然你也可以打开该输出，只要将该属性设置为 true 值。 <- :o'*<_  
QadNR<'v  
      对于 hibernate.jndi.class 和 hibernate.jndi.url 属性，该属性是当你如果想从远程客户端直接调用处在不同的 JVM 下的资源的时候，你就需要通过这两个属性查找 JNDI 资源，这里设置的是通过 jnp 提供的 NamingContextFactory 来查找 jnp://localhost:1099 这个服务下的资源。但是需要注意的是： JBoss 配置的 DataSource 的 JNDI 名称是 java:/MySqlDS ， JBoss 是不支持远程客户端对其 JNDI 资源的调用。所以在这里这两个属性并没有实际意义，而当我们将 JBoss 换成如 Weblogic 等的应用服务器的时候，就可以在远程客户端通过查找 JNDI 名称来获得处于另外 JVM 下的服务器资源，例如连接池数据源。 %u]@h7* n  
:?7 "A  
      对于 mapping 映射属性，这是通知 hibernate ，让其知道现在已经有一个映射文件来映射数据库中的表，这个文件名是 Cours.hbm.xml 。 ZZ/#MV7UD  
3|x Srq?  
      有关 hibernate.cfg.xml 或者 hibernate.properties 文件的更多配置信息，请参看前文提到的参考地址。 ;cwj,C  
J?axf5I/  
e) 下面让我们看看上节提到的 Cours.hbm.xml ，同样，这个文件需要 `-'6tt!7k/  
Xm5r;#  
放到 defaultroot\classes 目录下。该文件的内容如下： `Z`H5\Mt  
~g9[3]q?
 
      <?xml version="1.0"?> v{%Ks ,5+  
6,E][{2$  
<!DOCTYPE hibernate-mapping PUBLIC nW Ffkoq  
OfLnr[  
    "-//Hibernate/Hibernate Mapping DTD 2.0//EN" 1ED>ij/  
n6 Gd,Rx%  
    "[url]http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd[/url]" > |5jqqc{  
S;d,dR?  
    cb?u`r  
VyJ*7$S  
<hibernate-mapping> (% ?cJ7  
*&*^.D*#f  
    <class A\A74d  
kcF#M
e]i  
        name="com.hibernate.Cours" p+-@P@Z  
qQd[ys!4|  
        table="Courses" '+(^2lQ#-  
P|YB   
        dynamic-update="false" (JH44W_  
K7/CQ| 7  
    > K1czY
&!+]  
TOgT'Fve  
        <id
A{#AgW#  
]W,P5  
            name="courseId" Wrq?LY*&J@  
p6 lSz  
            column="CourseId" E<;V{zOL  
BH} 3a)Y6  
            type="string" Ar6P<W))  
l s0m9  
            unsaved-value="any" K |]&|e  
*)SU@kG  
        >
Yv-&ai+  
5vHm'@
jF  
            <generator class="assigned"/> c>d
 
CeXe09 r*  
        </id> =>(f] 8!  
vLq3o/;h  
  p<li"nn  
+AR
3~kD=:  
        <property ,'# 7m  
""RqeD  
            name="name" Dzscs[%K  
Wn|IzeQI  
            type="string" Q3p$0nvP  
CKB`j >_%  
            update="true" bmL!u_U9{  
ZYRg[
BC[q  
            insert="true" P?bf6+b#  
DAZ[*Gf5  
            column="Name" B3wGjUl  
u3Q&y|$%  
        />      P0xU3SZ  
@ <N} 0  
    </class> ~9\*Jo  
3Wv$FQ1 $  
</hibernate-mapping> p:_m'#V  
&!S^>mFZ\  
      首先让我们来看 class 节点，该节点描述数据库中的一个表对应我们创建的一个可持久化类（该持久化类类似于 JavaBean ，通过 getter 和 setter 方法访问）。在这里我们可以看到 name 为 com.hibernate.Cours 的可持久化类对应于 table 为 Courses 的数据库表， dynamic-update 属性用来标识是否对 update 的 sql 语句在运行时动态生成，并且之更新那些改变过的字段。在这里我们不需要过于关注这个属性。 :C/7  
;0YL"  
      其次，观察 id 子节点，该节点表示了表的关键字段， name=”courseId” 表明了 com.hibernate.Cours 类中的对应 courses 表主关键字的 attribute 属性是 courseId 。而对应的字段是 column="CourseId" ，类型为 type="string" #k7GSR*  
n,B{M_$1  

而对于 unsaved-value="any" 一个特定的标识属性值，用来标志该实例是刚 z4o~< 6w  

刚创建的，尚未保存。这可以把这种实例和从以前的session 中装载过但未再次持久化的实例区分开来。 <generator> 节点定义该主关键字的生成规则， assign 表示该主关键字生成规则为用户在 save 之前为对象分配主关键字标识符。关键字生成规则有以下几种类型： q/Gd.r%  

      increment （递增） bxAup-  

用于为 long , short 或者 int 类型生成唯一标识。只有在没有其他进程往同一张表中插入数据时才能使用。在集群下不要使用。 =y3rxnte  

Identity +hPQ{IJ.  

对 DB2,MySQL, MS SQL Server, Sybase 和 HypersonicSQL 的内置标识字段提供支持。返回的标识符是 long , short 或者 int 类型的。 s>#FrN,  

sequence （序列） \2\k8{yO  

在 DB2,PostgreSQL, Oracle, SAP DB, McKoi 中使用序列（ sequence ) ，而在 Interbase 中使用生成器( generator ) 。返回的标识符是 long , short 或者 int 类型的。 \'>:+B2  

hilo （高低位） 8X7a;HM1]  

使用一个高/低位算法来高效的生成 long , short 或者 int 类型的标识符。给定一个表和字段（默认分别是是 hibernate_unique_key 和 next ）作为高位值得来源。高/低位算法生成的标识符只在一个特定的数据库中是唯一的。在使用JTA 获得的连接或者用户自行提供的连接中，不要使用这种生成器。 &%'J=B  

seqhilo （使用序列的高低位） z 6&\p5D  

使用一个高/低位算法来高效的生成 long , short 或者 int 类型的标识符，给定一个数据库序列（ sequence ) 的名字。 kj<KD V?  

uuid.hex UhC5^7)  

用一个128-bit 的 UUID 算法生成字符串类型的标识符。在一个网络中唯一（使用了 IP 地址）。 UUID 被编码为一个32 位16 进制数字的字符串。 MA0#GY  

uuid.string C<W%MI7  

使用同样的 UUID 算法。 UUID 被编码为一个16 个字符长的任意ASCII 字符组成的字符串。不能使用在 PostgreSQL 数据库中 + --_{!  

native （本地） </B(wKsH#  

根据底层数据库的能力选择 identity , sequence 或者 hilo 中的一个。 ~YTo["g^]  

assigned （程序设置） T/*X,o<n  

让应用程序在 save() 之前为对象分配一个标示符。 ? AD/Z  

foreign （外部引用） 7^'=19/"  

使用另外一个相关联的对象的标识符。和 <one-to-one> 联合一起使用。 e!TA[OQ QE  

      Hibernate 用 property 节点来描述其他非关键字字段的属性， DV4b e4j  
"4It0 k'  

    f) 我们需要创建一个 HibernateUtil 类，来作为获取 Session 的工具类。 Ex4B_U?R~  

我们现在可以开始 Hibernate 的 Session 了。我们用它来从数据库中存取 Cours 。首先，我们要从 SessionFactory 中获取一个 Session (Hibernate 的工作单元）。 h 5T_C+S  

SessionFactory sessionFactory = q}e$8?Ww  

new Configuration().configure().buildSessionFactory(); vKv4geI  

SessionFactory 负责一个数据库，也只对应一个 XML 配置文件（ hibernate.cfg.xml ）。你可以用喜欢的任何方式编写一个 Servlet, 包含下面的代码，只要确保 SessionFactory 只创建一次。也就是说你不能把它作为你的 Serlvet 的实例变量。一个好办法是用在辅助类中用一个静态 SessionFactory ，例如这样： N*wkAt{>  

import net.sf.hibernate.*; BrS "#&jg9  

import net.sf.hibernate.cfg.*; J'Ep`20!0D  

public class HibernateUtil { kF@gE7{u)  

private static final SessionFactory sessionFactory; 2M:5H+y 4j  

static { *` =P  

try { GI#[5  

sessionFactory = new 4+[V k7+U  

Configuration().configure().buildSessionFactory(); U|H[
Qc
 

} catch (HibernateException ex) { G1&*0sF\o  

throw new RuntimeException("Exception building s1)[Yv  

SessionFactory: " + ex.getMessage(), ex); xVQJs2M8  

} ~#4 ^'Eg  

} 8K y h  

public static final ThreadLocal session = new ThreadLocal(); 1I1=<d\  

public static Session currentSession() throws HibernateException _ vH!D  

{ 8P]&$^0~ `  

Session s = (Session) session.get(); /6xxAt  

// Open a new Session, if this Thread has none yet 5WZ}#Wz  

if (s == null) { /=*fAN(*S  

s = sessionFactory.openSession(); XD1W.;(47  

session.set(s); @[9'0#]H  

} |C%+Rfq9  

return s; I{ !iYR!r  

} 4TS]S+K3]  

public static void closeSession() throws HibernateException { _/@uSB/  

Session s = (Session) session.get(); uB0Oc2  

session.set(null); L`)K,_|S  

if (s != null) dm<-C6W}{  

s.close(); Gbw{T!\B  

} EA ( yJ0  

} Ev["us  

这个类不但在它的静态属性中使用了 SessionFactory ，还使用了 ThreadLocal 来为当前工作线程保存 Session 。 Session 不是线程安全的，代表与数据库之间的一次操作。 Session 通过 SessionFactory 打开，在所有的工作完成后，需要关闭： f|q1
lCB7  

Session session = HibernateUtil.currentSession(); u[`FFcDT  

Transaction tx= session.beginTransaction(); 'oxy=9 F  

Cours course = new Cours(); %ZQa*w4  

course.setCourseId("aaaaaaa");

course.setName(“bbbbbbb”) P-Y4Gd{}3  

session.save(princess); %*0vSz8  

tx.commit(); p ass[i  

HibernateUtil.closeSession(); V50/)~H  

在 Session 中，每个数据库操作都是在一个事务 (transaction) 中进行的，这样就可以隔离开不同的操作（甚至包括只读操作）。我们使用 Hibernate 的 Transaction API 来从底层的事务策略中（本例中是 JDBC 事务）脱身。这样，如果需要把我们的程序部署到一个由容器管理事务 # e32Gv  

的环境中去（使用 JTA) ，我们就不需要更改源代码。请注意，我们上面的例子没有处理任何异常。也请注意，你可以随心所欲的多次调用 HibernateUtil. [0WOFvw?  

currentSession() ， 你每次都会得到同一个当前线程的 Session 。你必须确保 Session 在你的数据库事务完成后关闭，不管是在你的 Servlet 代码中，或者在 ServletFilter 中， HTTP 结果返回之前。 *xHK]h./  

      g) 创建访问 bean 类，来封装调用 hibernate 访问数据库的方法。在这里我们暂且定义该方法为 StoreAccessBean.java 。源文件如下： |Pw9}Q UU  
43JkUDb`  
package com.hibernate; RvFBS**H  
G{xD1jF<  
  <QP^*a.ae  
)
]J8jz@85  
import net.sf.hibernate.HibernateException; xPd |.ZI  
_? =g 06:  
import net.sf.hibernate.Session; 5-uQ!   
fwonu*
G  
import net.sf.hibernate.Transaction; $ ZKjNR*m  
>KI\PM2'1  
import java.util.Iterator; gV(
0:+Mx  
bxMsh.t5  
import java.util.Hashtable; )g?2Fv:  
= >Es"m  
import javax.naming.Context; pKosP/g4  
I6?u"+#8  
import javax.naming.InitialContext; GL_@X4\h  
[:G2|d  
import javax.sql.DataSource; If&.IEVy  
UDCucT,i  
  =?ozuE!Q  
= +44\$cZ  
public class StoreAccessBean{ p>249x g@_  
KKMkLrX  
  public StoreAccessBean(){ TH+!J$p  
1C2`.aMj  
  } 4BNW3I,p  
VQFpA9F[  
  J^kG(#yT  
Q(k; uA  
  public void addStoreAccess(Cours store){ {B P   
(0\%K #Zj0  
    try { < lZ[]m  
sn\z7np
 
      Session session = HibernateUtil.currentSession(); Nsm2U!Jr  
y1lK-n,  
      Transaction trans = session.beginTransaction(); (F#ak:U f  
Me*ptdA/  
      session.save(store); c.#OB C>N  
oGQdT  
      trans.commit(); S34,T[  
K HN=[ sK  
      HibernateUtil.closeSession(); J%0\g< 0r  
? @]PWN  
    } d`O:?Y_f  
HF A B14  
    catch (Exception ex) { AlA "sGi  
o*+lW;0-  
      ex.printStackTrace(); rk Ai7!  
x?5v/Z i  
    } ON{X ~Zi  
^IlL u  
  } 5~s1gCU*E>  
1r,?o+ \  
  B
12\llpk  
LV^8}!  
  public Iterator getAllCourses()throws HibernateException S5p;GG  
(:Y?-|!s  
  { N;=@dSXru  
B"
.A[Z  
    String queryString = "select storeaccess from storeaccess as storeaccess"; 0cl7';"_  
\f!7/o,Y'r  
    Session session = HibernateUtil.currentSession(); S({r0k  
PG?A}GX?  
    net.sf.hibernate.Query query = session.createQuery(queryString); n /^`=8:  
97z'j?i  
    Iterator it= query.iterate(); }R|_kI  
uAS87vYu0  
    HibernateUtil.closeSession(); }C3ia38D  
nmRXP(~ e  
    return it; L? 3t:y  
3r<N".N  
  } vI,NY$ZUmR  
p\8^P/>.  
} bIJ!uzu2  
N* l'a)D  
      该类中有两个方法，一个是添加一条数据的方法，另外一个是查询的方法。 iURoeU![  
~aecm69  
      最后，编译所有文件。在刚才新建的 jsp 中加入以下代码： h_^1  
[ M%Iko~t  
      com.hibernate.Cours access = new com.hibernate.Cours(); access.setCourseId("aaaaaaa"); EoH%PsJv  
>7v (~  
access.setName("bbbbbb"); RK;cby+h  
C]0mKrZh&  
com.hibernate.StoreAccessBean bean = new com.hibernate.StoreAccessBean(); =tI Cb&T  
2D&Y{h;  
最后，打成 war 包，部署到 %JBOSS_HOME%\server\default\deploy 目录中，启动 jboss ，访问建立的 jsp 页面，然后看看数据库中是否多了一条记录，这表明例程运行成功。 `;eQR5*6\