二、持久层的组成
这一节的名字应该换成“基于Hibernate的持久层的组成”更合适一点,可是它太长了。既然Hibernate是用来开发持久层,那么我先介绍一下这个持久层中的各个元素。
1. POJO:Plain Old Java Object,你可以把它看作是简单的JavaBean。一般说来,一张数据库表对应一个POJO,也就是对象/关系的一一映射。
2. DAO:对于每一个POJO,一般都有一个DAO与之对应,承担所有关于该POJO的访问控制。实际上也就是控制了对数据库中一张表的访问控制。
3. *.hbm.xml文件:这个文件定义了POJO和数据库中的表是如何映射的,比如POJO中的字段对应数据库表中的哪个字段等等。一般每个映射都用单独的文件来描述,也就是有一个POJO就有一个*.hbm.xml文件。
4. *.cfg.xml文件:这个文件定义了Hibernate的基本信息,比如数据库驱动,用户名,密码等等连接信息,也包括了所有要用的*.hbm.xml文件,在初始化的时候,Hibernate会读取这个文件来找相应的映射文件完成对象/关系。
我们还是以上文的例子来详细描述一下这里提到的各个元素的内容。
1. Student.java:
你可以看到save和delete方法都很简单直接对对象操作,而findById就有些麻烦,因为这里有一个查询过程在里面。Hibernate里面查询可以用Criteria这个类来完成,我们也常用Hibernate独有的HQL(Hibernate Query Language)来完成查询。当然Hibernate也是支持原生SQL的。关于查询的详细信息请参考其他文章或书籍,我只是演示一个流程,介绍一些概念。
有一个比较特别的标签是set,它对应着数据库中的外键关系,上文我提到的通过Student对象可以获得所有相关的选课记录就是通过这里的定义实现的。name属性对应了Student类中的字段名,key表示哪个字段是外键,one-to-many表示Student和CourseSelection是一对多关系,这和事实相符。类似的还有many-to-one,many-to-many,不过这些都不常用,我不介绍了。Hibernate根据这个映射定义文件,在实例化一个POJO(比如Student)的时候,会自动的把定义过映射的属性用数据库中的数据填充,set也包括在内。
我们通过Configuration来读取配置文件,然后就可以创建SessionFactory,这段代码在所有系统中都大同小异,一般就是xml配置文件的名字不一样,所以也没什么好说的。
当我们有了SessionFactory以后就可以获取Session了。调用SessionFactory.openSession()就会返回一个Session实例,然后我们操作这个Session来访问数据库。值得一提的是Session并不是线程安全的,也就是每一个线程都必须有自己的Session。所以我们一般通过以下方法来获取和关闭Session:
好了,现在我们已经获得了Session,下面我来介绍以下Session的常用函数,这些函数都有很多重载函数,我只介绍以下大概是干嘛的,不一一解释,详细信息你可以查看Hibernate的API。
1.Session.get(),获取某个类的实例,一般都是通过id来获取比如
Session.get(Student.class, "0361095");
这句话的意思就是获取id(primary key)为“0361095”的Student对象。这里要注意的是第二个参数必须是Object,也就是说,如果是long类型的1,那么必须转换成new Long(1)再传入。
2.Session.load(),用法和意义都和get一样,不过它们还是有点区别,我稍后解释。
3.Session.save(),将某个实例保存到数据库中去(往往在数据库中形成一条新的记录)。
4.Session.update(),更新某个实例,这个实例必须和数据库中有对应,否则会报错。
5.Session.delete(),删除某个实例,也就是删除这个实例对应的数据表中的数据。
6.Session.saveOrUpdate(),保存或者更新某个实例,调用这个方法你就不用去关心到底是save还是update了,它会自己判断,然后调用相应的函数。其实save和update 涉及到实体对象生命周期中的三种状态,这个比较重要,我在后面会单独讲的。
对于get和load的区别,很难讲清楚,这里涉及到Hibernate的缓存机制,是一个非常 复杂的话题,我不打算深入讨论这个内容。简单的来讲,Session实现了Hibernate的一级缓存,SessionFactory实现了Hibernate的二级缓存。load方法会先查找一级缓存再查找二级缓存,最后再去数据库中找,而get只会查找一级缓存,然后就去数据库中找了。 这只是是get和load的一个区别,另外的区别如果你有兴趣的话自己去google吧。关于Hibernate的缓存机制,如果你只是一般用用Hibernate的话没有必要深入研究,就当它不存在好了,get和load到底用哪个也不用非常讲究,如果你用工具生成DAO的话,生成的代码用什么就用什么吧。
四、关键概念的理解
在使用Hibernate进行开发的时候有几个概念在我看来是必须理解的,否则在开发的时候会遇到很多问题而摸不着头脑。
1.Lazy loading,懒加载(延迟加载)
这个技术在很多地方被应用,比如Eclipse的插件管理也是用的延迟加载。在Hibernate中,所谓延迟加载就是返回一个POJO但是某些数据(往往是实体类型或者Set类型)并没有被真正的被填充,直到POJO的某个字段真正被引用的时候才从数据库中读取相应的数据来填充POJO中的字段。这样就能有效的避免很多不必要的数据库操作,因为POJO的有些数据我们并不需要,而且数据库操作是很费时间的。在Hibernate2中,默认是非延迟加载的,而在Hibernate3中,默认就是延迟加载了。
如果使用了延迟加载,那么在读取数据的时候有一个问题必须注意,那就是在数据真正被加载之前,Session不能被关闭。你可以回头看一下代码片段5,我在构造函数里面open了session以后就没有关闭这个session,所以我在使用的时候没有什么问题,但这样总占着数据库连接也不好,用好了应该及时关闭给别人用。我上文给的例子中没有关闭Session的代码,要加的话给DAO加一个方法调用Session.close(),然后在代码片段1中的return之前调用这个方法就行了。
Hibernate的延迟加载机制远不是这么简单,但是普通的应用没有必要去深究这些东西,了解这么多就够了。
2. Object lifecycle,对象生命周期
在Hibernate中,对象分为三种状态,Transient(自由状态)、Persistent(持久状态),Detached(游离状态),下面我分别解释一下。
1、自由状态:所谓自由状态就是说这个对象是自由的,与Hibernate无关,比如:
Student student = new Student();
student.setId("0361095");
这里的student就是一个普通的对象与hibernate无关,称为自由状态。
2、持久状态:所谓持久状态就是指对象和数据库中的数据(持久状态的数据)有关联,也就是说对象被Hibernate所管理了,比如:
session.save(student);
这样student对象就从自由状态变为持久状态了。持久状态的对象在Session 与数据库中的数据进行同步时(比如commit)会把数据更新到数据库。而其他状态的则不会。我觉得可以这样来理解持久状态,可以看成Hibernate 也拥有一份对象的引用,那么如果你对持久状态对象的属性进行更改的话, Hibernate看到的对象的状态也更改了,而Hibernate所看到的对象和数据 库中的数据是等价的。也正是这样,Hibernate才实现了Object/Relation 的映射。类似的,load和get方法也一样会获取Persistent状态的对象。
3、游离状态:每次调用Session.close以后,所有跟这个session有关的处于
Persistant的对象就变成了游离状态。也许你要问Detached和Transient有什么区别。其实从我给的例子来说看不出什么区别,因为我这里ID是给定的,而真正开发的时候ID往往是自增的,那么Transient的对象是没有ID 的,当save了以后就有了,显而易见Detached的对象也是有ID,只不过这个对象已经和Hibernate脱离了关系。但是游离状态的对象仍然和数据库中的记录有一定联系,至少游离状态的对象知道数据库中有条记录的ID为xxx。从这一点上来讲,游离状态是可以自己创造出来的,只要你知道数据库中的主键信息。
在使用Hibernate开发的时候要分清楚这三种状态,否则很容易出错。比如不能去save一个游离状态的对象,不能去update一个自由状态的对象等等。
五、结束语
我要讲的就这么多,这篇文章不是详细介绍Hibernate,我只是总结了自己学习和使用Hibernate的一些感受和经验,希望能给没有用过Hibernate的开发者一个上手的指引。如果你看完了这篇文章仍然满头雾水,无从下手的话,我只能向你表示歉意,浪费你的时间了。不管怎样,我强烈推荐一本书《深入浅出Hibernate》,这本书既能作为学习的教程,也能作为日后的查询用书,相当实用。
这一节的名字应该换成“基于Hibernate的持久层的组成”更合适一点,可是它太长了。既然Hibernate是用来开发持久层,那么我先介绍一下这个持久层中的各个元素。
1. POJO:Plain Old Java Object,你可以把它看作是简单的JavaBean。一般说来,一张数据库表对应一个POJO,也就是对象/关系的一一映射。
2. DAO:对于每一个POJO,一般都有一个DAO与之对应,承担所有关于该POJO的访问控制。实际上也就是控制了对数据库中一张表的访问控制。
3. *.hbm.xml文件:这个文件定义了POJO和数据库中的表是如何映射的,比如POJO中的字段对应数据库表中的哪个字段等等。一般每个映射都用单独的文件来描述,也就是有一个POJO就有一个*.hbm.xml文件。
4. *.cfg.xml文件:这个文件定义了Hibernate的基本信息,比如数据库驱动,用户名,密码等等连接信息,也包括了所有要用的*.hbm.xml文件,在初始化的时候,Hibernate会读取这个文件来找相应的映射文件完成对象/关系。
我们还是以上文的例子来详细描述一下这里提到的各个元素的内容。
1. Student.java:
代码片段4:
public class Student implements java.io.Serializable
{
private String id;
private String name;
private Set courseSelections = new HashSet(0);
public Student()
{
}
public String getId()
{
return this.id;
}
public void setId(String id)
{
this.id = id;
}
public String getName()
{
return this.name;
}
public void setName(String name)
{
this.name = name;
}
public Set getCourseSelections()
{
return this.courseSelections;
}
public void setCourseSelections(Set courseSelections)
{
this.courseSelections = courseSelections;
}
}
这个类就是一个POJO,你可以很明显的看出来它就是一个JavaBean。我想解释它的courseSelection字段。很显然,在数据库表student中,没有这个字段。这里的这个字段是因为一个外键引用,course_selection的student_id是一个外键,引用了student表中的id字段。那么在Student类中courseSelection来记录这样的外键关系,也就是说,当我们获取了Student对象以后,就可以直接获取他的选课记录,这样就为上层的调用提供了很大的方便。这里有点模糊没关系,我在介绍映射定义文件(*.hbm.xml)的时候还会提到这个问题。
2. StudentDAO.java
代码片段5:
public class StudentDAO
{
Session session;
public StudentDAO()
{
Configuration cfg = new Configuration();
cfg.configure("/hibernate.cfg.xml");
SessionFactory sessionFactory = cfg.buildSessionFactory();
session = sessionFactory.openSession();
}
public void save(Student transientInstance)
{
session.save(transientInstance);
}
public void delete(Student persistentInstance)
{
session.delete(persistentInstance);
}
public Student findById(java.lang.String id)
{
List list = session.createCriteria(Student.class).add(
Expression.eq("id", id)).list();
if (list.size() > 0)
{
return (Student)list.get(0);
}
return null;
}
}
这里的构造函数是用来启动Hibernate,并获取session。打开一个session就相当于打开了一个数据库连接,然后我们就可以对这个session进行操作,完成数据库操作,完全不用写SQL语句。我这里Hibernate的启动方式写的很不规范,系统应该只需要完成一次Hibernate启动就可以在不同的DAO中使用,我把它写在构造函数里面纯粹是为了简化演示代码。
你可以看到save和delete方法都很简单直接对对象操作,而findById就有些麻烦,因为这里有一个查询过程在里面。Hibernate里面查询可以用Criteria这个类来完成,我们也常用Hibernate独有的HQL(Hibernate Query Language)来完成查询。当然Hibernate也是支持原生SQL的。关于查询的详细信息请参考其他文章或书籍,我只是演示一个流程,介绍一些概念。
3. Student.hbm.xml
代码片段6:
<hibernate-mapping>
<class name="Student" table="STUDENT">
<id name="id" type="string">
<column name="ID" length="10" />
<generator class="assigned" />
</id>
<property name="name" type="string">
<column name="NAME" not-null="true" />
</property>
<set name="courseSelections" inverse="true">
<key>
<column name="STUDENT_ID" length="10"
not-null="true" />
</key>
<one-to-many class="CourseSelection" />
</set>
</class>
</hibernate-mapping>
这个文件定义了Student类和Student表是如何映射的。class元素定义了Sudent类和STUDENT表映射,然后就定义了各个属性是如何映射的。如果一个属性是数据库的key,那么会用id标签来定义,column定义了当前类的属性和数据库中的哪个字段对应,generator是id特有的。一般来说id是自增的,由于我的数据库是用的Oracle,它没有自增字段,要实现自增必须用Sequence,这超出了本文的范围,所以我就用assigned来简化示例代码。assigned表示id是用户给定的。
有一个比较特别的标签是set,它对应着数据库中的外键关系,上文我提到的通过Student对象可以获得所有相关的选课记录就是通过这里的定义实现的。name属性对应了Student类中的字段名,key表示哪个字段是外键,one-to-many表示Student和CourseSelection是一对多关系,这和事实相符。类似的还有many-to-one,many-to-many,不过这些都不常用,我不介绍了。Hibernate根据这个映射定义文件,在实例化一个POJO(比如Student)的时候,会自动的把定义过映射的属性用数据库中的数据填充,set也包括在内。
4. hibernate.cfg.xml
代码片段7:
<hibernate-configuration>
<session-factory>
<property name="connection.username">test</property>
<property name="connection.url">
jdbc:oracle:thin:@10.85.33.199:1521:glee</property>
<property name="dialect">
org.hibernate.dialect.Oracle9Dialect</property>
<property name="connection.password">test</property>
<property name="connection.driver_class">
oracle.jdbc.OracleDriver</property>
<mapping resource="Student.hbm.xml"></mapping>
<mapping resource="CourseSelection.hbm.xml"></mapping>
<mapping resource="Course.hbm.xml"></mapping>
</session-factory>
</hibernate-configuration>
到这里为止,使用Hibernate进行开发的基本组成元素我都介绍好了,强烈建议你马上实践一遍,即使有些不理解,也先依葫芦画瓢一个。对了,别忘了把Hibernate的包down下来放到classpath里面。
三、Session与SessionFactory
Session可以说是Hibernate的核心,Hibernate对外暴露的接口就是Session。所以我这里讲一下有关Session的常用函数和特性。
在讲Session之前,我想先提一下SessionFactory,这个东西不复杂,只要配置好就行了。顾名思义,SessionFactory就是用来创建Session的。SessionFactory是线程安全的,也就是说对于同一个数据库的所有操作共享一个SessionFactory就行了。回头看代码片段5,我们可以看到SessionFactory的常用配置方式。
代码片段8:
Configuration cfg = new Configuration();
cfg.configure("/hibernate.cfg.xml");
SessionFactory sessionFactory = cfg.buildSessionFactory();
我们通过Configuration来读取配置文件,然后就可以创建SessionFactory,这段代码在所有系统中都大同小异,一般就是xml配置文件的名字不一样,所以也没什么好说的。
当我们有了SessionFactory以后就可以获取Session了。调用SessionFactory.openSession()就会返回一个Session实例,然后我们操作这个Session来访问数据库。值得一提的是Session并不是线程安全的,也就是每一个线程都必须有自己的Session。所以我们一般通过以下方法来获取和关闭Session:
public static Session currentSession() throws HibernateException
{
Session session = (Session) threadLocal.get();
if (session == null || !session.isOpen())
{
if (sessionFactory == null)
{
try
{
cfg.configure(CONFIG_FILE_LOCATION);
sessionFactory = cfg.buildSessionFactory();
}
catch (Exception e)
{
e.printStackTrace();
}
}
session = (sessionFactory != null) ?
sessionFactory.openSession(): null;
threadLocal.set(session);
}
return session;
}
public static void closeSession() throws HibernateException
{
Session session = (Session) threadLocal.get();
threadLocal.set(null);
if (session != null)
{
session.close();
}
}
可以看到,我们通过threadLocal来保存每个线程的session,这样就保证了各个线程之 间的互不干扰,也保证了系统只有一个SessionFactory实例(对于大多数应用来说已经 足够了)。如果你使用MyEclipse进行开发的话,它会自动生成一个 HibernateSessionFactory.java,其中就包含了以上代码。
好了,现在我们已经获得了Session,下面我来介绍以下Session的常用函数,这些函数都有很多重载函数,我只介绍以下大概是干嘛的,不一一解释,详细信息你可以查看Hibernate的API。
1.Session.get(),获取某个类的实例,一般都是通过id来获取比如
Session.get(Student.class, "0361095");
这句话的意思就是获取id(primary key)为“0361095”的Student对象。这里要注意的是第二个参数必须是Object,也就是说,如果是long类型的1,那么必须转换成new Long(1)再传入。
2.Session.load(),用法和意义都和get一样,不过它们还是有点区别,我稍后解释。
3.Session.save(),将某个实例保存到数据库中去(往往在数据库中形成一条新的记录)。
4.Session.update(),更新某个实例,这个实例必须和数据库中有对应,否则会报错。
5.Session.delete(),删除某个实例,也就是删除这个实例对应的数据表中的数据。
6.Session.saveOrUpdate(),保存或者更新某个实例,调用这个方法你就不用去关心到底是save还是update了,它会自己判断,然后调用相应的函数。其实save和update 涉及到实体对象生命周期中的三种状态,这个比较重要,我在后面会单独讲的。
对于get和load的区别,很难讲清楚,这里涉及到Hibernate的缓存机制,是一个非常 复杂的话题,我不打算深入讨论这个内容。简单的来讲,Session实现了Hibernate的一级缓存,SessionFactory实现了Hibernate的二级缓存。load方法会先查找一级缓存再查找二级缓存,最后再去数据库中找,而get只会查找一级缓存,然后就去数据库中找了。 这只是是get和load的一个区别,另外的区别如果你有兴趣的话自己去google吧。关于Hibernate的缓存机制,如果你只是一般用用Hibernate的话没有必要深入研究,就当它不存在好了,get和load到底用哪个也不用非常讲究,如果你用工具生成DAO的话,生成的代码用什么就用什么吧。
四、关键概念的理解
在使用Hibernate进行开发的时候有几个概念在我看来是必须理解的,否则在开发的时候会遇到很多问题而摸不着头脑。
1.Lazy loading,懒加载(延迟加载)
这个技术在很多地方被应用,比如Eclipse的插件管理也是用的延迟加载。在Hibernate中,所谓延迟加载就是返回一个POJO但是某些数据(往往是实体类型或者Set类型)并没有被真正的被填充,直到POJO的某个字段真正被引用的时候才从数据库中读取相应的数据来填充POJO中的字段。这样就能有效的避免很多不必要的数据库操作,因为POJO的有些数据我们并不需要,而且数据库操作是很费时间的。在Hibernate2中,默认是非延迟加载的,而在Hibernate3中,默认就是延迟加载了。
如果使用了延迟加载,那么在读取数据的时候有一个问题必须注意,那就是在数据真正被加载之前,Session不能被关闭。你可以回头看一下代码片段5,我在构造函数里面open了session以后就没有关闭这个session,所以我在使用的时候没有什么问题,但这样总占着数据库连接也不好,用好了应该及时关闭给别人用。我上文给的例子中没有关闭Session的代码,要加的话给DAO加一个方法调用Session.close(),然后在代码片段1中的return之前调用这个方法就行了。
Hibernate的延迟加载机制远不是这么简单,但是普通的应用没有必要去深究这些东西,了解这么多就够了。
2. Object lifecycle,对象生命周期
在Hibernate中,对象分为三种状态,Transient(自由状态)、Persistent(持久状态),Detached(游离状态),下面我分别解释一下。
1、自由状态:所谓自由状态就是说这个对象是自由的,与Hibernate无关,比如:
Student student = new Student();
student.setId("0361095");
这里的student就是一个普通的对象与hibernate无关,称为自由状态。
2、持久状态:所谓持久状态就是指对象和数据库中的数据(持久状态的数据)有关联,也就是说对象被Hibernate所管理了,比如:
session.save(student);
这样student对象就从自由状态变为持久状态了。持久状态的对象在Session 与数据库中的数据进行同步时(比如commit)会把数据更新到数据库。而其他状态的则不会。我觉得可以这样来理解持久状态,可以看成Hibernate 也拥有一份对象的引用,那么如果你对持久状态对象的属性进行更改的话, Hibernate看到的对象的状态也更改了,而Hibernate所看到的对象和数据 库中的数据是等价的。也正是这样,Hibernate才实现了Object/Relation 的映射。类似的,load和get方法也一样会获取Persistent状态的对象。
3、游离状态:每次调用Session.close以后,所有跟这个session有关的处于
Persistant的对象就变成了游离状态。也许你要问Detached和Transient有什么区别。其实从我给的例子来说看不出什么区别,因为我这里ID是给定的,而真正开发的时候ID往往是自增的,那么Transient的对象是没有ID 的,当save了以后就有了,显而易见Detached的对象也是有ID,只不过这个对象已经和Hibernate脱离了关系。但是游离状态的对象仍然和数据库中的记录有一定联系,至少游离状态的对象知道数据库中有条记录的ID为xxx。从这一点上来讲,游离状态是可以自己创造出来的,只要你知道数据库中的主键信息。
在使用Hibernate开发的时候要分清楚这三种状态,否则很容易出错。比如不能去save一个游离状态的对象,不能去update一个自由状态的对象等等。
五、结束语
我要讲的就这么多,这篇文章不是详细介绍Hibernate,我只是总结了自己学习和使用Hibernate的一些感受和经验,希望能给没有用过Hibernate的开发者一个上手的指引。如果你看完了这篇文章仍然满头雾水,无从下手的话,我只能向你表示歉意,浪费你的时间了。不管怎样,我强烈推荐一本书《深入浅出Hibernate》,这本书既能作为学习的教程,也能作为日后的查询用书,相当实用。