BlogJava-大道至简-文章分类-Hibernate

Hibernate3中的更新与删除

Tony — Tue, 21 Mar 2006 10:38:00 GMT

在Hibernate2中对某个表进行更新和删除，必须先把它Load出来，在后更改，然后再保存。
这个过程对于批量操作或者对于表关系比较复杂的情况，是很复杂的。
在Hibernate3中HQL语句中已经支持update 和delete 了
但是要注意的是update和delete的HQL不是面向对象的了。你用对象方式的语句返回会出错。
下面是一个简单的例子。
用对象的方式，不用HQL：

        Session session = getSession();
        Customer host = (Customer) session.load(Customer. class ,hostEmail);
        Customer guest = (Customer)session.load(Customer. class ,guestEmail);
        ContactId id = new ContactId(host,guest);
        Contact contact = (Contact)session.load(Contact. class ,id);
        RelationShip relation = (RelationShip)session.load(RelationShip. class , 2 );
        contact.setRelationShip(relation);
        contact.setUpdateTime(Calendar.getInstance().getTime());
        session.flush();
        session.close();

用HQL：

         private static final String HQL_BADGUY_TO_FRIEND = " update Contact set relation_id = 1,
                updateTime = :updateTime where host = :hostEmail and guest = :guestEmail " ;

        Session session = getSession();
        Query query = session.createQuery(HQL_BADGUY_TO_FRIEND);
        query.setString( " hostEmail " ,hostEmail);
        query.setString( " guestEmail " ,guestEmail);
        query.setDate( " updateTime " ,Calendar.getInstance().getTime());
        query.executeUpdate();
        session.close();

如果你把HQL写成这个样子：
update Contact as c set c.relationShip.relationId =1 ......
反而会出错，也就是说，你就按照native SQL去写就行了。
还有，如果能使用这样的功能
hibernate.query.factory_class = org.hibernate.hql.classic.ClassicQueryTranslatorFactory
这个Hibernate配置属性要不去掉，要不换成org.hibernate.hql.ast.ASTQueryTranslatorFactory
上面那个是支持Hibernate2的。
但是有一点要注意，如果你用update语句来做的话，可能产生缓存同步问题，而且两种方法最后Hibernate执行的语句差不多，对于第一种方法 Hibernate也是就生成一条update语句，当然因为我是根据主键来update的，如果批量处理的话还是用Update HQL快。

Tony 2006-03-21 18:38 发表评论

创建struts1.2 + Hibernate3.0 Web工程

Tony — Tue, 21 Mar 2006 10:36:00 GMT

1. 环境说明

　　安装Eclipse和安装MyEclipse组件的过程在这里不进行介绍。可以参考其它资料完成Eclipse环境的安装与资源的配置。

　　接下来的篇幅将给出一个在MyEclipse开发环境下的一个Web工程实例。说明在MyEclipse的集成开发环境下，如何利用Struts进行Web工程开发。

例子工程的环境：

Windows 2000 Professional或者更高的版本。
J2SDK 5.0
Apache Tomcat 5.0
MySQL 4.0.14b
Eclipse-SDK-3.1
MyEclipse 4.0
SQLyog407(可选)

2. 例子工程说明

　　本例子是利用struts架构，实现用户logon的Web工程。在这个工程中，用户可以访问三个页面，index.jsp、logon.jsp、menu.jsp。他们的关系如下图所示：

　　其中，左上角的方框代表struts结构中/WEB-INF/struts-config.xml中定义的，，也就是在整个Web工程中，只要有logon的动作发生，都会使画面转移到logon.jsp。那么处理logon.jsp画面的formbeen是上图上放右侧的模块表示的formbean来完成——logonForm。

　　LogonFrom处理后会有两个结果，“success”的时候，画面会转移到menu.jsp，失败的话，回到logon画面。

　　在logon画面，用户需要输入用户名和密码，点击submit，进行登录认证。输入内容的检测是在logonForm的bean中检查。判断操作在logonAction的bean中完成，在logonAction的bean中，需要访问MySql数据库的Account表格，进行用户和密码的查询。查询成功的话，证明用户认证通过。

3. 建立工程

3.1 v创建新的Web Project

　　启动MyEclipse，通过Wizard，建立一个Web工程。如下图：

　　点击project后，MyEclipse弹出工程的对话框，我们在所罗列的工程中选中MyEclipse下面的J2EE Projects的Web Project。如下图所示：

　　在Wizard的下一页，必要的输入信息是Project Name、Context root URL。最后点击finish，一个空的WebProject就已经建立起来了

3.2 加载Struts

　　在新创建的Web Project中加载struts。

　　在MyEclipse集成开发环境下，已经集成了struts开发的环境，用户可以根据自己的实际需要，加载struts的环境。加载过程如下图：

　　右键点击刚刚创建好的工程，点击MyEclipse属性，在扩展的右键菜单里面，选择Add Struts Capabilities。

　　MyEclipse集成环境就会自动将Struts所需要的目录结构进行创建，并将需要的环境资源自动引用到相应的目录中去。

　　我们还要对自动生成的Struts进行修正，首先，修改WEB-INF/web.xml 将标签中的属性删除。 ->

　　其次要添加本工程的标签定义库，添加

/WEB-INF/app.tld

/WEB-INF/struts-bean.tld

/WEB-INF/struts-html.tld

/WEB-INF/struts-logic.tld

4. 完善工程

4.1 添加index画面

　　在加载完Struts结构之后，就可以在这个工程中添加内容了。我们可以添加一个画面JSP。添加JSP很简单，点击工程的右键，添加JSP。Wizard会弹出一个添加的对话框。如下图：

　　在File Name栏中改变文件名称，改成index.jsp把这个jsp作为Web工程的第一个画面。

　　Template To Use 栏可以选择第五项（选择选择其他项也可以）。

　　对于新生成的jsp文件进行必要的修改。

Index.jsp文件：

<%@ page language="java" pageEncoding="UTF-8"%>

<%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean" %>
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
<%@ taglib uri="/WEB-INF/struts-logic.tld" prefix="logic" %>

    My JSP 'index.jsp' starting page

　其中蓝色和橙色部分是修改的内容，蓝色部分是今后自动添加jsp文件必须修改的地方，让这个页面用到的tag都能在这个工程中定义的tag集合中找到。

　　橙色部分是画面的主要显示内容。

的内容是一段文本，内容被struts结构的静态文本集合中的 index.heading给替换掉了。这个文本的内容可以在工程的src\com\yourcompany\struts\ ApplicationResources.properties文件中找到。Struts结构推荐用户将页面上的静态文本用 ApplicationResources的形式替换。这样可以在大量的维护页面文字时候，感到便捷很多，同时，也大大减轻了多国语言版本网页的维护。

　　相当于html语言中的。这个tag是在/WEB-INF/struts-html.tld中可以找到并在显示页面的时候，被转义成

4.2 添加logon画面

　　添加方法跟添加index画面相同。修改内容稍微有些差别。

Logon.jsp的内容：

<%@ page language="java" pageEncoding="UTF-8"%>

<%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean" %>
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
<%@ taglib uri="/WEB-INF/struts-logic.tld" prefix="logic" %>



    logon.jsp




    content="keyword1,keyword2,keyword3">


    action="/logon.do" method="post" focus="userName">

	property="userName" />
Password:

　　其中，蓝色部分是引用本工程的tag标示库，红色的部分是表单属性名称的修改，和指定action动作的名称。

4.3 修改WEB-INF/struts-config.xml

　　画面上出现了form，那么根据struts的结构要求，就必须在WEB-INF/struts-config.xml中明确这个form的 formbean（表单内容校验的java class）是什么。执行这个form的action（表单执行的内部逻辑）是什么，以及action的结果会产生怎样的画面迁移。这些都是在WEB- INF/struts-config.xml中定义的。也就是标准的MVC架构所要求的。





          path="/logon"
      type="com.yourcompany.actions.LogonAction"
      name="logonForm"
      scope="request"
      input="/logon.jsp">

　　其中部分是说明action的属性。

　　Path 指定Action处理的URL

　　Type 指定Action的类名

　　Name 指定Action主力的ActionForm名，与元素的name属性匹配。

　　Scope 指定ActionForm存在的范围

　　Input 指定包含客户提交表单的网页，如果ActionForm的Validate方法返回错误，则因该把用户请求转发到这个网页。

　　Validate 如果取值为true，则表示ActionServlet应该调用ActionForm的validate方法

　　Forward 就是Action的execute方法执行完毕后，把客户请求在转发给相应的页面。

4.4 添加formbean和actionbean

　　添加方法跟JSP相同，但是在选择superclass的时候，formbean要选择ActionForm作为类的父类。Actionbean的父类是Action

　　下面是各自的代码

LogonForm.java文件内容:

package com.yourcompany.forms;
import javax.servlet.http.HttpServletRequest;

import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionMapping;

public class LogonForm extends ActionForm {

private static final long serialVersionUID
= 7322786881443789688L;
// ------------------------------
--------------------------- Instance Variables
    private String username = null;
    private String password = null;

// -------------------------
-------------------------------- Methods
    public String getUserName() {
return (this.username);
    }

    public void setUserName(String username) {
        this.username = username;
    }

    public String getPassword() {
return (this.password);
    }

    public void setPassword(String password) {
        this.password = password;
    }

public void reset(ActionMapping mapping,
HttpServletRequest request) {
this.password = null;
this.username = null;
}

}

LogonAction.java文件：
package com.yourcompany.actions;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;

import com.yourcompany.forms.LogonForm;

public class LogonAction extends Action {

public ActionForward execute(ActionMapping
mapping, ActionForm form,
HttpServletRequest request,
HttpServletResponse response) {

String userName = null;
String password = null;

if (form != null) {
userName = ((LogonForm) form).getUserName();
password = ((LogonForm) form).getPassword();
}
if(userName.equals(“test1”) && password.
equals(“test1”)){
return (mapping.findForward("success"));
}
else{
return (mapping.findForward("fails"));
}
}

}

4.5 添加menu画面

　　与添加index画面的方法相同。下面是menu.jsp文件的内容

<%@ page language="java" pageEncoding="UTF-8"%>

<%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean" %>
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
<%@ taglib uri="/WEB-INF/struts-logic.tld" prefix="logic" %>


        menu.jsp

5. 调试工程

如果本地机器已经安装了Tomcat5，那么可以在MyEclilpse的环境下调试工程了。

指定Tomcat5 的web application service 如下图：

将Enable选项打开，并且指定Tomcat的安装目录。

配置目前的工程到Tomcat中去。

点选工具栏上的被红线圈出的按钮

在弹出来的对话框中选择，我们创建的工程，和添加Tomcat5 的web application service

然后就可以按下工具栏上的启动服务按钮，调试这个Web工程了。

每一次改动工程中的文件后，要想看看改动后的效果，那么就在配置工程中，重新发布这个工程到tomecat5去。

6. Tomcat下如何配置mysql的数据库连接池

6.1 配置server.xml

配置Tomcat的server.xml文件，路径：【TOMCAT_HOME】\common\lib下的server.xml文件在之前加入以下内容以添加JNDI数据源：

DBTest" docBase="DBTest"
        debug="5" reloadable="true" crossContext="true">
             prefix="localhost_DBTest_log." suffix=".txt"
             timestamp="true"/>
jdbc/TestDB"
               auth="Container"
               type="javax.sql.DataSource"/>
jdbc/TestDB">

      factory
    org.apache.commons.dbcp.BasicDataSourceFactory



      maxActive
      100



      maxIdle
      30



      maxWait
      10000



     username
     root


     password




       driverClassName
       org.gjt.mm.mysql.Driver



      url jdbc:mysql://192.168.0.208:3306
/db_test_account?autoReconnect=true

注意:

*其中蓝色字体表示你这个应用的路径和别名,也就是你访问自己配置的这个web站点的名字,注意区分大小写,必须一致,否则系统无法正常运行(例:http://localhost:8080/DBTest)

*其中红色字体表示数据源的名字,注意将会被web.xml和你访问数据库的程序调用

6.2 配置web.xml

配置Web用程序的web.xml文件

        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
    "http://java.sun.com/dtd/web-app_2_3.dtd">

MySQL Test App

      DB Connection
      jdbc/TestDB
      javax.sql.DataSource
      Container

6.3 访问数据库的程序片段

package swt.db.DBUtility;

import javax.naming.*;
import javax.sql.*;
import java.sql.*;

public class DBTest {

String foo = "Not Connected";
int bar = -1;

public void init() {
    try{
      Context ctx = new InitialContext();
      if(ctx == null )
          throw new Exception("Boom - No Context");
      DataSource ds =
            (DataSource)ctx.lookup(
               "java:comp/env/jdbc/TestDB");
      if (ds != null) {
        Connection conn = ds.getConnection();
        if(conn != null) {
            foo = "Got Connection "+conn.toString();
            Statement stmt = conn.createStatement();
            ResultSet rst =
                stmt.executeQuery(
                  " select UserName from t_account ");
            if(rst.next()) {
               foo=rst.getString(1);
               bar=208;
            }
            conn.close();
        }
      }
    }catch(Exception e) {
      e.printStackTrace();
    }
}
public String getFoo() { return foo; }
public int getBar() { return bar;}
}

6.4 Jsp页面(index.jsp)

<%@ page language="java" pageEncoding="UTF-8"%>
<%@ page import ="swt.db.DBUtility.*" %>

    DB Test

<%
    DBTest tst = new DBTest();
    tst.init();
%>

Results

Foo <%= tst.getFoo() %>

Bar <%= tst.getBar() %>

启动Tomcat在浏览器上输入http://localhost:8080/DBTest

备注：

连接池配置(Database Connection Pool (DBCP) Configurations)
DBCP使用的是Jakarta-Commons Database Connection Pool 要使用连接池需要如下的组件即jar文件

Jakarta-Commons DBCP 1.1 对应commons-dbcp-1.1.jar。
Jakarta-Commons Collections 2.0 对应commons-collections.jar。
Jakarta-Commons Pool 1.1 对应commons-pool-1.1.jar。
这三个jar文件要与你的JDBC驱动程序一起放到【TOMCAT_HOME】\common\lib目录下以便让tomcat和你的web应用都能够找到。

7. Tomcat5.0下配置Hibernate3.0应用

7.1 在Tomcat下建立数据库连接池，如6中所示

7.2 在Struts应用中添加Hibernate3.0支持

注意：hibernate.cfg.xml文件一定要存放到跟目录下，默认的也就是/web应用/src,这个部署这个应用的时候hibernate.cfg.xml才会出现在classes目录下，也就是hibernate存放配置文件的默认录入下.

由于我们采用Tomcat提供的数据库连接池，所以这里我们将是用自己创建的SessionFactory类。点击完成MyEclipse会自动把 Hibernate所需的的类库加入到当前应用中。接下来就是配置Hibernate连接数据库的所需的参数，以及性能参数（可选）。

既然我们选用应用服务器所提供的数据库连接池，那么在这里我们只须要指定数据源的名字：java:comp/env/jdbc/TestDB，其中 jdbc/TestDB就是我们在Tomcat中配置的数据源，也就是我们上面提到的jdbc/TestDB，资源名称一定要匹配。其他的参数由于已经在 Tomcat中配置过了，所以在这里就不用配置了，Dialect一定要指定跟我们数据库匹配的语言。既然我们选用应用服务器所提供的数据库连接池，那么在这里我们只须要指定数据源的名字：java:comp/env/jdbc/TestDB，其中 jdbc/TestDB就是我们在Tomcat中配置的数据源，也就是我们上面提到的jdbc/TestDB，资源名称一定要匹配。其他的参数由于已经在 Tomcat中配置过了，所以在这里就不用配置了，Dialect一定要指定跟我们数据库匹配的语言。

我们可以在这里配置Hibernate一些调整性能的参数（针对不同的数据库有些属性可能无效）。

在这里我们设置show_sql为true，这样在开发调试过程成控制台可以打印真正在数据库端执行的sql语句便于查找问题。其他一些属性可以参阅http://www.hibernate.org。
到这里Hibernate的配置已经基本完成，下面创建SessionFactory用来和数据库进行交互（Hibernate官方文档提供）。

package com.db;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {

    private static Log log =
LogFactory.getLog(HibernateUtil.class);

    private static final SessionFactory sessionFactory;

    static {
        try {
            sessionFactory = new Configuration().configure().
buildSessionFactory();
        } catch (Throwable ex) {
            log.error("Initial SessionFactory
creation failed.", ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static final ThreadLocal session = new ThreadLocal();

    public static Session currentSession() {
        Session s = (Session) session.get();
        if (s == null) {
            s = sessionFactory.openSession();
            session.set(s);
        }
        return s;
    }

    public static void closeSession() {
        Session s = (Session) session.get();
        if (s != null)
            s.close();
        session.set(null);
    }
}

后面将会提到如何使用HibernateUtil,下面建立我们所需的数据库
（略）我们可以使用208上的db_test_account这个数据库中的表message来测试我们的Hibernate配置是否成功。数据库样例：

建表语句：

				CREATE TABLE `message` (              
           `Id` varchar(50) NOT NULL default '0',   
           `text` varchar(50) default NULL,    
           `nextMessage` int(4) default NULL,  
           PRIMARY KEY  (`Id`)                 
          ) TYPE=MyISAM

创建O/R Mapping:

点击Edit

点击New添加MySQL的驱动，保存

激活Database Explorer，保存。

选择Database Explorer，创建数据库链接：

点击创建新的数据库,添加所需必要的参数

保存，然后右键点击该数据库选择open database，测试是否配置成功，如果不能连接查看该连接的配置参数。

点击完成后MyEclipse会自动生成POJO和Map文件，并更新Hibernate的配置文件（主要是加载Map 文件）。ID Generator选项可以根据你的需要进行选择，具体含义请参阅hibernate官方文档。下面建立一个测试用的jsp页面来看看Hibernate 是否好用。
//MyJsp.jsp

<%@ page language="java" import="com.db.*" pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+":
//"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>



    My JSP 'MyJsp.jsp' starting page









    <%
org.hibernate.Session s = HibernateUtil.currentSession();
String hql = " from Message where text='b'";
try {
org.hibernate.Query query = s.createQuery(hql);
java.util.List msgList = query.list();
hello.Message msg = (hello.Message) msgList.get(0);
out.println(msg.getId());
out.println(msg.getText());
out.println(msg.getNextmessage());
} catch (org.hibernate.HibernateException e) {
e.printStackTrace();
}
HibernateUtil.closeSession();
    %>

正常的结果如下：

Tony 2006-03-21 18:36 发表评论

如何从Hibernate2.1升级到Hibernate3.0？

Tony — Tue, 21 Mar 2006 10:33:00 GMT

1.1 Hibernate API 变化
1.1.1 包名
1.1.2 org.hibernate.classic包
1.1.3 Hibernate所依赖的第三方软件包
1.1.4 异常模型
1.1.5 Session接口
1.1.6 createSQLQuery()
1.1.7 Lifecycle 和 Validatable 接口
1.1.8 Interceptor接口
1.1.9 UserType和CompositeUserType接口
1.1.10 FetchMode类
1.1.11 PersistentEnum类
1.1.12 对Blob 和Clob的支持
1.1.13 Hibernate中供扩展的API的变化
1.2 元数据的变化
1.2.1 检索策略
1.2.2 对象标识符的映射
1.2.3 集合映射
1.2.4 DTD
1.3 查询语句的变化
1.3.1 indices()和elements()函数

尽管Hibernate 3.0 与Hibernate2.1的源代码是不兼容的，但是当Hibernate开发小组在设计Hibernate3.0时，为简化升级Hibernate版本作了周到的考虑。对于现有的基于Hibernate2.1的Java项目，可以很方便的把它升级到Hibernate3.0。

本文描述了Hibernate3.0版本的新变化，Hibernate3.0版本的变化包括三个方面：
（1）API的变化，它将影响到Java程序代码。
（2）元数据，它将影响到对象-关系映射文件。
（3）HQL查询语句。

值得注意的是， Hibernate3.0并不会完全取代Hibernate2.1。在同一个应用程序中，允许Hibernate3.0和Hibernate2.1并存。

1.1 Hibernate API 变化

1.1.1 包名

Hibernate3.0的包的根路径为: “org.hibernate” ，而在Hibernate2.1中为“net.sf.hibernate”。这一命名变化使得Hibernate2.1和Hibernate3.0能够同时在同一个应用程序中运行。

如果希望把已有的应用升级到Hibernate3.0，那么升级的第一步是把Java源程序中的所有“net.sf.hibernate”替换为“org.hibernate”。

Hibernate2.1中的“net.sf.hibernate.expression”包被改名为 “org.hibernate.criterion”。假如应用程序使用了Criteria API，那么在升级的过程中，必须把Java源程序中的所有“net.sf.hibernate.expression”替换为 “org.hibernate.criterion”。

如果应用使用了除Hibernate以外的其他外部软件，而这个外部软件又引用了Hibernate的接口，那么在升级时必须十分小心。例如 EHCache拥有自己的CacheProvider： net.sf.ehcache.hibernate.Provider，在这个类中引用了Hibernate2.1中的接口，在升级应用时，可以采用以下办法之一来升级EHCache:

（1）手工修改net.sf.ehcache.hibernate.Provider类，使它引用Hibernate3.0中的接口。
（2）等到EHCache软件本身升级为使用Hibernate3.0后，使用新的EHCache软件。
（3）使用Hibernate3.0中内置的CacheProvider：org.hibernate.cache.EhCacheProvider。

1.1.2 org.hibernate.classic包

Hibernate3.0把一些被废弃的接口都转移到org.hibernate.classic中。

1.1.3 Hibernate所依赖的第三方软件包

在Hibernate3.0的软件包的lib目录下的README.txt文件中，描述了Hibernate3.0所依赖的第三方软件包的变化。

1.1.4 异常模型

在Hibernate3.0中，HibernateException异常以及它的所有子类都继承了java.lang.RuntimeException。因此在编译时，编译器不会再检查HibernateException。

1.1.5 Session接口

在Hibernate3.0中，原来Hibernate2.1的Session接口中的有些基本方法也被废弃，但为了简化升级，这些方法依然是可用的，可以通过org.hibernate.classic.Session子接口来访问它们，例如：
org.hibernate.classic.Session session=sessionFactory.openSession();
session.delete("delete from Customer ");
在Hibernate3.0中，org.hibernate.classic.Session接口继承了org.hibernate.Session接口，在org.hibernate.classic.Session接口中包含了一系列被废弃的方法，如find()、interate()等。 SessionFactory接口的openSession()方法返回org.hibernate.classic.Session类型的实例。如果希望在程序中完全使用Hibernate3.0，可以采用以下方式创建Session实例：

org.hibernate.Session session=sessionFactory.openSession();

如果是对已有的程序进行简单的升级，并且希望仍然调用Hibernate2.1中Session的一些接口，可以采用以下方式创建Session实例：

org.hibernate.classic.Session session=sessionFactory.openSession();

在Hibernate3.0中，Session接口中被废弃的方法包括：
* 执行查询的方法：find()、iterate()、filter()和delete(String hqlSelectQuery)
* saveOrUpdateCopy()

Hibernate3.0一律采用createQuery()方法来执行所有的查询语句，采用DELETE 查询语句来执行批量删除，采用merge()方法来替代 saveOrUpdateCopy()方法。

提示：在Hibernate2.1中，Session的delete()方法有几种重载形式，其中参数为HQL查询语句的delete()方法在 Hibernate3.0中被废弃，而参数为Ojbect类型的的delete()方法依然被支持。delete(Object o)方法用于删除参数指定的对象，该方法支持级联删除。
Hibernate2.1没有对批量更新和批量删除提供很好的支持，参见<<精通Hibernate>>一书的第13章的 13.1.1节（批量更新和批量删除），而Hibernate3.0对批量更新和批量删除提供了支持，能够直接执行批量更新或批量删除语句，无需把被更新或删除的对象先加载到内存中。以下是通过Hibernate3.0执行批量更新的程序代码：
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
String hqlUpdate = "update Customer set name = :newName where name = :oldName";
int updatedEntities = s.createQuery( hqlUpdate )
.setString( "newName", newName )
.setString( "oldName", oldName )
.executeUpdate();
tx.commit();
session.close();
以下是通过Hibernate3.0执行批量删除的程序代码：
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
String hqlDelete = "delete Customer where name = :oldName";
int deletedEntities = s.createQuery( hqlDelete )
.setString( "oldName", oldName )
.executeUpdate();
tx.commit();
session.close();

1.1.6 createSQLQuery()

在Hibernate3.0中，Session接口的createSQLQuery()方法被废弃，被移到org.hibernate.classic.Session接口中。Hibernate3.0采用新的SQLQuery接口来完成相同的功能。

1.1.7 Lifecycle 和 Validatable 接口

Lifecycle和Validatable 接口被废弃，并且被移到org.hibernate.classic包中。

1.1.8 Interceptor接口

在Interceptor 接口中加入了两个新的方法。用户创建的Interceptor实现类在升级的过程中，需要为这两个新方法提供方法体为空的实现。此外，instantiate()方法的参数作了修改，isUnsaved()方法被改名为isTransient()。

1.1.9 UserType和CompositeUserType接口

在UserType和CompositeUserType接口中都加入了一些新的方法，这两个接口被移到org.hibernate.usertype包中，用户定义的UserType和CompositeUserType实现类必须实现这些新方法。
Hibernate3.0提供了ParameterizedType接口，用于更好的重用用户自定义的类型。
1.1.10 FetchMode类

FetchMode.LAZY 和 FetchMode.EAGER被废弃。取而代之的分别为FetchMode.SELECT 和FetchMode.JOIN。

1.1.11 PersistentEnum类

PersistentEnum被废弃并删除。已经存在的应用应该采用UserType来处理枚举类型。

1.1.12 对Blob 和Clob的支持

Hibernate对Blob和Clob实例进行了包装，使得那些拥有Blob或Clob类型的属性的类的实例可以被游离、序列化或反序列化，以及传递到merge()方法中。

1.1.13 Hibernate中供扩展的API的变化

org.hibernate.criterion、 org.hibernate.mapping、 org.hibernate.persister和org.hibernate.collection 包的结构和实现发生了重大的变化。多数基于Hibernate
2.1 的应用不依赖于这些包，因此不会被影响。如果你的应用扩展了这些包中的类，那么必须非常小心的对受影响的程序代码进行升级。

1.2 元数据的变化

1.2.1 检索策略

在Hibernate2.1中，lazy属性的默认值为“false”，而在Hibernate3.0中，lazy属性的默认值为“true”。在升级映射文件时，如果原来的映射文件中的有关元素，如、等没有显式设置lazy属性，那么必须把它们都显式的设置为lazy=“true”。如果觉得这种升级方式很麻烦，可以采取另一简单的升级方式：在元素中设置: default-lazy=“false”。

1.2.2 对象标识符的映射

unsaved-value属性是可选的，在多数情况下，Hibernate3.0将把unsaved-value="0" 作为默认值。

在Hibernate3.0中，当使用自然主键和游离对象时，不再强迫实现Interceptor.isUnsaved()方法。如果没有设置这个方法，当Hibernate3.0无法区分对象的状态时，会查询数据库，来判断这个对象到底是临时对象，还是游离对象。不过，显式的使用 Interceptor.isUnsaved()方法会获得更好的性能，因为这可以减少Hibernate直接访问数据库的次数。

1.2.3 集合映射

元素在某些情况下被和元素替代。此外，Hibernate3.0用元素来替代原来的.元素，用元素来替代原来的元素。

1.2.4 DTD

对象-关系映射文件中的DTD文档，由原来的：
http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd
改为：
http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd

1.3 查询语句的变化

Hibernate3.0 采用新的基于ANTLR的HQL/SQL查询翻译器，不过，Hibernate2.1的查询翻译器也依然存在。在Hibernate的配置文件中，hibernate.query.factory_class属性用来选择查询翻译器。例如：
（1）选择Hibernate3.0的查询翻译器：
hibernate.query.factory_class= org.hibernate.hql.ast.ASTQueryTranslatorFactory
（2）选择Hibernate2.1的查询翻译器
hibernate.query.factory_class= org.hibernate.hql.classic.ClassicQueryTranslatorFactory

提示：ANTLR是用纯Java语言编写出来的一个编译工具，它可生成Java语言或者是C++的词法和语法分析器，并可产生语法分析树并对该树进行遍历。ANTLR由于是纯Java的，因此可以安装在任意平台上，但是需要JDK的支持。
Hibernate开发小组尽力保证Hibernate3.0的查询翻译器能够支持Hibernate2.1的所有查询语句。不过，对于许多已经存在的应用，在升级过程中，也不妨仍然使用Hibernate2.1的查询翻译器。
值得注意的是， Hibernate3.0的查询翻译器存在一个Bug：不支持某些theta-style连结查询方言：如Oracle8i的OracleDialect 方言、Sybase11Dialect。解决这一问题的办法有两种：（1）改为使用支持ANSI-style连结查询的方言，如 Oracle9Dialect,（2）如果升级的时候遇到这一问题，那么还是改为使用Hibernate2.1的查询翻译器。

1.3.1 indices()和elements()函数

在HQL的select子句中废弃了indices()和elements()函数，因为这两个函数的语法很让用户费解，可以用显式的连接查询语句来替代 select elements(...) 。而在HQL的where子句中，仍然可以使用elements()函数。

Tony 2006-03-21 18:33 发表评论

升级Hibernate3的几点体会

Tony — Tue, 21 Mar 2006 10:32:00 GMT

之前都是用Hibernate2的，原来也没想着升级，那天突然发现项目里要做批量删除的功能，心想不如升级Hibernate3体验一下罢！
谁知把lib一改，全乱了！首先是hibernate包的路径改了，要把所有的“net.sf.hibernate”替换为“org.hibernate”。
然后就是处理下面几个废弃的方法：find()、iterate()、filter()、delete(String hqlSelectQuery)和saveOrUpdateCopy()。Hibernate3一律采用createQuery()方法来执行所有的查询语句，采用DELETE 查询语句来执行批量删除，采用merge()方法来替代 saveOrUpdateCopy()方法。——又是一次全文搜索和替换！
这样，IDE基本没有报错信息了！但一旦运行就会报Connection timed out，后来发现hibernate的config文件和map文件都必须把dtd改为3.0。否则xerces会到hibernate.org上找 3.0dtd,如果你没有联网，则会报出java.net.ConnectException。
另外，还要记得添加antlr-2.7.5H3.jar，要不会报java.lang.NoClassDefFoundError: antlr/ANTLRException。
花了大半天时间，系统基本正常了！粗略检查了一下，浏览和修改功能都正常，但有一个问题，竟然无法插入新记录啊！
出现的异常为：
org.hibernate.exception.ConstraintViolationException: could not insert
后来在所有元素中设置: default-lazy="false"就可以了。
值得一提的是，如果只想对已有的程序进行简单的升级，并且希望仍然调用Hibernate2.1中Session的一些接口，可以采用以下方式创建Session实例：
org.hibernate.classic.Session session=sessionFactory.openSession();
这样的改动会小很多～～～当然如果希望在程序中完全使用Hibernate3.0，就只能采用以下方式创建Session实例：org.hibernate.Session session=sessionFactory.openSession();

补充关于hilo Generator的变化

Submitted by alex on Fri, 2005-10-28 11:40.

如果使用高/低位算法（hilo）生成id，hibernate3也有一点变化。在hibernate2中，hi值是其对应的class的最近一个实例的id，但hibernate3则是下一个将要产生的实例的id，即h2的hi值比h3的hi值小1。

Tony 2006-03-21 18:32 发表评论

hibernate3.0实例

Tony — Tue, 21 Mar 2006 10:31:00 GMT

hibernate3.0实例
建议是有一点点是一点点基础的人又没有hibernate基础和经验的人比较适合(所谓一点点基础是最起码不要我介绍一些配置文件的什么的.).注意我用的JDBC驱动com.inet.tds.TdsDriver
要是感觉注释太少,或者是在调试的过程中出现BUG或者是什么的,请回贴,我会答复你.
大家一起努力学习吧.

1、建立PO对象
   建PO对象Customer、Order以及它们的hibernate配置文件

/*
* Created on 2005-10-12
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
*/
package testdemo;

import java.util.HashSet;
import java.util.Set;

/**
* @author liuzj
*
* TODO To change the template for this generated type comment go to Window -
* Preferences - Java - Code Style - Code Templates
*/

public class Customer {
    private int id;

    private String username;

    private String password;

    private Set orders = new HashSet();

    public Customer() {
    }

    public Customer(String username, String password, Set orders) {
        this.username = username;
        this.password = password;

        this.orders = orders;

    }

    public int getId() {
        return id;
    }

    public String getPassword() {
        return password;
    }

    public String getUsername() {
        return username;
    }

    public Set getOrders() {
        return orders;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public void setOrders(Set orders) {
        this.orders = orders;
    }

}

      "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
          "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

               name="orders"
        inverse="true"
        cascade="save-update"
    >

/*
* Created on 2005-10-13
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
*/
package testdemo;

/**
* @author liuzj
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/

import java.io.Serializable;
public class Order implements Serializable {

    private Long id;
    private String orderNumber;
    private double price;
    private Customer customer;

    public Order() {
    }
    public Order(String orderNumber,double price,Customer customer) {
      this.orderNumber=orderNumber;
      this.price=price;
      this.customer=customer;
    }
    public Long getId() {
        return this.id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getOrderNumber() {
        return this.orderNumber;
    }

    public void setOrderNumber(String orderNumber) {
        this.orderNumber = orderNumber;
    }

    public Customer getCustomer() {
        return this.customer;
    }

    public void setCustomer(Customer customer) {
        this.customer = customer;
    }

    public double getPrice(){
       return this.price;
    }
    private void setPrice( double price ){
       this.price = price;
    }
}

      "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
          "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

        name="customer"
        column="CUSTOMER_ID"
        class="Customer"
        not-null="true"
     />



上面的PO已经建立完成，下面是一个测试类

/*
* Created on 2005-10-12
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
*/
package testdemo;

import java.util.HashSet;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

import testdemo.Customer;

/**
* @author liuzj
*
* TODO To change the template for this generated type comment go to Window -
* Preferences - Java - Code Style - Code Templates
*/

public class Test {

    SessionFactory sessionFactory = new Configuration().configure().addClass(
            testdemo.Customer.class).addClass(Order.class).buildSessionFactory();
    Session session = sessionFactory.openSession();
    public void saveCustomer(Customer customer) throws Exception {

        Transaction tx = null;
        try {
            tx = session.beginTransaction();
            session.save(customer);

            tx.commit();

        } catch (Exception e) {
            if (tx != null) {
                tx.rollback();
            }
            throw e;
        } finally {
            session.close();
        }
    }


    public void testmethod()throws Exception
    {
      Customer customer=new Customer("lzhengj","001",new HashSet());
      Order order1=new Order("Order",1000,customer);
      Order order2=new Order("Order",2000,customer);
      customer.getOrders().add(order1);
      customer.getOrders().add(order2);
      this.saveCustomer(customer);

    }

    public static void main(String[] args) {

        try{
         new Test().testmethod();

        }catch(Exception e)
        {
        System.out.println("this is the testmethod  throw exception.....");
         e.printStackTrace();
        }

    }
}

ok,下面是一个hibernate的配置hibernate.cfg.xml(位于应用目录下面)

    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

          jdbc:inetdae:localhost:1433?charset=gbk&database=hibernate_test


            com.inet.tds.TdsDriver


            sa


       aa


          org.hibernate.dialect.SQLServerDialect


          true

另外还需要配置一个LOG文件log4j.properties (位于应用目录下面)

log4j.rootLogger=DEBUG, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%c{1} - %m%n

Tony 2006-03-21 18:31 发表评论

史上最简单的Hibernate入门简介

Tony — Wed, 15 Mar 2006 03:08:00 GMT

    其实Hibernate本身是个独立的框架，它不需要任何web server或application server的支持。然而，大多数的Hibernate入门介绍都加入了很多非Hibernate的东西，比如: Tomcat, Eclipse, Log4J,Struts, XDoclet, 甚至JBoss。这容易让人产生Hibernate复杂难懂的误解，特别是打击了初学者的积极性。

    在这篇文章将不涉及Eclipse, log4j, Struts, Tomcat, XDoclet，和JBoss。本文的目的是演示一下Hibernate的安装过程以及最基本的功能，从而给初学者一个低得不能再低的入门门槛。

下载文件

你需要Java SDK、 Hibernate包、Ant包、和JDBC Driver。

1、Hibernate包下载地址:
http://prdownloads.sourceforge.net/hibernate/?sort_by=date&sort=desc

2、Ant包下载地址:
http://apache.130th.net/ant/binaries/apache-ant-1.6.1-bin.zip

3、 JDBC Driver要根据你用的database来定，一般database官方网站上都会有。Hibernate支持常用的database，比如 MySQL, Oracle, PostgreSQL, 和MS-SQL Server。这些数据库都有JDBC Driver:

Oracle JDBC Driver下载地址(下载前必须同意Oracle协议书)
http://otn.oracle.com/software/htdocs/distlic.html?/software/tech/java/sqlj_jdbc/htdocs/jdbc9201.html

MySQL JDBC Driver下载地址
http://dev.mysql.com/downloads/connector/j/3.0.html

PostgreSQL JDBC Driver下载地址
http://jdbc.postgresql.org/download.html

MS-SQL Server JDBC Driver下载地址
http://www.microsoft.com/downloads/details.aspx?FamilyID=9f1874b6-f8e1-4bd6-947c-0fc5bf05bf71&displaylang=en

4、将Hibernate包和Ant包分别解压至c:\dev\下(此目录不重要，你可以换其它任何目录)。

配置环境

1、你需要添加一个新的环境变量: ANT_HOME，让它指向c:\dev\<你的ANT包所在目录>。并在PATH环境变量里添加%ANT_HOME%\bin。

2、你需要添加一个新的环境变量: JAVA_HOME，让它指向你的j2sdk根目录。并在PATH环境变量里添加%JAVA_HOME%\bin。

3、创建一个项目目录，比如c:\workspace\My1stHibernate。

在项目目录下，另外创建三个目录: src, classes, lib。

在lib目录下，创建两个目录: hibernate和db。

这样你有了如下的文件结构:

c:\workspace\My1stHibernate\
c:\workspace\My1stHibernate\src
c:\workspace\My1stHibernate\classes
c:\workspace\My1stHibernate\lib
c:\workspace\My1stHibernate\lib\hibernate
c:\workspace\My1stHibernate\lib\db

4、将c:\dev\<你的Hibernate包所在目录>\hibernate2.jar文件copy到c:\workspace\My1stHibernate\lib\hibernate下。

将c:\dev\<你的Hibernate包所在目录>\lib\下的所有文件同样copy到c:\workspace\My1stHibernate\lib\hibernate下。

将你的JDBC Driver文件(一般是一个jar文件)copy到c:\workspace\My1stHibernate\lib\db下。

创建数据库

1、用你最喜爱的database软件，创建一个hibernate_test的数据库。

2、在此数据库下，新建一个table名为CUSTOMER

CREATE TABLE CUSTOMER
(
    CID INTEGER NOT NULL PRIMARY KEY,
    USERNAME VARCHAR(12) NOT NULL,
    PASSWORD VARCHAR(12)
);

编写Java文件

public class Customer {

    private int id;
    private String username;
    private String password;

    public int getId() {
        return id;
    }

    public String getPassword() {
        return password;
    }

    public String getUsername() {
        return username;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public void setUsername(String username) {
        this.username = username;
    }

}

将此类存为c:\workspace\My1stHibernate\src\Customer.java文件。

编写Test类

import net.sf.hibernate.*;
import net.sf.hibernate.cfg.*;

public class Test {

    public static void main(String[] args) {

        try {
            SessionFactory sf =
                new Configuration().configure().buildSessionFactory();
            Session session = sf.openSession();
            Transaction tx = session.beginTransaction();

            for (int i = 0; i < 200; i++) {
                Customer customer = new Customer();
                customer.setUsername("customer" + i);
                customer.setPassword("customer");
                session.save(customer);
            }

            tx.commit();
            session.close();

        } catch (HibernateException e) {
            e.printStackTrace();
        }
    }
}

将此类存为c:\workspace\My1stHibernate\src\Test.java文件。

创建Hibernate映射文件

因为这里只有一个Class --- Customer 和一个Table --- CUSTOMER，你只需要建立一个映射文件--- Customer.hbm.xml，来对应Customer类和CUSTOMER表之间的关系。

    "-//Hibernate/Hibernate Mapping DTD//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

把此文件存为c:\workspace\My1stHibernate\src\Customer.hbm.xml，和Customer.java放在同一目录下。

编写Ant build.xml文件

你不一定要知道这个build.xml的细节，其实Ant也不是Hibernate所必须的。这里用Ant是为了简化一些任务，比如: 编译、copy、运行，等。




































配置Hibernate描述文件

Hibernate描述文件可以是一个properties或xml 文件，其中最重要的是定义数据库的连接。我这里列出的是一个XML格式的hibernate.cfg.xml描述文件。

    PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"
    "http://hibernate.sourceforge.net/hibernate-configuration-2.0.dtd">

        true

            oracle.jdbc.driver.OracleDriver


            jdbc:oracle:oci8:@hibernate_test


            你的数据库用户名


            你的数据库密码


            net.sf.hibernate.dialect.Oracle9Dialect

如果你用的不是Oracle 9i，可到C:\dev\<你的Hibernate包所在目录>\src\hibernate.properties文件里找到你的数据库，然后替换以上相对应的值。

开始运行

到c:\workspace\My1stHibernate下，运行ant run。如果你严格依照以上步骤，应该看到

run:
        [java] log4j:WARN No appenders could be found for logger (net.sf.hibernate.cfg.Environment).
        [java] log4j:WARN Please initialize the log4j system properly.
        [java] Hibernate: insert into CUSTOMER (USERNAME, PASSWORD, CID) values (?, ?, ?)
BUILD SUCCESSFUL

到你的hibernate_test数据库看一下，在CUSTMOR表里新添了200条记录，但你没有写任何JDBC code。
以后如果你要更换数据库，只需要改变hibernate.cfg.xml描述文件里相应的值即可。

Tony 2006-03-15 11:08 发表评论

Hibernate O/R映射三大基本定则

Tony — Wed, 16 Nov 2005 08:39:00 GMT

1. 引言
在Java环境下，有多种对象关系映射方法，如实体Bean、OJB、JDO、JDBC等。Hibernate是一种新的O/R映射工具，它不仅提供了从Java类到数据表的映射，也提供了数据查询和恢复等机制。Hibernate非常简单易学,目前国内有很多同行已经或正在用 Hibernate开发实施项目;但Hibernate有很多规则不为人知或应用甚少。本文的目的就是将这些规则归纳总结,希望对您的开发和设计有益。

首先声明,本文是Hibernate入门级文章,高手请不用往下看了。

2. 基本定则

定则一:数据库配置文件名称可以不是Hibernate.properties或Hibernate.cfg.xml

由于Hibernate官方文档(本文www.hibernate.org的文档)的影响,很多Hibernate开发者误以为系统一定要有名称为Hibernate.properties或Hibernate.cfg.xml的文件,而且一定要放在classes的根目录下。实际上,该文件只是一般的配置文件,名称可以自己取,文件位置可以自己定,而且在多数据库环境下,可以有多个配置文件,使得程序可以连接多个数据库。只是您在创建会话工厂时需要特殊处理,代码示例如下:

//配置文件名称

protected static String CONFIG_FILE = "my_hibernate.config";

//配置文件目录,可以考虑在该目录下存放系统所有配置文件,此处使用虚拟机参数

String configPath = System.getProperty("my.config");

//创建会话工厂

sessionFactory =( new Configuration().configure(new File(configPath+File.separator+CONFIG_FILE))) .buildSessionFactory();

定则二:小型项目中,.hbm.xml文件可以合并到一个文件中

同样由于Hibernate官方文档的影响,很多Hibernate开发者误以为Hibernate的对象关系映射一定要一个表对应一个对象,并将映射文件和对象文件放在同一目录下。实际上,该模式是为规范性考虑而设计的,因为在多人参与的项目中,多人要维护同一文件容易产生冲突;当项目比较小时,配置文件的维护人员少,我们完全可以将.hbm.xml文件合并到一个或者几个文件中。依据作者本人的项目设计开发经验,最好是项目中有几人同时从事O/R映射和持久工作,则设定几个.hbm.xml文件,每人维护一个。当然,为了便于分类和管理,每人的工作应该按逻辑划分。

大型项目中的文件配置示例如下:

小型项目中的文件配置示例如下:

要注意的是, 从对Hibernate源代码的分析可知,指定映射文件时,不能用绝对目录,只能用相对目录;而且,系统以classes根目录为当前目录。

定则三:对象关系映射是以.hbm.xml文件为基准的,而不是以PO文件为基准

该定律的意思是:系统启动检查您的对象关系映射是否正确时,是以.hbm.xml为基准来进行检查的;对象文件的property可以比映射文件的property多,但不能少。如果您有如下的映射:

系统启动,检查数据库和其他配置正确后,将以该文件为基准,首先检查User对象中有无id属性和对应的get/set方法,如果没有则报错,如果有且正确则检查有无name属性和对应的get/set方法……,直到文件结束。要注意的是,如果属性为name,则get方法名称必须为getName(), set方法名称必须为setName(),否则会报错。

如果User对象除了有id,name,loginName, passwd四个属性和对应的方法,还有其它的属性和方法,会报错吗?不会,因为对象关系映射是以.hbm.xml文件为基准的,而不是以PO文件为基准。您在项目中可以充分利用该特点,实现您自己的比较特殊的需求。例如,您可以在User对象中加入updatedPasswd表示更改后的口令,由此构造在表示层要使用的FormBean和在业务层要使用的valueObject。当然,这样做也有缺点,需要根据您的实际情况而定。
3. 总结

Tony 2005-11-16 16:39 发表评论

从头到脚跟你解释什么是Hibernate

Tony — Wed, 16 Nov 2005 08:39:00 GMT

Hibernate
　　
　　Hibernate是一个免费的开源Java包，它使得与关系数据库打交道变得十分轻松，就像您的数据库中包含每天使用的普通Java对象一样，同时不必考虑如何把它们从神秘的数据库表中取出（或放回到数据库表中）。它解放了您，使您可以专注于应用程序的对象和功能，而不必担心如何保存它们或稍后如何找到它们。
　　
　　大多数应用程序都需要处理数据。Java 应用程序运行时，往往把数据封装为相互连接的对象网络，但是当程序结束时，这些对象就会消失在一团逻辑中，所以需要有一些保存它们的方法。有时候，甚至在编写应用程序之前，数据就已经存在了，所以需要有读入它们和将其表示为对象的方法。手动编写代码来执行这些任务不仅单调乏味、易于出错，而且会占用整个应用程序的很大一部分开发工作量。
　　
　　优秀的面向对象开发人员厌倦了这种重复性的劳动，他们开始采用通常的“积极”偷懒做法，即，创建工具，使整个过程自动化。对于关系数据库来说，这种努力的最大成果就是对象/关系映射(ORM)工具。
　　
　　这类工具有很多，从昂贵的商业产品到内置于J2EE中的EJB标准。然而，在很多情况下，这些工具具有自身的复杂性，使得开发人员必须学习使用它们的详细规则，并修改组成应用程序的类以满足映射系统的需要。由于这些工具为应付更加严格和复杂的企业需求而不断发展，于是在比较简单和常见的场景中，使用它们所面临的复杂性反而盖过了所能获得的好处。这引起了一场革命，促进了轻量级解决方案的出现，而Hibernate就是这样的一个例子。
　　
　　Hibernate的工作方式
　　
　　Hibernate不会对您造成妨碍，也不会强迫您修改对象的行为方式。它们不需要实现任何不可思议的接口以便能够持续存在。惟一需要做的就是创建一份 XML“映射文档”，告诉Hibernate您希望能够保存在数据库中的类，以及它们如何关联到该数据库中的表和列，然后就可以要求它以对象的形式获取数据，或者把对象保存为数据。与其他解决方案相比，它几乎已经很完美了。
　　
　　由于本文只是一篇介绍性的文章，所以不会引入构建和使用 Hibernate映射文档的具体例子（我在《Hibernate: A Developer's Notebook》一书的头几章中已经介绍了一个例子）。此外，在网上和Hibernate的在线文档中，还可以找到一些不错的例子，请参见下面的“其他信息”部分。它实际上相当直观。应用程序对象中的属性以一种简单而自然的方式与正确的数据库结构相关联。
　　
　　运行时， Hibernate读取映射文档，然后动态构建Java类，以便管理数据库与Java之间的转换。在Hibernate中有一个简单而直观的API，用于对数据库所表示的对象执行查询。要修改这些对象，（一般情况下）只需在程序中与它们进行交互，然后告诉Hibernate保存修改即可。类似地，创建新对象也很简单；只需以常规方式创建它们，然后告诉Hibernate有关它们的信息，这样就能在数据库中保存它们。
　　
　　 Hibernate API学习起来很简单，而且它与程序流的交互相当自然。在适当的位置调用它，就可以达成目的。它带来了很多自动化和代码节省方面的好处，所以花一点时间学习它是值得的。而且还可以获得另一个好处，即代码不用关心要使用的数据库种类（否则的话甚至必须知道）。我所在的公司就曾有过在开发过程后期被迫更换数据库厂商的经历。这会造成巨大的灾难，但是借助于Hibernate，只需要简单地修改Hibernate配置文件即可。
　　
　　这里的讨论假定您已经通过创建Hibernate映射文档，建立了一个关系数据库，并且拥有要映射的Java类。有一个Hibernate“工具集”可在编译时使用，以支持不同的工作流。例如，如果您已经拥有Java类和映射文档，Hibernate可以为您创建（或更新）必需的数据库表。或者，仅仅从映射文档开始，Hibernate也能够生成数据类。或者，它可以反向设计您的数据库和类，从而拟定映射文档。还有一些用于Eclipse的alpha 插件，它们可以在IDE中提供智能的编辑支持以及对这些工具的图形访问。
　　
　　如果您使用的是Hibernate 2环境，这些工具鲜有提供，但是存在可用的第三方工具。
　　
　　使用Hibernate的场合
　　
　　既然Hibernate看起来如此灵活好用，为什么还要使用其他的工具呢？下面有一些场景，可以帮助您做出判断（或许通过提供一些比较和上下文，可以有助于鉴别非常适用Hibernate的场合）。
　　
　　如果应用对于数据存储的需要十分简单——例如，您只想管理一组用户优先选择——您根本不需要数据库，更不用说一个优秀的对象-关系映射系统了（即使它也如Hibernate这般易于使用）！从Java 1.4开始，有一个标准的Java Preferences API可以很好地发挥这个作用。（在ONJava文章中可以找到有关Preferences API的更多信息。）
　　
　　对于熟悉使用关系数据库和了解如何执行完美的SQL查询与企业数据库交互的人来说，Hibernate似乎有些碍手碍脚，这就像带有动力和自动排挡的快艇车会使注重性能的赛车驾驶员不耐烦一样。如果您属于这种人，如果您所在的项目团队拥有一个强大的DBA，或者有一些存储过程要处理，您可能想研究一下iBATIS。 Hibernate的创建者本身就把iBATIS当作是另一种有趣的选择。我对它很有兴趣，因为我们曾为一个电子商务站点开发了一个类似的系统（其功能更为强大），而且从那时到现在，我们已经在其他环境中使用过它，尽管在发现Hibernate之后，在新项目中我们通常更喜欢使用Hibernate。您可以认为，以SQL为中心的解决方案（比如iBATIS）是“反向的”对象/关系映射工具，而Hibernate是一个更为传统的ORM。
　　
　　当然，还有其他的外部原因会导致采用另外的方法。比如，在一个企业环境中，必须使用成熟的EJB架构（或者其他的一些非普通对象映射系统）。可以为提供自己的数据存储工具的平台量身定做代码，比如Mac OS X's Core Data。使用的可能是像XML DTD这样的存储规范，而它根本不涉及关系数据库。
　　
　　但是，如果您使用的是富对象模型，而且想要灵活、轻松且高效地保存它（无论您是否正要开始或已经决定使用关系数据库，只要这是一个选择——而且存在可用的优秀免费数据库，比如MySQL，或可嵌入Java的HSQLDB，它就应该始终是一个选择），那么Hibernate很可能就是您理想的选择。您可能会惊讶于节省的时间之多，以及您将会多么地喜欢使用它。
　　
　　其他信息
　　
　　Hibernate项目有大量的在线文档，可以帮助您找准方向，快速开始使用。
　　
　　权威性的参考资料是Hibernate in Action，作者是Christian Bauer和Gavin King，都是Hibernate的创建者。该书全面而基础地讲述了Hibernate包的功能和正确的使用方法。
　　
　　阅读我的书Hibernate: A Developer's Notebook，也是一种快速上手的好方法。它直接但详细地讲述了如何在Java项目中设置Hibernate，以及如何使用它的一些最重要的功能。其中的代码示例普遍基于Hibernate和HSQLDB的早期版本，所以如果您想不加改动地使用它们，需要使用这两种软件的正确版本。无论如何，基本的概念是正确的，而且我希望能够尽快地针对Hibernate 3更新本书。
　　
　　另一本有趣的书是Better Faster Lighter Java，作者是Bruce Tate 和Justin Gehtland。书中给出了一些实用方法，可以以合理的方式完成实际的项目，这也是它流行的原因之一。它在如何评估和使用（或否决）可用的Java技术方面给出了合理建议，并作为正确方法的例子提到了Hibernate和Spring。
　　
　　最后，“Working with Hibernate in Eclipse”（它预先提到了更强大的新的alpha版的Hibernate 3工具）中详细讲述了如何将一个叫做Hibernate Synchronizer的Eclipse插件与Hibernate一起使用。

Tony 2005-11-16 16:39 发表评论