Hibernate学习笔记

1． Hibernate介绍

Hibernate是一个开放源代码的O/R Mapping (对象关系映射框架)，它对JDBC进行了轻量级的对象封装，使Java程序员可以随心所欲的使用对象编程思维来操纵数据库。

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

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

Hibernate开发准备工作需要准备工具:

Hibernate工具，下载地址:http://www.hibernate.org.cn/download/

hibernate-2.1.2.zip，然后将其解压缩。假设放到C:\hibernate-2.1目录下（我们在这里设置环境变量HIBERNATE_HOME= C:\hibernate-2.1）。让我们看看Hibernate的包情况，首先在%HIBERNATE_HOME%目录下有一个hibernate

2.jar，该包就是我们进行Hibernate开发所需要用到的Hibernate工具包，当然Hibernate本身还需要其他lib的支持，这些支持包都在%HIBERNATE_HO

ME%\lib下面。请看表1-1，Hibernate的第三方库

库名称

说明

dom4j (必需）

Hibernate 在解析XML 配置和XML 映射元文件时需要使用dom4j。

CGLIB (必需）

Hibernate 在运行时使用这个代码生成库强化类（与Java 反射机制联合使用）。

Commons collection,Commons logging

Hibernat 使用Apache Jakarta Commons 项目提供的多个工具类库。

ODMG4

Hibernate 提供了一个可选的ODMG 兼容持久化管理界面。如果你需要映射集合，你就需要这个类库，就算你不是为了使用ODMG API。

Log4j

Hibernate 使用Commons Logging API,后者可以使用Log4j 作为实施log 的机制。如果把Log4j 库放到上下文类目录中，Commons Logging就会使用Log4j 和它在上下文类路径中找到的log4j.properties 文件。在Hibernate 发行包中包含有一个示例的properties 文件。所以，也把log4j.jar 拷贝到你的上下文类路径去吧。

其他文件是不是必须的

请察看Hibernate 发行包中的/lib/README.txt 文件。这是一个

Hibernate 发行包中附带的第三方类库的列表，总是保持更新。你可以在那里找到所有必需或者可选的类库的列表。

表1-1

2． Hibernate的配置

首先，让我们看看Hibernate的全局配置文件，这个配置文件可以有两种形式，每种形式都可以完成Hibernate的配置工作，分别是hibernate.properties或者hibernate.cfg.xml，这个文件需要放到上下文路径下面（假设在一个Web应用下，需要放到WEB-INF/classes下面）,但请注意，虽然hibernate官方说法是必须放到该目录下，其实是可以放在别的路径下面，只需要在buildSessionFactory的时候加入配置文件的路径就可以了。关于配置文件的内容，可以参看%HIBERNATE_HOME%\src目录中hibernate.properties文件，而关于其含义解释，可以参看:

http://www.javajia.com/article.php?id=901

http://www.hibernate.org.cn/53.html

在进入Hibernate例程之前还需要其他一些准备工作。下载应用服务器JBoss3.2.6，其下载地址为：

http://voxel.dl.sourceforge.net/sourceforge/jboss/jboss-3.2.6.zip

下载mysql5.0.0，其下载地址为：

http://mysql.linuxforum.net/Downloads/MySQL-5.0/mysql-5.0.0a-alpha-win.zip

以及mysl数据库的jdbc数据库连接包，下载地址：

http://dev.mysql.com/get/Downloads/Connector-J/mysql-connector-java-3.1.4-beta.zip

当然，你还必须确定你已经安装了j2sdk1.4.2，如果没有请下载安装：

http://java.sun.com/j2sk/1.4.2/download.html

还有就是你必须确定，您已经将JAVA_HOME，JBOSS_HOME，classpath等环境变量设置齐全。最好将mysql的jdbc连接包，放到%JBOSS_HOME%

server\default\lib下面。

此外，你还需要在mysql数据库中建立一个test库，并且在该库中建立一张名为courses的表，其创建语句为：

create database if not exists `test`;

use `test`;

drop table if exists `courses`;

CREATE TABLE `courses` (

`CourseId` varchar(32) NOT NULL default '',

`name` varchar(32) default NULL,

PRIMARY KEY (`CourseId`)

) ENGINE=MyISAM DEFAULT CHARSET=latin1;

INSERT INTO `courses` VALUES

('2313213213','eeeeeee'),

('12345656','Jacky'),

('Bonnie','Bonnie');

这样就创建了我们例程所需要的表和测试数据。此外我们还需要配置JBoss的数据源，在此之前，请启动JBoss，如若不能正常启动，请查看环境变量配置情况，或者查看JBoss网站。找到%JBOSS_HOME%\server\default\deploy目录，查看该目录下是否有mysql-ds.xml的mysql数据源配置文件。如果没有请新建该文件，该文件内容如下：

<?xml version="1.0" encoding="UTF-8"?>

<local-tx-datasource>

<jndi-name>MySqlDS</jndi-name>

<connection-url>jdbc:mysql://localhost:3306/test</connection-url>

<driver-class>org.gjt.mm.mysql.Driver</driver-class>

<user-name>root</user-name>

</local-tx-datasource>

</datasources>

这样就配置好了Jboss的jdbc数据源。其名称为MySqlDS。启动JBoss，注意控制台输出信息，已经将数据源邦定到java:/MySqlDS的JNDI名称。

3． Hibernate例程

a) 打开JBuilder新建一个Project，将其命名为TestHibernate。然后

将%HIBERNATE_HOME%\hibernate2.jar以及%HIBERNATE_HOME%\lib下面所有以上提到的包（你也可以将其下所有的包）放到一个JBuilder library下，将这个library引入TestHibernate工程的classpath下面。这样就将所有hibernate所需要的包引入了。

b) 建立第一个可持久化类。新建一个类，将其package设com.hibernate

并且将其命名为Cours.java，其代码如下:

package com.hibernate;

import java.util.Set;

/**

*在hibernate中代表了Course表的类。

public class Cours

{

/**每个属性和表的一个字段对应**/

private String courseId;

private String name;

/**students表示course中的学生，在后面才会用到，暂时不管**/

private Set students;

/**属性的访问方法**/

public void setCourseId(String string) {

courseId = string;

}

public String getCourseId() {

return courseId;

}

public void setName(String name){

this.name=name;

}

public String getName(){

return this.name;

}

public void setStudents(Set stud){

this.students=stud;

}

public Set getStudents(){

return this.students;

}

c)建立一个Jsp页面以便JBuilder生成defaultroot目录结构，编译java源文件。

d)这个时候我们就可以找到该JBuilder工程所在的目录，找到defaultroot下面的classes目录，在该目录中手工建立一个Hibernate配置文件hibernate.cfg.xml，现在我们来看配置该文件。

<!DOCTYPE hibernate-configuration

PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"

"http://hibernate.sourceforge.net/hibernate-configuration-2.0.dtd">

<hibernate-configuration>

<session-factory>

<property name="connection.datasource">java:/MySqlDS</property>

<property name="show_sql">false</property>

<property name="dialect">net.sf.hibernate.dialect.MySQLDialect</property>

<property name="jndi.class">org.jnp.interfaces.NamingContextFactory</property>

<property name="jndi.url">jnp://localhost:1099/</property>

</session-factory>

</hibernate-configuration>

首先我们要确保Hibernate会连接到MySql数据库，参考前文提到的Hibernate配置文档，这是就需要我们配置hibernate.dialect方言属性，该属性说明hibernate需要连接的数据库类型，在此我们设置为MySql类型。将hibernate.dialect设置成net.sf.hibernate.dialect.MySQLDialect。

而访问数据库的数据源，我们在此设置成了java:/MySqlDS。我们需要注意，Hibernate自带一个连接池配置方案(hibernate.properties方案)：

hibernate.dialect net.sf.hibernate.dialect.MySQLDialect

hibernate.connection.driver_class com.mysql.jdbc.Driver

hibernate.connection.url jdbc:mysql:///test

hibernate.connection.username root

hibernate.connection.password

如果你去研究Hibernate的源代码，会发现Hibernate自带的连接池方案是一个非常原始的连接池，所以我们在此不用。Hibernate总共有三种连接吃方案：Hibernate自带连接池、Hibernate带的DBCP连接池、App Server的连接池。当然，我们选择的是最后一种方案，采用App Server提供连接池的方案。

而hibernate.show_sql属性是让用户能够购在调试程序的时候通过控制台看到sql语句的输出，以便用户调试，在这里我们选择了关闭该输出，当然你也可以打开该输出，只要将该属性设置为true值。

对于hibernate.jndi.class和hibernate.jndi.url属性，该属性是当你如果想从远程客户端直接调用处在不同的JVM下的资源的时候，你就需要通过这两个属性查找JNDI资源，这里设置的是通过jnp提供的NamingContextFactory来查找jnp://localhost:1099这个服务下的资源。但是需要注意的是：JBoss配置的DataSource的JNDI名称是java:/MySqlDS，JBoss是不支持远程客户端对其JNDI资源的调用。所以在这里这两个属性并没有实际意义，而当我们将JBoss换成如Weblogic等的应用服务器的时候，就可以在远程客户端通过查找JNDI名称来获得处于另外JVM下的服务器资源，例如连接池数据源。

对于mapping映射属性，这是通知hibernate，让其知道现在已经有一个映射文件来映射数据库中的表，这个文件名是Cours.hbm.xml。

有关hibernate.cfg.xml或者hibernate.properties文件的更多配置信息，请参看前文提到的参考地址。

e)下面让我们看看上节提到的Cours.hbm.xml，同样，这个文件需要

放到defaultroot\classes目录下。该文件的内容如下：

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC

"-//Hibernate/Hibernate Mapping DTD 2.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd" >

<hibernate-mapping>

<class

name="com.hibernate.Cours"

table="Courses"

dynamic-update="false"

<id

name="courseId"

column="CourseId"

type="string"

unsaved-value="any"

</id>

<property

name="name"

type="string"

update="true"

insert="true"

column="Name"

</class>

</hibernate-mapping>

首先让我们来看class节点，该节点描述数据库中的一个表对应我们创建的一个可持久化类（该持久化类类似于JavaBean，通过getter和setter方法访问）。在这里我们可以看到name为com.hibernate.Cours的可持久化类对应于table为Courses的数据库表，dynamic-update属性用来标识是否对update的sql语句在运行时动态生成，并且之更新那些改变过的字段。在这里我们不需要过于关注这个属性。

其次，观察id子节点，该节点表示了表的关键字段，name=”courseId”表明了com.hibernate.Cours类中的对应courses表主关键字的attribute属性是courseId。而对应的字段是column="CourseId"，类型为type="string"

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

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

increment（递增）

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

Identity

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

sequence （序列）

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

hilo （高低位）

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

seqhilo（使用序列的高低位）

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

uuid.hex

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

uuid.string

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

native（本地）

根据底层数据库的能力选择identity, sequence 或者hilo 中的一个。

assigned（程序设置）

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

foreign（外部引用）

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

Hibernate用property节点来描述其他非关键字字段的属性，

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

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

SessionFactory sessionFactory =

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

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

import net.sf.hibernate.*;

import net.sf.hibernate.cfg.*;

public class HibernateUtil {

private static final SessionFactory sessionFactory;

static {

try {

sessionFactory = new

Configuration().configure().buildSessionFactory();

} catch (HibernateException ex) {

throw new RuntimeException("Exception building

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

}

public static final ThreadLocal session = new ThreadLocal();

public static Session currentSession() throws HibernateException

{

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

// Open a new Session, if this Thread has none yet

if (s == null) {

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();

}

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

Session session = HibernateUtil.currentSession();

Transaction tx= session.beginTransaction();

Cours course = new Cours();

course.setCourseId("aaaaaaa");

course.setName(“bbbbbbb”)

session.save(princess);

tx.commit();

HibernateUtil.closeSession();

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

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

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

g)创建访问bean类，来封装调用hibernate访问数据库的方法。在这里我们暂且定义该方法为StoreAccessBean.java。源文件如下：

package com.hibernate;

import net.sf.hibernate.HibernateException;

import net.sf.hibernate.Session;

import net.sf.hibernate.Transaction;

import java.util.Iterator;

import java.util.Hashtable;

import javax.naming.Context;

import javax.naming.InitialContext;

import javax.sql.DataSource;

public class StoreAccessBean{

public StoreAccessBean(){

}

public void addStoreAccess(Cours store){

try {

Session session = HibernateUtil.currentSession();

Transaction trans = session.beginTransaction();

session.save(store);

trans.commit();

HibernateUtil.closeSession();

}

catch (Exception ex) {

ex.printStackTrace();

}

public Iterator getAllCourses()throws HibernateException

{

String queryString = "select storeaccess from storeaccess as storeaccess";

Session session = HibernateUtil.currentSession();

net.sf.hibernate.Query query = session.createQuery(queryString);

Iterator it= query.iterate();

HibernateUtil.closeSession();

return it;

}

该类中有两个方法，一个是添加一条数据的方法，另外一个是查询的方法。

最后，编译所有文件。在刚才新建的jsp中加入以下代码：

com.hibernate.Cours access = new com.hibernate.Cours(); access.setCourseId("aaaaaaa");

access.setName("bbbbbb");

com.hibernate.StoreAccessBean bean = new com.hibernate.StoreAccessBean();

最后，打成war包，部署到%JBOSS_HOME%\server\default\deploy目录中，启动jboss，访问建立的jsp页面，然后看看数据库中是否多了一条记录，这表明例程运行成功。