Solution

You tried to delete an object that was allready deleted from the database.

This can happen when cascading deletes where performed somewhere and you did not reattach your object. For deleting you do not nee to reattach your object but this could prevent this problem. 

Exception Message

19:47:56,078 ERROR AbstractBatcher:61 - Exception executing batch: 

org.hibernate.StaleStateException: Batch update returned unexpected row count from update: 0 actual row count: 0 expected: 1

at org.hibernate.jdbc.BatchingBatcher.checkRowCount(BatchingBatcher.java:93)

at org.hibernate.jdbc.BatchingBatcher.checkRowCounts(BatchingBatcher.java:79)

at org.hibernate.jdbc.BatchingBatcher.doExecuteBatch(BatchingBatcher.java:58)

at org.hibernate.jdbc.AbstractBatcher.executeBatch(AbstractBatcher.java:195)

at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java:230)

at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java:145)

at org.hibernate.event.def.AbstractFlushingEventListener.performExecutions(AbstractFlushingEventListener.java:296)

at org.hibernate.event.def.DefaultFlushEventListener.onFlush(DefaultFlushEventListener.java:27)

at org.hibernate.impl.SessionImpl.flush(SessionImpl.java:1009)

at org.hibernate.impl.SessionImpl.managedFlush(SessionImpl.java:356)

一 hibernate配置
1.下载所需包
下载hibernate2.13, hibernate-extension2.13,Middlegen(已装了jdk和ant)
2.创建数据库(例子:student;course,stu_cou)
Student(id,name)
Course(id,name)
Stu_cou(stu_id,cou_id)(分别是student表和course表的外健)
3.使用MiddleGen(见附录)

二 hibernate映射关系(many-to-many)
1. 分析inverse参数(student.hbm.xml course.hbm.xml)
inverse该参数用来负责映射之间的关系,设置为false的一方可以对他们的关系进行维护
设置inverse = false的实体,表示在映射中是它是主动关系,由它来维户关系中的数据
设置inverse = true 的实体,表示在映射中是它是被动关系,它不维护关系中的数据
1) inverse=false的情况
a) 添加记录的情况
student.hbm.xml是主动方,由它来决定stu_cou表中的记录,故inverse=false
当向stu_cou中写入记录时候,
/*
* 测试目的:在stu_cou中添加一组对应关系(student,course)
* 测试结果:当执行完该段代码后
* 如stu_cou中没有(student,course)时,自动加入(student,course)
* 如stu_cou中存在(student,course)时,什么都不作,不会存在主健冲突
Student student=(Student)session.load(Student.class,student2.getId())
Course course=(Course)session.load(Course.class,course2.getId());
student.getCourses().add(course);
session.save(student);
执行完后,hibenrate成功显示
Hibernate: select course0_.id as id0_, course0_.name as name0_ from course course0_ where course0_.id=?
Hibernate: select student0_.id as id0_, student0_.name as name0_ from student student0_ where student0_.id=?
Hibernate: select courses0_.cid as cid__, courses0_.sid as sid__ from stu_cou courses0_ where courses0_.sid=?
Hibernate: insert into stu_cou (sid, cid) values (?, ?)
b) 删除记录的情况
Student student=(Student)session.load(Student.class,student2.getId())
Course course=(Course)session.load(Course.class,course2.getId());
student.getCourses().让remove(course);
session.save(student);
代码执行完后,可以成功执行,hibernate显示:
Hibernate: select course0_.id as id0_, course0_.name as name0_ from course course0_ where course0_.id=?
Hibernate: select student0_.id as id0_, student0_.name as name0_ from student student0_ where student0_.id=?
Hibernate: select courses0_.cid as cid__, courses0_.sid as sid__ from stu_cou courses0_ where courses0_.sid=?
Hibernate: delete from stu_cou where sid=?

2) inverse=true的情况
student.hbm.xml是被动方,设置它的inverse=true
a) 添加记录情况
* 测试目的:在stu_cou中添加一组对应关系(student,course)
* 测试结果:当执行完该段代码后
* 如stu_cou中没有(student,course)时,自动加入(student,course)
* 如stu_cou中存在(student,course)时,什么都不作,不会存在主健冲突
Student tudent=(Student)session.load(Student.class,student2.getId());
Course course=(Course)session.load(Course.class,course2.getId());
student.getCourses().add(course);
session.save(student);
代码执行完后,hibernate显示,没有插入记录
Hibernate: select course0_.id as id0_, course0_.name as name0_ from course course0_ where course0_.id=?
Hibernate: select student0_.id as id0_, student0_.name as name0_ from student student0_ where student0_.id=?
Hibernate: select courses0_.cid as cid__, courses0_.sid as sid__ from stu_cou courses0_ where courses0_.sid=?

b) 删除记录情况
当向stu_cou中删除记录时候,
Student student=(Student)session.load(Student.class,student2.getId())
Course course= (Course)session.load(Course.class,course2.getId());
student.getCourses().remove(course);
session.save(student);
执行完,hibernate显示如下,证明没有删除记录
Hibernate: select course0_.id as id0_, course0_.name as name0_ from course course0_ where course0_.id=?
Hibernate: select student0_.id as id0_, student0_.name as name0_ from student student0_ where student0_.id=?
Hibernate: select courses0_.cid as cid__, courses0_.sid as sid__ from stu_cou courses0_ where courses0_.sid=?
Hibernate: select course0_.id as id0_, course0_.name as name0_ from course course0_ where course0_.id=?
Hibernate: select course0_.id as id0_, course0_.name as name0_ from course course0_ where course0_.id=?

2. 分析cascade参数(student.hbm.xml course.hbm.xml)
只有设置了inverse=false才可以操纵stu_cou的数据
当inverse=true的时候,下列情况1中b)提示错误
原因: stu_cou中存在外健约束,你无法直接删除student表中的数据
1) cascade=save-update的情况
a)添加记录情况
Set set=new HashSet();
set.add(course1);
set.add(course2);
set.add(course3);
student3.setCourses(set);
session.save(student3);
执行后hibernate提示:
Hibernate: insert into student (name) values (?)
Hibernate: insert into course (name) values (?)
Hibernate: insert into course (name) values (?)
Hibernate: insert into course (name) values (?)
Hibernate: insert into stu_cou (sid, cid) values (?, ?)
可见,插入了student,course,和stu_cou三个表

b)删除记录情况
Student student=(Student)session.load(Student.class,new Integer(22));
session.delete(student);
成功执行后,hibernate提示:
Hibernate: select student0_.id as id0_, student0_.name as name0_ from student student0_ where student0_.id=?
Hibernate: delete from stu_cou where sid=?
Hibernate: delete from student where

2) cascade=all的情况
a) 添加记录情况
Set set=new HashSet();
set.add(course1);
set.add(course2);
set.add(course3);
student3.setCourses(set);
session.save(student3);
执行后hibernate提示:成功添加级联关系
Hibernate: insert into student (name) values (?)
Hibernate: insert into course (name) values (?)
Hibernate: insert into course (name) values (?)
Hibernate: insert into course (name) values (?)
Hibernate: insert into stu_cou (sid, cid) values (?, ?)
b) 删除记录情况
Student student=(Student)session.load(Student.class,new Integer(22));
session.delete(student);
测试结果(所有和student(22)相关的记录均被删除)
删除student表中的student(22)记录
删除stu_cou表中的student(22)的记录
删除course表中的student(22)对应的course的记录

2) cascade=none情况
a) 添加记录情况
Set set=new HashSet();
set.add(course1);
set.add(course2);
set.add(course3);
student3.setCourses(set);
session.save(student3);
失败,因为没有级联关系,所以course记录添加不进去,造成外健失败

b) 删除记录情况
Student student=(Student)session.load(Student.class,new Integer(22));
session.delete(student);
正常,删除了student表中的记录student(22),同时删除了stu_cou中对应的student(22)的记录

附录
1．MiddleGen的使用
1环境变量设置
%Hibernate_Home%/lib/*.jar到%MiddleGen%/lib下
%Hibernate_Home%/hibernate2.jar到%MiddleGen%/lib下
%Hibernate-Extension_Home%/tools/lib/*.jar到%MiddleGen%/lib下
%Hibernate-Extension_Home%/tools/hibernate-tools.jar到%MiddleGen%/lib下

2 MiddleGen的配置
配置目标数据库参数
进入MiddleGen 目录下的\config\database 子目录，根据我们实际采用的数据库打开对应的配置文件。如这里我用的是mysql数据库，对应的就是mysql.xml文件。
<property
name="database.script.file" value="${src.dir}/sql/${name}-mysql.sql"/>
<property
name="database.driver.file" value="${lib.dir}/mysql.jar"/>
<property
name="database.driver.classpath" value="${database.driver.file}"/>
<property
name="database.driver" value="org.gjt.mm.mysql.Driver"/>
<property
name="database.url" value="jdbc:mysql://localhost/sample"/>
<property
name="database.userid" value="user"/>
<property
name="database.password" value="mypass"/>
<property
name="database.schema" value=""/>
<property
name="database.catalog" value=""/>
<property
name="jboss.datasource.mapping" value="mySQL"/>
其中下划线标准的部分是我们进行配置的内容，分别是数据url以及数据库用
户名和密码。

1) 修改Build.xml
修改MiddleGen 根目录下的build.xml 文件，此文件是Middlegen-Hibernate 的Ant构建配置。Middlegen-Hibernate将根据build.xml文件中的具体参数生成数据库表映射文件。可配置的项目包括：

a) 目标数据库配置文件地址
查找关键字 ”!ENTITY”，得到：
<!DOCTYPE project [
<!ENTITY database SYSTEM
"file:./config/database/hsqldb.xml">
]>
默认情况下，MiddleGen 采用的是hsqldb.xml，
将其修改为我们所用的数据库配置文件（mysql.xml）：
<!DOCTYPE project [
<!ENTITY database SYSTEM
"file:./config/database/mysql.xml">
]>

b) Application name
查找：
<property value="airline"/>
“aireline”是MiddleGen原始配置中默认的 Application Name，将其修改为我们
所希望的名称，如“HibernateSample”：
<property value="HibernateSample"/>

c) 输出目录
查找关键字“name="build.gen-src.dir"”，得到：
<property
value="${build.dir}/gen-src"/>
修改value="${build.dir}/gen-src"使其指向我们所期望的输出目录，
这里我们修改为：<property
value="C:\sample"/>
d) 对应代码的Package name
查找关键字“destination”，得到：
<hibernate
destination="${build.gen-src.dir}"
package="${name}.hibernate"
genXDocletTags="false"
genIntergratedCompositeKeys="false"
javaTypeMapper=
"middlegen.plugins.hibernate.HibernateJavaTypeMapper"
/>
可以看到，hibernate 节点package 属性的默认设置实际上是由前面的
Application Name （${name}）和“.hibernate”组合而成，根据我们的需要，
这里还有一个属性genXDocletTags，如果设置为true，则生成的代码将包含
xdoclet tag，这为以后在开发过程中借助xdoclet进行映射调整提供了帮助。注意，如果使用的数据库为SQLServer，需要将build.xml部分删除(参见夏?^的文档)，否则Middlegen会报出找不到表的错误。
至此为止，MiddleGen 已经配置完毕，在MiddleGen 根目录下运行ant，就将出现
MiddleGen的界面：
2 *.xml到.java
在得到.xml后,使用ant hbm2java 即可得到相应的java文件
总结:
我第一次运行成功,但是后来则出现如下类似错误,检查发现在MiddleGen的lib目录下存在多个类似的jar包
(velocity.jar,velocity1-0.8.jar),删除旧的jar包后,问题解决
[middlegen] java.lang.IncompatibleClassChangeError
[middlegen] at [middlegen] at org.apache.velocity.Template.process(Template.java:136)

2．(评论)关于Many-to-Many需要注意的问题
比如group/user,user/role,group/role,都是多对多的关系。
所以有必要搞搞清楚。以group/user为例
(1)group.getUsers() & user.getGroups()双向映射。在这里，考虑到user.setGroups()是不会放出来的。所以在user端加入inverse=true，就是说，让Group端来维护两者的关系表。
(2)于是，添加的时候，要把user加入到group的user set中，保存，才有意义！
(3)如果要删除group_user的关系，而不是group/user本身，那么，需要在group端设定casade=save-update。否则，group.getUsers().remove(user)不会起作用！
(4)由于有了FK保护，你是无法单独删除User的。同时，由于你指定了inverse=true,所以无法光光的设置user.getGroups().clear就能够搞定一切。你必须首先在每个Group.getUsers中删除这个user，才能最后删除。所以，UserManagerImpl代码可能看起来像这样：
public void delUser(User user) {
if (user == null) {
logger.info("Got a null user object!");
return;
}
Session session = null;
Transaction trans = null;
boolean bSuccess = false;
try {
String username = new String(user.getName());
session = PLUtils.getSession();
trans = session.beginTransaction();
session.update(user);

Set groups = ((UserEntity)user).getGroups();
for(Iterator i = groups.iterator();i.hasNext();){
GroupEntity g = (GroupEntity)i.next();
session.update(g);
g.getUsers().remove(user);
session.update(g);
}

// ((UserEntity)user).getGroups().clear();
session.delete(user);
bSuccess = true;
logger.debug("User " + username + " deleted ok!");
}
catch (ObjectNotFoundException onfe) {
logger.info("user not found!", onfe);
}
catch (Exception e) {
logger.error("failed!", e);
}
finally {
try {
if (bSuccess)
trans.commit();
else
trans.rollback();
session.close();
}
catch (Exception ex) {
}
}
}

最近在项目中使用 Spring 和 Hibernate 进行开发，有感于 Criteria 比较好用，在查询方法设计上可以灵活的根据 Criteria 的特点来方便地进行查询条件的组装。所以现在对 Hibernate 的 Criteria 深入研究一下。《 Hibernate Reference 》及网上其它一些资料对 Criteria 已经做了很多介绍。

以上代码在Session范围内通过Hibernate类的initialize()方法显式初始化了Customer代理类实例，因此当Session关闭后，可以正常访问Customer游离对象。

Distributed Objects With Hibernate

Problem:

You are building a three tier distributed system and you are passing persistent objects between tiers. When you send the objects back to the server, you want to save the only the changes.

Solutions:

1)Hibernate added the select-before-update option in 2.1. Setting this option on your class will cause Hibernate to load the data from the database and compare that to the data in your object to determine what has changed. It makes use of a version or timestamp field to enforce optimistic concurrency. This works well but introduces additional database access that could effect performance.

2)Save the original data for each persistent object and implement a custom EntityPersister to return the original state to Hibernate instead of accessing the state in the database.

Implementing Solution 2:

Step 1: Save the original state for each persistent object

The easiest way to implement this is to have each persistent object remember the original values of any properties that changed. If you make all your persistent objects proper JavaBeans, you can capture this in the base class when the object fires a propertyChanged event:

public abstract class AbstractDomainObject implements Serializable {
private PropertyChangeSupport support = new PropertyChangeSupport(this);
private Map originalValues = new HashMap();
public AbstractDomainObject() {
super();
}
public Map getOriginalState() {
return originalValues;
}
public void addPropertyChangeListener(PropertyChangeListener propertyChangeListener) {
support.addPropertyChangeListener(propertyChangeListener);
}
protected void firePropertyChange(String property, Object oldValue, Object newValue) {
if (!originalValues.containsKey(property)) {
originalValues.put(property, oldValue);
}
support.firePropertyChange(property, oldValue, newValue);
}
}

Step 2: Create your domain objects

A domain object might look like follows. Because it fires propertyChange events, the base class will remember original values of properties that changed. Note that you will want to map the properties as access=field since the setter fires a propertyChange event when called.

public class Customer extends AbstractDomainObject {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
String oldValue = this.name;
this.name = name;
firePropertyChange("name", oldValue, name);
}
}

Step 3: Create a custome entity persister

Create a custom entity persister and override getCurrentPersistentState. Set the persister for each class to this custom persister.

public Object[] getCurrentPersistentState(Serializable id, Object version, SessionImplementor session) throws HibernateException {
AbstractDomainObject entity = (AbstractDomainObject) session.getEntity(new Key(id, this));
Map originalValues = entity.getOriginalState();
Type[] types = getPropertyTypes();
String[] propertyNames = getPropertyNames();
Object[] values = new Object[propertyNames.length];
boolean[] includeProperty = getPropertyUpdateability();
for (int i = 0; i < propertyNames.length; i++) {
if (includeProperty[i]) {
if (originalValues.containsKey(propertyNames[i])) {
values[i] = types[i].disassemble(originalValues.get(propertyNames[i]), session);
} else {
values[i] = types[i].disassemble(getPropertyValue(entity, propertyNames[i]), session);
}
}
}
return values;
}

What about collections you ask? Well, Hibernate keeps track of changes to collections in the collection class wrappers for you.

Please note this solution has worked great in my example programs, but I have not yet implemented it in a production program.

Hibernate配置文件可以有两种格式，一种是hibernate.properties，另一种是hibernate.cfg.xml。后者稍微方便一些，当增加hbm映射文件的时候，可以直接在hibernate.cfg.xml里面增加，不必像hibernate.properties必须在初始化代码中加入。但不管怎么说，两种的配置项都是一样的，下面详细介绍：

在Hibernate的src目录下有一个hibernate.properties模板，我们不必自己从头写，修改模板就可以了

代码:

hibernate.query.substitutions true 1, false 0, yes 'Y', no 'N'

这个配置意思是当你在 Hibernate里面输入true的时候，Hibernate会转化为0插入数据库，当你在Hibernate里面输入false的时候， Hibernate会转化为1插入数据库，后面的Y，N同理。对于某些数据库，例如Oracle来说，没有boolean数据类型，就是采用1代表 true，0代表false，因此使用这个配置在Hibernate里面直接用true/false会非常直观。

代码:

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

hibernate.connection.driver_class org.gjt.mm.mysql.Driver

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

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

hibernate.connection.username root

hibernate.connection.password

这是一个连接MySQL数据库的例子，很直观，不必解释，不同的数据库的连接参数模板中全部给出了。

代码:

hibernate.connection.pool_size 1

hibernate.statement_cache.size 25

这是Hibernate自带的连接池的配置参数，在默认情况下将采用。意义很直观，不多解释。只是提醒一点，Hibernate这个连接池是非常原始非常简单的连接池，如果你在项目中用Hibernate的话，建议你首选App Server的连接池，次选Hibernate带的DBCP连接池。自带的连接池应该做为末选。

如果你采用DBCP连接池，除了要配置DBCP连接池以外，还需要取消掉下行的注释：

代码:

hibernate.connection.provider_class net.sf.hibernate.connection.DBCPConnectionProvider

其它的连接池同理。

如果采用App Server的连接池，假设App Server连接池的DataSource的JNDI名称为"mypool"的话，配置应该如下：

代码:

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

hibernate.connection.datasource mypool

hibernate.connection.provider_class net.sf.hibernate.connection.DatasourceConnectionProvider

其它参数就不必写了，因为已经在App Server配置连接池的时候指定好了。

如果你不是在App Server环境中使用Hibernate，例如远程客户端程序，但是你又想用App Server的数据库连接池，那么你还需要配置JNDI的参数，例如Hibernate连接远程Weblogic上的数据库连接池：

代码:

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

hibernate.connection.datasource mypool

hibernate.connection.provider_class net.sf.hibernate.connection.DatasourceConnectionProvider

hibernate.jndi.class weblogic.jndi.WLInitialContextFactory

hibernate.jndi.url t3://servername:7001/

最后，如果你需要在EJB或者JTA中使用Hibernate，需要取消下行的注释：

代码:

hibernate.transaction.factory_class net.sf.hibernate.transaction.JTATransactionFactory

杂项配置：

代码:

hibernate.show_sql false

是否将Hibernate发送给数据库的sql显示出来，这是一个非常非常有用处的功能。当你在调试Hibernate的时候，让Hibernate打印sql语句，可以帮助你迅速解决问题。

代码:

#hibernate.connection.isolation 4

指定数据库的隔离级别，往往不同的数据库有自己定义的隔离级别，未必是Hibernate的设置所能更改的，所以也不必去管它了。

代码:

hibernate.jdbc.fetch_size 50

hibernate.jdbc.batch_size 25

这两个选项非常非常非常重要！！！将严重影响Hibernate的CRUD性能!

注 : C = create, R = read, U = update, D = delete

Fetch Size 是设定JDBC的Statement读取数据的时候每次从数据库中取出的记录条数。例如一次查询1万条记录，对于Oracle的JDBC驱动来说，是不会1次性把1万条取出来的，而只会取出Fetch Size条数，当纪录集遍历完了这些记录以后，再去数据库取Fetch Size条数据。因此大大节省了无谓的内存消耗。当然Fetch Size设的越大，读数据库的次数越少，速度越快；Fetch Size越小，读数据库的次数越多，速度越慢。这有点像平时我们写程序写硬盘文件一样，设立一个Buffer，每次写入Buffer，等Buffer满了以后，一次写入硬盘，道理相同。

Oracle数据库的JDBC驱动默认的Fetch Size=10，是一个非常保守的设定，根据我的测试，当Fetch Size=50的时候，性能会提升1倍之多，当Fetch Size=100，性能还能继续提升20%，Fetch Size继续增大，性能提升的就不显著了。因此我建议使用Oracle的一定要将Fetch Size设到50。

不过并不是所有的数据库都支持Fetch Size特性，例如MySQL就不支持。MySQL就像我上面说的那种最坏的情况，他总是一下就把1万条记录完全取出来，内存消耗会非常非常惊人！这个情况就没有什么好办法了 。

Batch Size是设定对数据库进行批量删除，批量更新和批量插入的时候的批次大小，有点相当于设置Buffer缓冲区大小的意思。Batch Size越大，批量操作的向数据库发送sql的次数越少，速度就越快。我做的一个测试结果是当Batch Size=0的时候，使用Hibernate对Oracle数据库删除1万条记录需要25秒，Batch Size = 50的时候，删除仅仅需要5秒！！！可见有多么大的性能提升！很多人做Hibernate和JDBC的插入性能测试会奇怪的发现Hibernate速度至少是JDBC的两倍，就是因为Hibernate使用了Batch Insert，而他们写的JDBC没有使用Batch的缘故。以我的经验来看，Oracle数据库 Batch Size = 30 的时候比较合适，50也不错，性能会继续提升，50以上，性能提升的非常微弱，反而消耗内存更加多，就没有必要了。

代码:

#hibernate.jdbc.use_scrollable_resultset true

设定是否可以使用JDBC2.0规范的可滚动结果集，这对Hibernate的分页显示有一定的作用，默认就好了。

代码:

#hibernate.cglib.use_reflection_optimizer false

默认打开，启用cglib反射优化。cglib是用来在Hibernate中动态生成PO字节码的，打开优化可以加快字节码构造的速度。

不过，当你在调试程序过程中，特别是和proxy，lazy loading相关的应用中，代码出错，但是出错提示信息有语焉不详，那么你可以把cglib优化关掉，这样Hibernate会输出比较详细的调试信息，帮助你debug。

尽管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 = ldName";
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 = ldName";
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”。在升级映射文件时，如果原来的映射文件中的有关元素，如<set>、<class>等没有显式设置lazy属性，那么必须把它们都显式的设置为lazy=“true”。如果觉得这种升级方式很麻烦，可以采取另一简单的升级方式：在<hibernate-mapping>元素中设置: 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 集合映射

<index>元素在某些情况下被<list-index>和<map-key>元素替代。此外，Hibernate3.0用<map-key-many-to-many> 元素来替代原来的<key-many-to-many>.元素，用<composite-map-key>元素来替代原来的<composite-index>元素。

1.2.4 DTD

对象-关系映射文件中的DTD文档，由原来的：
http://hibernate.sourceforge.net/hi...mapping-2.0.dtd
改为：
http://hibernate.sourceforge.net/hi...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()函数

hibernate2 升级为hibernate3的需要注意的事

1.首先将hibernate2.jar替换为hibernate3.jar(hibernate-3.0.5)
hibernate-tools.jar也替换成新的(从hibernate-tools-3.0.0.alpha4a找出来的)
2.将所有程序中的net.sf.hibernate替换为org.hibernate.

3.但是有例外
net.sf.hibernate.expression.Expression换为org.hibernate.criterion.Expression
如果用eclipse,用ctrl+shift+o快捷键可以加快速度

4.在使用hql查询时将
createSQLQuery(hql,"c",EZCampaignDTO.class);改为createSQLQuery(hql).addEntity("c",EZCampaignDTO.class);

5.在批量插入时
将原来的int size = ((SessionFactoryImpl)(session.getSessionFactory())).getJdbcBatchSize()
改为int size = ((SessionFactoryImpl)(session.getSessionFactory())).getSettings().getJdbcBatchSize();

6.在计算count时
将原来的int size = ((Integer) session.iterate(hql).next()).intValue();
改为int size = ((Integer) session.createQuery(hql).iterate().next()).intValue();
其中hql="select count(*) from " + DAOVar.contactClass;

7.还有就是把.hbm中的hibernate-mapping-2.0.dtd替换为hibernate-mapping-3.0.dtd
Hibernate Mapping DTD 2.0替换为Hibernate Mapping DTD 3.0

8.hibernate.cfg.xml中
Hibernate Mapping DTD 2.0替换为Hibernate Mapping DTD 3.0
<property name="hibernate.dialect">org.hibernate.dialect.SQLServerDialect</property>

9.hibernate.properties中类似

10.cache-config.xml中
<provider className="net.sf.hibernate.cache.OSCacheProvider"/>替换为
<provider className="org.hibernate.cache.OSCacheProvider"/>

11.classeshibernate.properties中
hibernate.cache.provider_class=org.hibernate.cache.EhCacheProvider
hibernate.dialect=org.hibernate.dialect.SQLServerDialect
晕s了,怎么这里还有
还是用编辑器暴力替换一下吧干脆

然后部署,集成测试,希望一切ok
结果咣铛,还是报错

12.在自动外部模块部分有一个功能是根据模版自动生成.hbm文件在load,结果出来的.hbm中有问题:
生成的 <composite-id unsaved-value="any" mapped="false">其中mapped="false" 出错.
找了半天才发现在网上的hibernate-mapping-3.0.dtd文件有支持mapped="false"这个属性.而本地的hebernate3.0.5中的
hibernate-mapping-3.0.dtd文件没有这个属性.晕,hibernate也太不负责了吧. 解决办法把hibernate-mapping-3.0.dtd
copy到jboss\bin目录下然后,在template文件中
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN" "hibernate-mapping-3.0.dtd">
然后他会在jboss\bin目录下读取该文件

13.重新测试,还是咣铛
发现子类读父类数据时抛出异常
"org.hibernate.LazyInitializationException: could not initialize proxy"
延迟抓取出的错,hb3对many-to-one的默认处理是lazy = "proxy"
没有搞懂到底怎么回事,把所有many-to-one,one-to-one都加上lazy="false"
再测试终于大功告成

在使用hibernate过程中经常碰到一些异常，有些很常见，经过个人经验和网上的搜集，也总结一下：

一.CGLIB异常

org.springframework.orm.hibernate.HibernateSystemException: exception setting property value with CGLIB (set hibernate.cglib.use_reflection_optimizer=false for more info) setter of com.anyi.fa.model.FaCard.setCardND; nested exception is net.sf.hibernate.PropertyAccessException: exception setting property value with CGLIB (set hibernate.cglib.use_reflection_optimizer=false for more info) setter of com.anyi.fa.model.FaCard.setCardND
net.sf.hibernate.PropertyAccessException: exception setting property value with CGLIB (set hibernate.cglib.use_reflection_optimizer=false for more info) setter of com.anyi.fa.model.FaCard.setCardND
 at net.sf.hibernate.persister.AbstractEntityPersister.setPropertyValues(AbstractEntityPersister.java:220)
 at net.sf.hibernate.impl.SessionImpl.initializeEntity(SessionImpl.java:2224)
 at net.sf.hibernate.loader.Loader.initializeEntitiesAndCollections(Loader.java:319)
 at net.sf.hibernate.loader.Loader.doQuery(Loader.java:309)
 at net.sf.hibernate.loader.Loader.doQueryAndInitializeNonLazyCollections(Loader.java:138)
 at net.sf.hibernate.loader.Loader.loadEntity(Loader.java:941)
 at net.sf.hibernate.loader.Loader.loadEntity(Loader.java:961)
 at net.sf.hibernate.loader.EntityLoader.load(EntityLoader.java:59)
 at net.sf.hibernate.loader.EntityLoader.load(EntityLoader.java:51)
 at net.sf.hibernate.persister.EntityPersister.load(EntityPersister.java:413)
 at net.sf.hibernate.impl.SessionImpl.doLoad(SessionImpl.java:2131)

 此中异常比较常见，一般是因为null造成的。例如：一个int映射到数据库中，但从数据库读取时是null值这样就会出现此中异常。

解决方式：如果允许为空的字段做一包装（int-->Integer,long-->Long，double--->Double等），其实这在系统设计时就应该根据实际情况考虑到的。

二 。延迟加载问题

net.sf.hibernate.LazyInitializationException:

 Failed to lazily initialize a collection - no session or session was closed

此类问题也是比较常见的，一般是由于采用了延迟加载机制(lazy=true)，在session关闭之后又调用延迟加载的数据或方法造成的。

解决方式:

   在session关闭之前读取，或调用HIbernate.initalize()方法。

三.BigDecimal属性映射时要指定小数位数。

四.其他就是一些级联更新删除，主外建约束错误，操作主，子表顺序的问题了，一般比较容易解决.  

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1108781

 // Fields
 private AllTablePbId id;

 // Property accessors
 public AllTablePbId getId() {
  return this.id;
 }

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

public class AllTablePbId implements java.io.Serializable {

 // Fields

 private String owner;

 private String tableName;

 private String columnName;

 private String dataType;

 private String pbcCnam;

 private String pbcCmnt;

 // Property accessors

 public String getOwner() {
  return this.owner;
 }

 public void setOwner(String owner) {
  this.owner = owner;
 }

 public String getTableName() {
  return this.tableName;
 }

 public void setTableName(String tableName) {
  this.tableName = tableName;
 }

 public String getColumnName() {
  return this.columnName;
 }

 public void setColumnName(String columnName) {
  this.columnName = columnName;
 }

 public String getDataType() {
  return this.dataType;
 }

 public void setDataType(String dataType) {
  this.dataType = dataType;
 }

 public String getPbcCnam() {
  return this.pbcCnam;
 }

 public void setPbcCnam(String pbcCnam) {
  this.pbcCnam = pbcCnam;
 }

 public String getPbcCmnt() {
  return this.pbcCmnt;
 }

 public void setPbcCmnt(String pbcCmnt) {
  this.pbcCmnt = pbcCmnt;
 }

}

配置文件：
<hibernate-mapping>
 <class name="com.hhkj.workflow.bean.AllTablePb" table="V_ALLTAB_PB" schema="CANP">
  <composite-id name="id" class="com.hhkj.workflow.bean.AllTablePbId">
   <key-property name="owner" type="string">
    <column name="OWNER" length="30" />
   </key-property>
   <key-property name="tableName" type="string">
    <column name="TABLE_NAME" length="30" />
   </key-property>
   <key-property name="columnName" type="string">
    <column name="COLUMN_NAME" length="30" />
   </key-property>
   <key-property name="dataType" type="string">
    <column name="DATA_TYPE" length="106" />
   </key-property>
   <key-property name="pbcCnam" type="string">
    <column name="PBC_CNAM" length="30" />
   </key-property>
   <key-property name="pbcCmnt" type="string">
    <column name="PBC_CMNT" length="254" />
   </key-property>
  </composite-id>
 </class>
</hibernate-mapping>
这样就可以通过AllTablePb.getId()取得相关的信息。
      感觉myeclipse的确不错，特别是对于使用hibernate还不是非常熟练的人来说，通过它可以帮解决不少问题。
      通过这样对视图的操作，同样也可以用到对于那些没有定义主键的表，操作方法是一样的。
      呵呵，个人的一点体会，欢迎大家多提意见。