hibernate3入门
Hibernate入门
++YONG原创，转载请声明
1. 应用程序的分层体系结构：
1.1. 典型的三层结构：
1.1.1. 表示层：提供数据输入、检验与数据呈现的应用程序组件。(GUI、web页面)。就是与用户打交道的UI界面。
1.1.2. 业务层：提供商业逻辑服务的应用程序组件。
1.1.3. 数据层：负责存放和管理应用的持久性业务数据的持久化存储系统。(Database、XML)，最常见的持久化存储系统就是广泛使用的关系数据库。
1.2. 软件层的特征：
1.2.1. 每个层由一组相关的类或组件构成，共同完成特定的功能。
1.2.2. 层与层之间存在自上而下的依赖关系。即上层组件会访问下层组件的API，而下层组件不应该依赖上层组件。如：表现层依赖于业务逻辑层，而业务逻辑层依赖于数据层。
1.2.3. 每个层对上层公开API，封装实现细节。当某一层的实现发生改变，只要它的API不变，不会影响其他层的实现。
1.3. 软件分层的优点：
1.3.1. 伸缩性强：能支持更多的用户。
1.3.2. 可维护性高：修改软件的某一层的实现，不会影响其他层。
1.3.3. 可扩展性强：增加新功能更容易，每个层中都有扩展点，不会打破应用的整体框架。
1.3.4. 可重用性高：同一程序能满足多种需求。
1.3.5. 可管理性高：工作、管理模块化。
1.4. 四层结构：
由于数据存储方式多样，业务层不仅要负责业务逻辑的处理，还要跟数据层交互，提供对业务数据的CRUD操作(create、retrieve、update、delete)。为了把业务数据访问细节和业务逻辑分开，把业务数据访问作为单独的持久层。因此目前流行的软件分层结构是：
1. 表示层：
2. 业务层：业务逻辑层负责完成应用程序的逻辑功能，包括
调用持久层完成实体对象的存取、安全检查，事务控制等。抽象出业务逻辑层的好处是将应用程序的逻辑功能从表示层中剥离，这样就能复用逻辑层的功能。此外，业务逻辑层也可以看作是对持久层的一个门面模式，简化表示层对这些逻辑功能的调用。
3. 持久层：封装了业务数据访问细节，为业务层提供了面向对象的API。
持久层负责实现所有的数据访问功能，它将上层传入的数据写入到持久化存储系统中，并根据上层的要求读取或修改现有的数据。
4. 数据层：
1.5. 完善的持久层应该达到以下目标：
l 代码可重用性高，能够完成所有的数据访问操作。
l 具有相对独立性，当持久层的实现细节发生变化，不会影响上层的实现。
2. ORM简介：
1. ORM(Object-Relation Mapping)对象－关系映射模式指的是在单个组件中负责所有实体域对象的持久化，封装数据访问的细节。
2. Hibernate就是一个开源的ORM中间件。(官方网站： http://www.hibernate.org/)
3. Hibernate简介：
2001年未 Hibernate 第一个版本发表，2003年6月8日 Hibernate 2 发表，并于年未获得 Jolt 2004 大奖，后被 JBOSS 收纳而成为其子项目之一，2005年3月 Hibernate 3 正式发表，当中有了一些重大的改变，本文使用的版本为Hibernate 3.2。
4. 配置 hibernate：
4.1. 准备好所需的jar包：
到官方网站： http://www.hibernate.org/6.html 下载(当前版本：Hibernate Core 3.2.3GA ) hibernate包。解开压缩包。在lib目录下找到以下hibernate应用所必须的包(可以查看该目录下的_README.txt文件来确定哪些包是必需的)：
1. hibernate.jar ：hibernate核心包。必需的。
2. antlr.jar ：Hibernate使用ANTLR来产生查询分析器，这个类库在运行环境下时也是必需的。
3. cglib.jar ：CGLIB库，Hibernate用它来实现PO字节码的动态生成，非常核心的库，必需的jar包。
4. asm.jar ：ASM字节码库，cglib.jar包依赖的包。必需的jar包。
5. asm-attrs.jar ：ASM字节码库，cglib.jar包依赖的包。必需的jar包。
6. commons-collections.jar ：Apache Commons包中的一个，包含了一些Apache开发的集合类，功能比java.util.*强大。必须使用的jar包。
7. commons-logging.jar ：Apache Commons包中的一个，包含了日志功能，必须使用的jar包。这个包本身包含了一个Simple Logger，但是功能很弱。在运行的时候它会先在CLASSPATH找log4j，如果有，就使用log4j，如果没有，就找JDK1.4带的java.util.logging，如果也找不到就用Simple Logger。必需的。
8. ehcache.jar ：Hibernate可以使用不同cache缓存工具作为二级缓存。EHCache是缺省的cache缓存工具。如果没有其它的可选缓存工具，则为必需的。
9. jta.jar ：JTA规范，当Hibernate使用JTA的时候需要。必需的。
10. dom4j.jar ：dom4j是一个Java的XML API，类似于jdom，用来读写XML文件的。Hibernate使用dom4j解析XML配置文件和XML映射元文件。必需的。
11. log4j.jar ：日志包，可选的。
把以上必需的jar放置到应用程序的类路径中(web应用的WEB-INF/lib目录下)。
4.2. 基本的Hibernate配置文件：
在WEB-INF/classes目录下创建一hibernate.cfg.xml(在官方下载的包etc目录下有样板文件)：
|
<?
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
>
<!--
数据库连接设置
-->
<
property
name
=
"connection.driver_class"
>
com.mysql.jdbc.Driver
</
property
>
<
property
name
=
"connection.url"
>
jdbc:mysql://localhost:3306/demo
</
property
>
<
property
name
=
"connection.username"
>
root
</
property
>
<
property
name
=
"connection.password"
>
root
</
property
>
<!-- SQL
方言
-->
<
property
name
=
"dialect"
>
org.hibernate.dialect.MySQLInnoDBDialect
</
property
>
<!--
实际操作数据库时是否显示
SQL -->
<
property
name
=
"show_sql"
>
true
</
property
>
<!--
将数据库
schema
的
DDL
导出到数据库
-->
<!--
property
name
=
"hibernate.hbm2ddl.auto"
>
create
</
property!--
>
<!--
以下设置对象与数据库表的映像文件
-->
......
</
session-factory
>
</
hibernate-configuration
>
|
5. 第一个Hibernate应用程序：
5.1. 创建一个持久化类：
持久化类就是其实例要被持久化到数据库中的类，通常都是实体域类，它是带有一些属性及属性的getters、setters方法的POJO类：
|
package
org.qiujy.demo;
/**
*
User
持久化类
*
第一个
Hibernate
示例
*
@author
Administrator
*
*/
public
class
User {
private
Integer
id
;
private
String
name
;
private
Integer
age
;
public
User(){}
public
Integer getAge() {
return
age
;
}
public
void
setAge(Integer age) {
this
.
age
= age;
}
public
Integer getId() {
return
id
;
}
public
void
setId(Integer id) {
this
.
id
= id;
}
public
String getName() {
return
name
;
}
public
void
setName(String name) {
this
.
name
= name;
}
}
|
5.2. 准备好数据库表：
在MySQL中新增一个demo数据库，并建立user表：
|
CREATE TABLE user (
id INT(11) NOT NULL auto_increment PRIMARY KEY,
name VARCHAR(100) NOT NULL default '',
age INT
);
|
5.3. 创建对象-关系映射文件：
Hibernate需要知道怎样去加载（load）和存储（store）持久化类的对象。这正是Hibernate映射文件发挥作用的地方。映射文件告诉Hibernate应该访问数据库(database)里面的哪个表（table）以及应该使用表里面的哪些字段（column）。
在持久化类所在的包的目录下创建一名为User.hbm.xml的映射文件：
|
<?
xml
version
=
"1.0"
encoding
=
"utf-8"
?>
<!
DOCTYPE
hibernate-mapping
PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"
>
<
hibernate-mapping
>
<
class
name
=
"org.qiujy.demo.User"
table
=
"user"
>
<
id
name
=
"id"
column
=
"id"
type
=
"java.lang.Integer"
>
<
generator
class
=
"native"
/>
</
id
>
<
property
name
=
"name"
column
=
"name"
type
=
"java.lang.String"
/>
<
property
name
=
"age"
column
=
"age"
type
=
"java.lang.Integer"
/>
</
class
>
</
hibernate-mapping
>
|
5.4. 在Hibernate配置文件hibernate.cfg.xml中指明映射文件的位置：
|
<
session-factory
>
<!--
以下设置对象与数据库表的映像文件
-->
<
mapping
resource
=
"org/qiujy/demo/User.hbm.xml"
/>
</
session-factory
>
|
5.5. 使用Hibernate API进行持久化操作：
1. 创建一辅助类：由这个辅助类来创建一个线程安全的、全局的SessoinFactory，SessionFactory可以创建并打开新的单线程的Session。
|
package org.qiujy.common;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
/**
* HibernateSession
工厂
*/
public class HibernateSessionFactory {
/** Hibernate
的配置文件
hibernate.cfg.xml */
private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.xml";
/** Session
的线程本地变量
*/
private static final ThreadLocal threadLocal = new ThreadLocal();
/** transaction
的线程本地变量
*/
private static final ThreadLocal txThreadLocal = new ThreadLocal();
private static Configuration configuration = new Configuration();
private static org.hibernate.SessionFactory sessionFactory;
private static String configFile = CONFIG_FILE_LOCATION;
private HibernateSessionFactory() {
}
/**
*
获得一个线程本地化的
Hibernate session
实例
* @return Session
* @throws HibernateException
*/
public static Session getSession() throws HibernateException {
Session session = (Session) threadLocal.get();
if (session == null || !session.isOpen()) {
if (sessionFactory == null) {
rebuildSessionFactory();
}
session = (sessionFactory != null) ? sessionFactory.openSession()
: null;
threadLocal.set(session);
}
return session;
}
/**
* Rebuild hibernate session factory
*/
public static void rebuildSessionFactory() {
try {
configuration.configure(configFile);
sessionFactory = configuration.buildSessionFactory();
} catch (Exception e) {
System.err
.println("%%%% Error Creating SessionFactory %%%%");
e.printStackTrace();
}
}
/**
*
关闭线程化的
Hibernate session
实例
* @throws HibernateException
*/
public static void closeSession() throws HibernateException {
Session session = (Session) threadLocal.get();
threadLocal.set(null);
if (session != null) {
session.close();
}
}
/**
* return session factory
*
*/
public static org.hibernate.SessionFactory getSessionFactory() {
return sessionFactory;
}
/**
* return session factory
*
* session factory will be rebuilded in the next call
*/
public static void setConfigFile(String configFile) {
HibernateSessionFactory.configFile = configFile;
sessionFactory = null;
}
/**
* return hibernate configuration
*
*/
public static Configuration getConfiguration() {
return configuration;
}
/**
*
在本地
session
实例上开启事务
*/
public static void beginTransaction(){
Transaction tx = (Transaction)txThreadLocal.get();
if(tx == null){
tx = getSession().beginTransaction();
txThreadLocal.set(tx);
}
}
/**
*
在本地
session
实例上提交事务
*/
public static void commitTransaction(){
Transaction tx = (Transaction)txThreadLocal.get();
if(tx != null && !tx.wasCommitted() && !tx.wasRolledBack()){
tx.commit();
txThreadLocal.set(null);
}
}
/**
*
在本地
session
实例上回滚事务
*/
public static void rollbackTransaction(){
Transaction tx = (Transaction)txThreadLocal.get();
txThreadLocal.set(null);
if(tx != null && !tx.wasCommitted() && !tx.wasRolledBack()){
tx.rollback();
}
}
}
|
2. 持久化操作类：
|
package
org.qiujy.dao.impl;
import
org.apache.log4j.Logger;
import
org.hibernate.HibernateException;
import
org.hibernate.Session;
import
org.qiujy.common.HibernateSessionFactory;
import
org.qiujy.domain.User;
public
class
UseDaoHBImpl {
private
static
Logger
myLogger
= Logger.getLogger(UseDaoHBImpl.
class
);
/**
*
新增一个用户
*
@param
user
用户对象
*/
public
void
saveUser(User user) {
Session session = HibernateSessionFactory.getSession();
try
{
HibernateSessionFactory.beginTransaction();
session.save(user);
HibernateSessionFactory.commitTransaction();
}
catch
(HibernateException e) {
HibernateSessionFactory.rollbackTransaction();
myLogger
.error(
"
新增用户失败
"
, e);
}
finally
{
HibernateSessionFactory.closeSession();
}
}
/**
*
根据
ID
删除该用户对象
*
@param
id
用户
ID
*/
public
void
removeUserByID(
int
id){
Session session = HibernateSessionFactory.getSession();
try
{
HibernateSessionFactory.beginTransaction();
User user = (User) session.get(User.
class
,
new
Integer(id));
session.delete(user);
HibernateSessionFactory.commitTransaction();
}
catch
(HibernateException e) {
HibernateSessionFactory.rollbackTransaction();
myLogger
.error(
"
新增用户失败
"
, e);
}
finally
{
HibernateSessionFactory.closeSession();
}
}
/**
*
更新用户的信息
*
@param
user
用户对象
*/
public
void
updateUser(User user){
Session session = HibernateSessionFactory.getSession();
try
{
HibernateSessionFactory.beginTransaction();
session.saveOrUpdate(user);
HibernateSessionFactory.commitTransaction();
}
catch
(HibernateException e) {
HibernateSessionFactory.rollbackTransaction();
myLogger
.error(
"
新增用户失败
"
, e);
}
finally
{
HibernateSessionFactory.closeSession();
}
}
/**
*
根据用户
ID
查询该用户对象
*
@param
id
用户
ID
*
@return
User
查询成功返回该用户对象，否则返回
null
*/
public
User getUserByID(
int
id) {
User user =
null
;
Session session = HibernateSessionFactory.getSession();
try
{
//get
与
load
的区别
?
user = (User) session.get(User.
class
,
new
Integer(id));
}
catch
(HibernateException e) {
myLogger
.error(
"
查询用户失败
"
, e);
}
finally
{
HibernateSessionFactory.closeSession();
}
return
user;
}
public
static
void
main(String[] args) {
User user =
new
User();
user.setName(
"
张三
"
);
user.setAge(
new
Integer(26));
UseDaoHBImpl manager =
new
UseDaoHBImpl();
//
增
manager.saveUser(user);
//
查
User user1 = manager.getUserByID(1);
if
(user1 !=
null
){
user1.setName(
"
李四
"
);
//
改
manager.updateUser(user1);
//
删
//manager.removeUserByID(user1.getId().intValue());
}
}
}
|
3. 运行如上程序，操作成功的话，以数据库就可以看到新插入的数据了。
4. 整个web应用程序的目录结构如下：(我是在eclipse+MyEclispe下构建的)
5. 本例源代码：
6. Hibernate的核心接口：
所有的Hibernate应用中都会访问Hibernate的5个核心接口：
6.1. Configuration接口：
此接口的实例用于配置并且根启动Hibernate。Hibernate通过Cofinguration实例来指定对象-关系映射文件的位置或者动态配置Hibernate的属性，然后创建SessionFactory实例。
6.2. SessionFactory接口：
一个SessionFactory实例对应一个数据存储源。应用程序从SessionFactory中获得Session实例。SessionFactory具有以下特点：
1. 线程安全，即同一个SessionFactory实例可以被应用的多个线程共享。
2. 它是重量级的，因为它需要一个很大的缓存，用来存放预定义的SQL语句以及映射元数据等。所以，如果应用程序只访问一个数据库，则只需要创建一个SessionFactory实例。
6.3. Session接口：
应用最广泛的接口。Session也被称为持久化管理器，它提供了和持久化相关的操作：如添加、更新、删除、加载和查询对象。session有以下特点：
1. 线程不安全，在设计软件架构时，应该避免多个线程共享同一个Session实例。
2. Session实例是轻量级的，它的创建和销毁不需要消耗太多的资源。
session有一个缓存，被称为Hibernate的第一级缓存，它存放被当前工作单元加载的对象。
6.4. Transaction接口：
Transaction接口是Hibernate的数据库事务接口。它对底层的事务接口做了封装，包括：
JDBC API、JTA、CORBA。
Hibernate 应用可通过一致的Transaction接口来声明事务边界，这有助于应用在不同的环境和容器中移植。
6.5. Query和Criteria接口：
它们是Hibernate的查询接口，用于数据库查询对象以及控制执行查询的过程。Query包装了一个HQL(Hibernate Query Language)查询语句，Criteria接口完全封装了基于字符串形式的查询语句，比Query更加面向对象，Cirteria接口擅长于执行动态查询。