Let's assume we need a small database application that can store events we want to attend, and information about the host(s) of these events. We will use an in-memory, Java database named HSQLDB to avoid describing installation/setup of any particular database servers. Feel free to tweak this tutorial to use whatever database you feel comfortable using.
The first thing we need to do is set up our development environment, and specifically to setup all the required dependencies
to Hibernate as well as other libraries. Hibernate is built using Maven which amongst other features provides dependecy management
; moreover it provides transitive dependecy management
which simply means that to use Hibernate we can simply define our dependency on Hibernate, Hibernate itself defines the dependencies
it needs which then become transitive dependencies of our project.
. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> ... <dependencies> <dependency> <groupId >${groupId}</groupId> <artifactId >hibernate-core</artifactId> </dependency> <!-- Because this is a web app, we also have a dependency on the servlet api. --> <dependency> <groupId >javax.servlet</groupId> <artifactId >servlet-api</artifactId> </dependency> </dependencies> </project >
Essentially we are describing here the /tutorials/web/pom.xml
file. See the Maven site for more information.
While not strictly necessary, most IDEs have integration with Maven to read these POM files and automatically set up a project for you which can save lots of time and effort.
接下来我们创建一个类,用来代表那些我们希望储存在数据库里的event。
我们的第一个持久化类是一个带有一些属性(property)的简单JavaBean类:
package org.hibernate.tutorial.domain; import java.util.Date; public class Event { private Long id; private String title; private Date date; public Event() {} public Long getId() { return id; } private void setId(Long id) { this.id = id; } public Date getDate() { return date; } public void setDate(Date date) { this.date = date; } public String getTitle() { return title; } public void setTitle(String title) { this.title = title; } }
你可以看到这个类对属性的存取方法(getter and setter method)使用了标准JavaBean命名约定,同时把类属性(field)的访问级别设成私有的(private)。这是推荐的设计,但并不是必须的。Hibernate也可以直接访问这些field,而使用访问方法(accessor method)的好处是提供了重构时的健壮性(robustness)。为了通过反射机制(Reflection)来实例化这个类的对象,我们需要提供一个无参的构造器(no-argument constructor)。
对一特定的event, id
属性持有唯一的标识符(identifier)的值。如果我们希望使用Hibernate提供的所有特性,那么所有的持久化实体(persistent entity)类(这里也包括一些次要依赖类)都需要一个这样的标识符属性。而事实上,大多数应用程序(特别是web应用程序)都需要通过标识符来区别对象,所以你应该考虑使用标识符属性而不是把它当作一种限制。然而,我们通常不会操作对象的标识(identity),因此它的setter方法的访问级别应该声明private。这样当对象被保存的时候,只有Hibernate可以为它分配标识符值。你可看到Hibernate可以直接访问public,private和protected的访问方法和field。所以选择哪种方式完全取决于你,你可以使你的选择与你的应用程序设计相吻合。
所有的持久化类(persistent classes)都要求有无参的构造器,因为Hibernate必须使用Java反射机制来为你创建对象。构造器(constructor)的访问级别可以是private,然而当生成运行时代理(runtime proxy)的时候则要求使用至少是package 级别的访问控制,这样在没有字节码指令(bytecode instrumentation)的情况下,从持久化类里获取数据会更有效率。
把这个Java源代码文件放到开发目录下的src
目录里,注意包位置要正确。 现在这个目录看起来应该像这样:
. +lib <Hibernate and third-party libraries> +src +events Event.java
下一步,我们把这个持久化类的信息告诉Hibernate。
Hibernate需要知道怎样去加载(load)和存储(store)持久化类的对象。这正是Hibernate映射文件发挥作用的地方。映射文件告诉Hibernate它,应该访问数据库(database)里面的哪个表(table)及应该使用表里面的哪些字段(column)。
一个映射文件的基本结构看起来像这样:
<?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <hibernate-mapping> [...] </hibernate-mapping>
注意Hibernate的DTD是非常复杂的。你的编辑器或者IDE里使用它来自动完成那些用来映射的XML元素(element)和属性(attribute)。你也可以在文本编辑器里打开DTD-这是最简单的方式来概览所有的元素和attribute,并查看它们的缺省值以及注释。注意Hibernate不会从web加载DTD文件,但它会首先在应用程序的classpath中查找。DTD文件已包括在hibernate3.jar
里,同时也在Hibernate发布包的src/
目录下。
为缩短代码长度,在以后的例子里我们会省略DTD的声明。当然,在实际的应用程序中,DTD声明是必须的。
在hibernate-mapping
标签(tag)之间, 含有一个class
元素。所有的持久化实体类(再次声明,或许接下来会有依赖类,就是那些次要的实体)都需要一个这样的映射,来把类对象映射到SQL数据库里的表。
<hibernate-mapping> <class name="events.Event" table="EVENTS"> </class> </hibernate-mapping>
到目前为止,我们告诉了Hibernate怎样把Events
类的对象持久化到数据库的EVENTS
表里,以及怎样从EVENTS
表加载到Events
类的对象。每个实例对应着数据库表中的一行。现在我们将继续讨论有关唯一标识符属性到数据库表的映射。另外,由于我们不关心怎样处理这个标识符,我们就配置由Hibernate的标识符生成策略来产生代理主键字段。
<hibernate-mapping> <class name="events.Event" table="EVENTS"> <id name="id" column="EVENT_ID"> <generator class="native"/> </id> </class> </hibernate-mapping>
The id
element is the declaration of the identifier property, name="id"
declares the name of the Java property - Hibernate will use the getter and setter methods to access the property. The column
attribute tells Hibernate which column of the EVENTS
table we use for this primary key. The nested generator
element specifies the identifier generation strategy, in this case we used native
, which picks the best strategy depending on the configured database (dialect). Hibernate supports database generated, globally
unique, as well as application assigned identifiers (or any strategy you have written an extension for).
最后我们在映射文件里面包含需要持久化属性的声明。默认情况下,类里面的属性都被视为非持久化的:
<hibernate-mapping> <class name="events.Event" table="EVENTS"> <id name="id" column="EVENT_ID"> <generator class="native"/> </id> <property name="date" type="timestamp" column="EVENT_DATE"/> <property name="title"/> </class> </hibernate-mapping>
和id
元素一样,property
元素的name
属性告诉Hibernate使用哪个getter和setter方法。在此例中,Hibernate会寻找getDate()/setDate()
, 以及getTitle()/setTitle()
。
为什么date
属性的映射含有column
attribute,而title
却没有?当没有设定column
attribute 的时候,Hibernate缺省地使用JavaBean的属性名作为字段名。对于title
,这样工作得很好。然而,date
在多数的数据库里,是一个保留关键字,所以我们最好把它映射成一个不同的名字。
另一有趣的事情是title
属性缺少一个type
attribute。我们在映射文件里声明并使用的类型,却不是我们期望的那样,是Java数据类型,同时也不是SQL数据库的数据类型。这些类型就是所谓的Hibernate 映射类型(mapping types),它们能把Java数据类型转换到SQL数据类型,反之亦然。再次重申,如果在映射文件中没有设置type
属性的话,Hibernate会自己试着去确定正确的转换类型和它的映射类型。在某些情况下这个自动检测机制(在Java 类上使用反射机制)不会产生你所期待或需要的缺省值。date
属性就是个很好的例子,Hibernate无法知道这个属性(java.util.Date
类型的)应该被映射成:SQL date
,或timestamp
,还是time
字段。在此例中,把这个属性映射成timestamp
转换器,这样我们预留了日期和时间的全部信息。
应该把这个映射文件保存为Event.hbm.xml
,且就在Event
Java类的源文件目录下。映射文件可随意地命名,但hbm.xml
的后缀已成为Hibernate开发者社区的约定。现在目录结构看起来应该像这样:
. +lib <Hibernate and third-party libraries> +src +events Event.java Event.hbm.xml
我们继续进行Hibernate的主要配置。
现在我们已经有了一个持久化类和它的映射文件,该是配置Hibernate的时候了。在此之前,我们需要一个数据库。 HSQL DB是种基于Java 的SQL数据库管理系统(DBMS),可以从HSQL DB的网站上下载。实际上,你只需下载的包中的hsqldb.jar
文件,并把这个文件放在开发文件夹的lib/
目录下即可。
在开发的根目录下创建一个data
目录 - 这是HSQL DB存储数据文件的地方。此时在data目录中运行java -classpath ../lib/hsqldb.jar org.hsqldb.Server
就可启动数据库。你可以在log中看到它的启动,及绑定到TCP/IP套结字,这正是我们的应用程序稍后会连接的地方。如果你希望在本例中运行一个全新的数据库,就在窗口中按下CTRL + C
来关闭HSQL数据库,并删除data/
目录下的所有文件,再重新启动HSQL数据库。
Hibernate是你的应用程序里连接数据库的那层,所以它需要连接用的信息。连接(connection)是通过一个也由我们配置的JDBC连接池(connection pool)来完成的。Hibernate的发布包里包含了许多开源的(open source)连接池,但在我们例子中使用Hibernate内置的连接池。注意,如果你希望使用一个产品级(production-quality)的第三方连接池软件,你必须拷贝所需的库文件到你的classpath下,并使用不同的连接池设置。
为了保存Hibernate的配置,我们可以使用一个简单的hibernate.properties
文件,或者一个稍微复杂的hibernate.cfg.xml
,甚至可以完全使用程序来配置Hibernate。多数用户更喜欢使用XML配置文件:
<?xml version='1.0' encoding='utf-8'?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"> <hibernate-configuration> <session-factory> <!-- Database connection settings --> <property name="connection.driver_class">org.hsqldb.jdbcDriver</property> <property name="connection.url">jdbc:hsqldb:hsql://localhost</property> <property name="connection.username">sa</property> <property name="connection.password"></property> <!-- JDBC connection pool (use the built-in) --> <property name="connection.pool_size">1</property> <!-- SQL dialect --> <property name="dialect">org.hibernate.dialect.HSQLDialect</property> <!-- Enable Hibernate's automatic session context management --> <property name="current_session_context_class">thread</property> <!-- Disable the second-level cache --> <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property> <!-- Echo all executed SQL to stdout --> <property name="show_sql">true</property> <!-- Drop and re-create the database schema on startup --> <property name="hbm2ddl.auto">create</property> <mapping resource="events/Event.hbm.xml"/> </session-factory> </hibernate-configuration>
注意这个XML配置使用了一个不同的DTD。在这里,我们配置了Hibernate的SessionFactory
-一个关联于特定数据库全局的工厂(factory)。如果你要使用多个数据库,就要用多个的<session-factory>
,通常把它们放在多个配置文件中(为了更容易启动)。
最开始的4个property
元素包含必要的JDBC连接信息。方言(dialect)的property
元素指明Hibernate 生成的特定SQL变量。你很快会看到,Hibernate对持久化上下文的自动session管理就会派上用场。 打开hbm2ddl.auto
选项将自动生成数据库模式(schema)- 直接加入数据库中。当然这个选项也可以被关闭(通过去除这个配置选项)或者通过Ant任务SchemaExport
的帮助来把数据库schema重定向到文件中。最后,在配置中为持久化类加入映射文件。
把这个文件拷贝到源代码目录下面,这样它就位于classpath的根目录的最后。Hibernate在启动时会自动在classpath的根目录查找名为hibernate.cfg.xml
的配置文件。
现在我们用Ant来构建应用程序。你必须先安装Ant-可以从Ant 下载页面得到它。怎样安装Ant就不在这里介绍了,请参考Ant 用户手册。当你安装完了Ant,就可以开始创建build.xml
文件,把它直接放在开发目录下面。
一个简单的build文件看起来像这样:
<project name="hibernate-tutorial" default="compile"> <property name="sourcedir" value="${basedir}/src"/> <property name="targetdir" value="${basedir}/bin"/> <property name="librarydir" value="${basedir}/lib"/> <path id="libraries"> <fileset dir="${librarydir}"> <include name="*.jar"/> </fileset> </path> <target name="clean"> <delete dir="${targetdir}"/> <mkdir dir="${targetdir}"/> </target> <target name="compile" depends="clean, copy-resources"> <javac srcdir="${sourcedir}" destdir="${targetdir}" classpathref="libraries"/> </target> <target name="copy-resources"> <copy todir="${targetdir}"> <fileset dir="${sourcedir}"> <exclude name="**/*.java"/> </fileset> </copy> </target> </project>
这将告诉Ant把所有在lib目录下以.jar
结尾的文件拷贝到classpath中以供编译之用。它也把所有的非Java源代码文件,例如配置和Hibernate映射文件,拷贝到目标目录。如果你现在运行Ant,会得到以下输出:
C:\hibernateTutorial\>ant Buildfile: build.xml copy-resources: [copy] Copying 2 files to C:\hibernateTutorial\bin compile: [javac] Compiling 1 source file to C:\hibernateTutorial\bin BUILD SUCCESSFUL Total time: 1 second
是时候来加载和储存一些Event
对象了,但首先我们得编写一些基础的代码以完成设置。我们必须启动Hibernate,此过程包括创建一个全局的SessoinFactory
,并把它储存在应用程序代码容易访问的地方。SessionFactory
可以创建并打开新的Session
。一个Session
代表一个单线程的单元操作,SessionFactory
则是个线程安全的全局对象,只需要被实例化一次。
我们将创建一个HibernateUtil
辅助类(helper class)来负责启动Hibernate和更方便地操作SessionFactory
。让我们来看一下它的实现:
package util; import org.hibernate.*; import org.hibernate.cfg.*; public class HibernateUtil { private static final SessionFactory sessionFactory; static { try { // Create the SessionFactory from hibernate.cfg.xml sessionFactory = new Configuration().configure().buildSessionFactory(); } catch (Throwable ex) { // Make sure you log the exception, as it might be swallowed System.err.println("Initial SessionFactory creation failed." + ex); throw new ExceptionInInitializerError(ex); } } public static SessionFactory getSessionFactory() { return sessionFactory; } }
这个类不但在它的静态初始化过程(仅当加载这个类的时候被JVM执行一次)中产生全局的SessionFactory
,而且隐藏了它使用了静态singleton的事实。它也可能在应用程序服务器中的JNDI查找SessionFactory
。
如果你在配置文件中给SessionFactory
一个名字,在SessionFactory
创建后,Hibernate会试着把它绑定到JNDI。要完全避免这样的代码,你也可以使用JMX部署,让具有JMX能力的容器来实例化HibernateService
并把它绑定到JNDI。这些高级可选项在后面的章节中会讨论到。
把HibernateUtil.java
放在开发目录的源代码路径下,与放events
的包并列:
. +lib <Hibernate and third-party libraries> +src +events Event.java Event.hbm.xml +util HibernateUtil.java hibernate.cfg.xml +data build.xml
再次编译这个应用程序应该不会有问题。最后我们需要配置一个日志(logging)系统 - Hibernate使用通用日志接口,允许你在Log4j和JDK 1.4 日志之间进行选择。多数开发者更喜欢Log4j:从Hibernate的发布包中(它在etc/
目录下)拷贝log4j.properties
到你的src
目录,与hibernate.cfg.xml
.放在一起。看一下配置示例,如果你希望看到更加详细的输出信息,你可以修改配置。默认情况下,只有Hibernate的启动信息才会显示在标准输出上。
示例的基本框架完成了 - 现在我们可以用Hibernate来做些真正的工作。
我们终于可以使用Hibernate来加载和存储对象了,编写一个带有main()
方法的EventManager
类:
package events; import org.hibernate.Session; import java.util.Date; import util.HibernateUtil; public class EventManager { public static void main(String[] args) { EventManager mgr = new EventManager(); if (args[0].equals("store")) { mgr.createAndStoreEvent("My Event", new Date()); } HibernateUtil.getSessionFactory().close(); } private void createAndStoreEvent(String title, Date theDate) { Session session = HibernateUtil.getSessionFactory().getCurrentSession(); session.beginTransaction(); Event theEvent = new Event(); theEvent.setTitle(title); theEvent.setDate(theDate); session.save(theEvent); session.getTransaction().commit(); } }
我们创建了个新的Event
对象并把它传递给Hibernate。现在Hibernate负责与SQL打交道,并把INSERT
命令传给数据库。在运行之前,让我们看一下处理Session
和Transaction
的代码。
一个Session
就是个单一的工作单元。我们暂时让事情简单一些,并假设HibernateSession
和数据库事务是一一对应的。为了让我们的代码从底层的事务系统中脱离出来(此例中是JDBC,但也可能是JTA),我们使用Hibernate Session
中的Transaction
API。
sessionFactory.getCurrentSession()
是干什么的呢?首先,只要你持有SessionFactory
(幸亏我们有HibernateUtil
,可以随时获得),大可在任何时候、任何地点调用这个方法。getCurrentSession()
方法总会返回“当前的”工作单元。记得我们在hibernate.cfg.xml
中把这一配置选项调整为"thread"了吗?因此,因此,当前工作单元被绑定到当前执行我们应用程序的Java线程。但是,这并非是完全准确的,你还得考虑工作单元的生命周期范围 (scope),它何时开始,又何时结束.
Session
在第一次被使用的时候,即第一次调用getCurrentSession()
的时候,其生命周期就开始。然后它被Hibernate绑定到当前线程。当事务结束的时候,不管是提交还是回滚,Hibernate会自动把Session
从当前线程剥离,并且关闭它。假若你再次调用getCurrentSession()
,你会得到一个新的Session
,并且开始一个新的工作单元。这种线程绑定(thread-bound)的编程模型(model)是使用Hibernate的最广泛的方式,因为它支持对你的代码灵活分层(事务划分可以和你的数据访问代码分离开来,在本教程的后面部分就会这么做)。
和工作单元的生命周期这个话题相关,Hibernate Session
是否被应该用来执行多次数据库操作?上面的例子对每一次操作使用了一个Session
,这完全是巧合,这个例子不是很复杂,无法展示其他方式。Hibernate Session
的生命周期可以很灵活,但是你绝不要把你的应用程序设计成为每一次数据库操作都用一个新的Hibernate Session
。因此就算下面的例子(它们都很简单)中你可以看到这种用法,记住每次操作一个session是一个反模式。在本教程的后面会展示一个真正的(web)程序。
关于事务处理及事务边界界定的详细信息,请参看第 11 章 事务和并发。在上面的例子中,我们也忽略了所有的错误与回滚的处理。
为第一次运行我们的程序,我们得在Ant的build文件中增加一个可以调用得到的target。
<target name="run" depends="compile"> <java fork="true" classname="events.EventManager" classpathref="libraries"> <classpath path="${targetdir}"/> <arg value="${action}"/> </java> </target>
action
参数(argument)的值是通过命令行调用这个target的时候设置的:
C:\hibernateTutorial\>ant run -Daction=store
你应该会看到,编译以后,Hibernate根据你的配置启动,并产生一大堆的输出日志。在日志最后你会看到下面这行:
[java] Hibernate: insert into EVENTS (EVENT_DATE, title, EVENT_ID) values (?, ?, ?)
这是Hibernate执行的INSERT
命令,问号代表JDBC的绑定参数。如果想要看到绑定参数的值或者减少日志的长度,就要调整你在log4j.properties
文件里的设置。
我们想要列出所有已经被存储的events,就要增加一个条件分支选项到main方法中去。
if (args[0].equals("store")) { mgr.createAndStoreEvent("My Event", new Date()); } else if (args[0].equals("list")) { List events = mgr.listEvents(); for (int i = 0; i < events.size(); i++) { Event theEvent = (Event) events.get(i); System.out.println("Event: " + theEvent.getTitle() + " Time: " + theEvent.getDate()); } }
我们也增加一个新的listEvents()
方法:
private List listEvents() { Session session = HibernateUtil.getSessionFactory().getCurrentSession(); session.beginTransaction(); List result = session.createQuery("from Event").list(); session.getTransaction().commit(); return result; }
我们在这里是用一个HQL(Hibernate Query Language-Hibernate查询语言)查询语句来从数据库中加载所有存在的Event
对象。Hibernate会生成适当的SQL,把它发送到数据库,并操作从查询得到数据的Event
对象。当然,你可以使用HQL来创建更加复杂的查询。
现在,根据以下步骤来执行并测试以上各项:
运行ant run -Daction=store
来保存一些内容到数据库。当然,先得用hbm2ddl来生成数据库schema。
Now disable hbm2ddl by commenting out the property in your hibernate.cfg.xml
file. Usually you only leave it turned on in continuous unit testing, but another run of hbm2ddl would drop everything you have stored - the create
configuration setting actually translates into "drop all tables from the schema, then re-create all tables, when the SessionFactory
is build".
如果你现在使用命令行参数-Daction=list
运行Ant,你会看到那些至今为止我们所储存的events。当然,你也可以多调用几次store
以保存更多的envents。
注意,很多Hibernate新手在这一步会失败,我们不时看到关于Table not found错误信息的提问。但是,只要你根据上面描述的步骤来执行,就不会有这个问题,因为hbm2ddl会在第一次运行的时候创建数据库schema,后继的应用程序重起后还能继续使用这个schema。假若你修改了映射,或者修改了数据库schema,你必须把hbm2ddl重新打开一次。