日本一区二区三区在线播放,国产91久久精品一区二区,蜜桃视频在线观看网站

Hibernate中Criteria的完整用�?�?

seal — Fri, 23 Apr 2010 21:55:00 GMT

最�q�在��目中��?Spring �?Hibernate �q�行开发，有感�?Criteria 比较好用�Q�在查询�Ҏ��

设计上可以灵�zȝ��Ҏ�� Criteria 的特�Ҏ��方便地进行查询条件的�l�装。现在对 Hibernate的Criteria 的用法进行�ȝ��Q?/font>
   Hibernate 设计�?CriteriaSpecification 作�ؓ Criteria 的父接口�Q�下面提供了 Criteria和DetachedCriteria �?
   Criteria �?DetachedCriteria 的主要区别在于创建的形式不一��P�� Criteria 是在�U�的�Q�所
以它是由 Hibernate Session �q�行创徏的；�?DetachedCriteria 是离�U�的�Q�创建时无需
Session�Q�DetachedCriteria 提供�?2 个静态方�? forClass(Class) �?forEntityName(Name)
�q�行DetachedCriteria 实例的创建�?Spring 的框架提供了getHibernateTemplate
().findByCriteria(detachedCriteria) �Ҏ��可以很方便地�Ҏ��DetachedCriteria 来返回查询结
果�?
   Criteria �?DetachedCriteria 均可使用 Criterion �?Projection 讄��查询条�g。可以设
�|?FetchMode( 联合查询抓取的模�?) �Q�设�|�排序方式。对�? Criteria �q�可以设�|?FlushModel
�Q�冲�?Session 的方式）�?LockMode �Q�数据库锁模式）�?
下面�?Criterion �?Projection �q�行详细说明�?/font>
     Criterion �?Criteria 的查询条件。Criteria 提供�?add(Criterion criterion) �Ҏ��?/font>
��d��查询条�g�?br />      Criterion 接口的主要实现包括： Example �?Junction �?SimpleExpression 。�?
Junction 的实际��用是它的两个子类 conjunction �?disjunction �Q�分别是使用 AND �?OR �?/font>
作符�q�行来联 �l�查询条仉��合�?br />      Criterion 的实例可以通过 Restrictions 工具�c�L��创徏�Q�Restrictions 提供了大量的静�?/font>
�Ҏ��Q�如 eq �Q�等于）�? ge �Q�大于等于）�?between �{�来�Ҏ��的创�?Criterion 查询条�g
�Q�SimpleExpression 实例�Q�。除此之外， Restrictions �q�提供了�Ҏ��来创�? conjunction �?
disjunction 实例�Q�通过往该实例的 add(Criteria) �Ҏ��来增加查询条件�Ş成一个查询条仉��?/font>
�?br />      至于 Example 的创建有所不同�Q?Example 本��n提供了一个静态方�?create(Object
entity) �Q�即�Ҏ��一个对象（实际使用中一般是映射到数据库的对象）来创建。然后可以设�|�一�?/font>
�q��o条�g�Q?
Example exampleUser =Example.create(u)
.ignoreCase() // 忽略大小�?
.enableLike(MatchMode.ANYWHERE);
// �?String �c�d��的属性，无论在那里值在那里都匹配。相当于 %value%
Project 主要是让 Criteria 能够�q�行报表查询�Q��ƈ可以实现分组�?Project 主要�?
SimpleProjection �?ProjectionList �?Property 三个实现。其�? SimpleProjection �?
ProjectionList 的实例化是由内徏�?Projections 来完成，如提供的 avg �?count �?max �?
min �?sum 可以让开发者很�Ҏ��Ҏ��个字�D�进行统计查询�?
       Property 是对某个字段�q�行查询条�g的设�|�，如通过Porperty.forName(“color”).in
(new String[]{“black”,”red”,”write”}); 则可以创��Z��?Project 实例。通过
criteria �?add(Project) �Ҏ��加入到查询条件中厅R�?
    使用 Criteria �q�行查询�Q�主要要清晰的是 Hibernate 提供了那些类和方法来满��开发中�?/font>
询条件的创徏和组装，下面介绍几种用法�Q?/font>
1. 创徏一个Criteria 实例
org.hibernate.Criteria 接口表示特定持久�cȝ��一个查询。Session�?Criteria实例的工厂�?br /> Criteria crit = sess.createCriteria(Cat.class);
crit.setMaxResults(50);
List cats = crit.list();

2. 限制�l�果集内�?br /> 一个单独的查询条�g�? org.hibernate.criterion.Criterion 接口的一个实例�?/font>

org.hibernate.criterion.Restrictions�c? 定义了获得某些内�|�Criterion�c�d��的工厂方法�?br /> List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.like("name", "Fritz%") )
    .add( Restrictions.between("weight", minWeight, maxWeight) )
    .list();

�U�束可以按逻辑分组�?

List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.like("name", "Fritz%") )
    .add( Restrictions.or(
        Restrictions.eq( "age", new Integer(0) ),
        Restrictions.isNull("age")
    ) )
    .list();

List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.in( "name", new String[] { "Fritz", "Izi", "Pk" } ) )
    .add( Restrictions.disjunction()
        .add( Restrictions.isNull("age") )
        .add( Restrictions.eq("age", new Integer(0) ) )
        .add( Restrictions.eq("age", new Integer(1) ) )
        .add( Restrictions.eq("age", new Integer(2) ) )
    ) )
    .list();

Hibernate提供了相当多的内�|�criterion�c�d��(Restrictions 子类), 但是��其有用的是可以允许

你直接��? SQL�?br />
List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.sql("lower({alias}.name) like lower(?)", "Fritz%",

Hibernate.STRING) )
    .list();

{alias} 占位�W�应当被替换��查询实体的列别名�?
Property实例是获得一个条件的另外一�U�途径。你可以通过调用 Property.forName() 创徏一�?/font>

Property�?

Property age = Property.forName("age");
List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.disjunction()
        .add( age.isNull() )
        .add( age.eq( new Integer(0) ) )
        .add( age.eq( new Integer(1) ) )
        .add( age.eq( new Integer(2) ) )
    ) )
    .add( Property.forName("name").in( new String[] { "Fritz", "Izi", "Pk" } ) )
    .list();

3. �l�果集排�?br /> 你可以��用org.hibernate.criterion.Order来�ؓ查询�l�果�? 序�?

List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.like("name", "F%")
    .addOrder( Order.asc("name") )
    .addOrder( Order.desc("age") )
    .setMaxResults(50)
    .list();

List cats = sess.createCriteria(Cat.class)
    .add( Property.forName("name").like("F%") )
    .addOrder( Property.forName("name").asc() )
    .addOrder( Property.forName("age").desc() )
    .setMaxResults(50)
    .list();

4. 兌��
你可以��用createCriteria()非常�Ҏ��的在互相兌��的实体间建立 �U�束�?br />
List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.like("name", "F%")
    .createCriteria("kittens")
        .add( Restrictions.like("name", "F%")
    .list();

注意�W�二�?createCriteria()�q�回一个新�? Criteria实例�Q�该实例引用kittens 集合中的元素�?
接下来，替换形态在某些情况下也是很有用的�?br />
List cats = sess.createCriteria(Cat.class)
    .createAlias("kittens", "kt")
    .createAlias("mate", "mt")
    .add( Restrictions.eqProperty("kt.name", "mt.name") )
    .list();

(createAlias()�q�不创徏一个新�?Criteria实例�?
Cat实例所保存的之前两�ơ查询所�q�回的kittens集合�?没有被条仉��q��o的。如果你希望只获�?/font>

�W�合条�g的kittens�Q?你必��M��用returnMaps()�?

List cats = sess.createCriteria(Cat.class)
    .createCriteria("kittens", "kt")
    .add( Restrictions.eq("name", "F%") )
    .returnMaps()
    .list();
Iterator iter = cats.iterator();
while ( iter.hasNext() ) {
    Map map = (Map) iter.next();
    Cat cat = (Cat) map.get(Criteria.ROOT_ALIAS);
    Cat kitten = (Cat) map.get("kt");
}

5. 动态关联抓�?br /> 你可以��用setFetchMode()在运行时定义�? 态关联抓取的语义�?

List cats = sess.createCriteria(Cat.class)
    .add( Restrictions.like("name", "Fritz%") )
    .setFetchMode("mate", FetchMode.EAGER)
    .setFetchMode("kittens", FetchMode.EAGER)
    .list();

�q�个查询可以通过外连接抓取mate和kittens�?br />
6. 查询�C�Z��
org.hibernate.criterion.Example �c�d��怽�通过一个给定实�?构徏一个条件查询�?br />
Cat cat = new Cat();
cat.setSex('F');
cat.setColor(Color.BLACK);
List results = session.createCriteria(Cat.class)
    .add( Example.create(cat) )
    .list();

版本属性、标识符和关联被忽略。默认情况下��gؓnull的属性将被排除�?
可以自行调整 Example使之更实用�?

Example example = Example.create(cat)
    .excludeZeroes()           //exclude zero valued properties
    .excludeProperty("color") //exclude the property named "color"
    .ignoreCase()              //perform case insensitive string comparisons
    .enableLike();             //use like for string comparisons
List results = session.createCriteria(Cat.class)
    .add(example)
    .list();

甚至可以使用 examples在关联对象上攄��条�g�?br />
List results = session.createCriteria(Cat.class)
    .add( Example.create(cat) )
    .createCriteria("mate")
        .add( Example.create( cat.getMate() ) )
    .list();

7. 投媄(Projections)、聚合（aggregation�Q�和分组�Q�grouping�Q?br /> org.hibernate.criterion.Projections �?Projection 的实例工厂。我们通过调用

setProjection()应用投媄��C��个查询�?

List results = session.createCriteria(Cat.class)
    .setProjection( Projections.rowCount() )
    .add( Restrictions.eq("color", Color.BLACK) )
    .list();

List results = session.createCriteria(Cat.class)
    .setProjection( Projections.projectionList()
        .add( Projections.rowCount() )
        .add( Projections.avg("weight") )
        .add( Projections.max("weight") )
        .add( Projections.groupProperty("color") )
    )
    .list();


在一个条件查询中没有必要昑ּ�的��?"group by" 。某些投��q��型就是被定义�?分组投媄�Q�他

们也出现在SQL的group by子句中�?

可以选择把一个别名指�z��一个投影，�q�样可以使投影��D��U�束或排序所引用。下面是两种不同�?/font>

实现方式�Q?br />
List results = session.createCriteria(Cat.class)
    .setProjection( Projections.alias( Projections.groupProperty("color"), "colr" ) )
    .addOrder( Order.asc("colr") )
    .list();

 List results = session.createCriteria(Cat.class)
    .setProjection( Projections.groupProperty("color").as("colr") )
    .addOrder( Order.asc("colr") )
    .list();

alias()和as()�Ҏ��便的��一个投影实例包装到�? 外一�?别名的Projection实例中。简而言之，

当你��d��一个投影到一个投影列表中�?你可以�ؓ它指定一个别名：

List results = session.createCriteria(Cat.class)
    .setProjection( Projections.projectionList()
        .add( Projections.rowCount(), "catCountByColor" )
        .add( Projections.avg("weight"), "avgWeight" )
        .add( Projections.max("weight"), "maxWeight" )
        .add( Projections.groupProperty("color"), "color" )
    )
    .addOrder( Order.desc("catCountByColor") )
    .addOrder( Order.desc("avgWeight") )
    .list();

List results = session.createCriteria(Domestic.class, "cat")
    .createAlias("kittens", "kit")
    .setProjection( Projections.projectionList()
        .add( Projections.property("cat.name"), "catName" )
        .add( Projections.property("kit.name"), "kitName" )
    )
    .addOrder( Order.asc("catName") )
    .addOrder( Order.asc("kitName") )
    .list();

也可以��? Property.forName()来表�C�投影：

List results = session.createCriteria(Cat.class)
    .setProjection( Property.forName("name") )
    .add( Property.forName("color").eq(Color.BLACK) )
    .list();
List results = session.createCriteria(Cat.class)
    .setProjection( Projections.projectionList()
        .add( Projections.rowCount().as("catCountByColor") )
        .add( Property.forName("weight").avg().as("avgWeight") )
        .add( Property.forName("weight").max().as("maxWeight") )
        .add( Property.forName("color").group().as("color" )
    )
    .addOrder( Order.desc("catCountByColor") )
    .addOrder( Order.desc("avgWeight") )
    .list();

8. ��ȝ��(detached)查询和子查询
DetachedCriteria �c�M��你在一个session范围之外创徏一个查询，�q�且可以使用��L��?Session�?/font>

执行它�?br />
DetachedCriteria query = DetachedCriteria.forClass(Cat.class)
    .add( Property.forName("sex").eq('F') );
//创徏一个Session
Session session = .;
Transaction txn = session.beginTransaction();
List results = query.getExecutableCriteria(session).setMaxResults(100).list();
txn.commit();
session.close();

DetachedCriteria也可以用以表�C�子查询。条件实例包含子�? 询可以通过 Subqueries或�?/font>
Property 获得�?br />
DetachedCriteria avgWeight = DetachedCriteria.forClass(Cat.class)
    .setProjection( Property.forName("weight").avg() );
session.createCriteria(Cat.class)
    .add( Property.forName("weight).gt(avgWeight) )
    .list();
DetachedCriteria weights = DetachedCriteria.forClass(Cat.class)
    .setProjection( Property.forName("weight") );
session.createCriteria(Cat.class)
    .add( Subqueries.geAll("weight", weights) )
    .list();

�怺�兌��的子查询也是有可能的�Q?br />
DetachedCriteria avgWeightForSex = DetachedCriteria.forClass(Cat.class, "cat2")
    .setProjection( Property.forName("weight").avg() )
    .add( Property.forName("cat2.sex").eqProperty("cat.sex") );
session.createCriteria(Cat.class, "cat")
    .add( Property.forName("weight).gt(avgWeightForSex) )
    .list();

seal 2010-04-24 05:55 发表评论

illegal attempt to dereference collection(�?

seal — Fri, 23 Apr 2010 14:44:00 GMT

首先说一句：是版本的问题!

我写的hql为：

from Department as d where d.employees.name='Tom';

�q�行时出现异常：org.hibernate.QueryException: illegal attempt to dereference collection

是因为：在上面的HQL语句中，Department的关联实体employees是一个集合，而不直接是一个Employee实体�?/p>

�? Hibernate3.2.2以前的版本，Hibernate会对兌��实体自动使用隐式的inner join�Q?/p>

也就是说如下SQL语句不会有�Q何问�?nbsp;:from Department as d where d.employees.name='Tom';

�? Hibernate3.2.3以后�Q�Hibernate改变了这�U�隐式的inner join的策�?

对于如下�q�条语句�Q?/p>

from Department as d where d.employees.name='Tom';

如果employees是普通组件属性，或单个的兌��实体�Q�则Hibernate会自动生成隐式的inner join

如果myEvents是也一个集合，那么对不��P��p? �l�将会出�?org.hibernate.QueryException: illegal attempt to dereference collection异常�?br /> 据Hibernate官方说法:
�q�样可以让这使得隐含兌��更具��定性（原文�Q�This makes implicit joins more deterministic �Q��?/p>

getHibernateTemplate()和getSession()的区别（转）

seal — Mon, 22 Feb 2010 08:43:00 GMT

在前一��日志中自动生成hibernate配置文�g的时候，会在dao层用到getSession()�Ҏ��来操作数据库记录�Q�但是他�q�有个方法getHibernateTemplate()�Q�这两个�Ҏ��I�竟有什么区别呢�Q?/p>

1.使用getSession()�Ҏ��你只要��承sessionFactory�Q�而��用getHibernateTemplate()�Ҏ��必须�l�承 HibernateDaoSupport当然包括sessionFactory�Q�这点区别都不是特别重要的，下面�q�些区别��很重要�?/p>

2.getSession()�Ҏ��是没有经�q�spring包装的，spring会把最原始的session�l�你�Q�在使用完之后必��自��p��用相应的 close�Ҏ��Q�而且也不会对声明式事务进行相应的��理�Q�一旦没有及时关闭连接，��׃��D��数据库连接池的连接数�? 出，getHibernateTemplate()�Ҏ��是经�q�spring��装的，例如��d��相应的声明式事务��理�Q�由spring��理相应的连接�?/p>

在实际的使用�q�程中发现的��getHibernateTemplate()比getSession()�Ҏ��要好很多�Q�但是有些方法在getHibernateTemplate()�q�没有提供，�q�时我们用HibernateCallback 回调的方法管理数据库.

例如如下代码�Q?/p>

/**
     * 使用 hql 语句�q�行操作
     * @param hql HSQL 查询语句�Q��用回调函数访问外部变量，必须是final的）
     * @param offset 开始取数据的下�?br />     * @param length ��d��数据记录�?br />     * @return List �l�果�?br /> */
public List getListForPage ( final String hql , final int offset , final int length ) {

              List list = getHibernateTemplate().executeFind ( new HibernateCallback ( ) {
                            public Object doInHibernate ( Session session ) throws HibernateException, SQLException {
                                            Query query = session.createQuery ( hql ) ;
                                            query.setFirstResult ( offset ) ;
                                            query.setMaxResults ( length ) ;
                                            List list = query.list ( ) ;
                                            return list ;
                           }
               }) ;
               return list ;
}

seal 2010-02-22 16:43 发表评论

Spring �?HibernateDaoSupport �cȝ�� getSession() ��D��的连接泄露问题（转）

seal — Mon, 22 Feb 2010 08:43:00 GMT

摘要: Spring+Hibernate做项�? 发现有member在不加事务的情况下就去调�?getSession() �Ҏ��, �l�果��D��数据库连接不能释�? 也无法正常的提交事务(只能做查�? 不能做save(), update()). 如果配合�q�接池��用的�? 不出几分钟就会导致连接池无法拿到新连接的情况. 不过, 只要�l�DAO或者Service加入了事�? ��׃��会出现连接泄漏的问题. 谈谈�?.. 阅读全文

seal 2010-02-22 16:43 发表评论

seal — Tue, 09 Feb 2010 03:05:00 GMT

�q�个模板在每个Hibernate发行版下project/etc下，名字为hibernate.properties.
为方便查询，�?.3.2对应的内容�{下来�Q�方便以后查询：

######################
### Query Language ###
######################

## define query language constants / function names

hibernate.query.substitutions yes 'Y', no 'N'

## select the classic query parser

#hibernate.query.factory_class org.hibernate.hql.classic.ClassicQueryTranslatorFactory

#################
### Platforms ###
#################

## JNDI Datasource

#hibernate.connection.datasource jdbc/test
#hibernate.connection.username db2
#hibernate.connection.password db2

## HypersonicSQL

hibernate.dialect org.hibernate.dialect.HSQLDialect
hibernate.connection.driver_class org.hsqldb.jdbcDriver
hibernate.connection.username sa
hibernate.connection.password
hibernate.connection.url jdbc:hsqldb:./build/db/hsqldb/hibernate
#hibernate.connection.url jdbc:hsqldb:hsql://localhost
#hibernate.connection.url jdbc:hsqldb:test

## H2 (www.h2database.com)
#hibernate.dialect org.hibernate.dialect.H2Dialect
#hibernate.connection.driver_class org.h2.Driver
#hibernate.connection.username sa
#hibernate.connection.password
#hibernate.connection.url jdbc:h2:mem:./build/db/h2/hibernate
#hibernate.connection.url jdbc:h2:testdb/h2test
#hibernate.connection.url jdbc:h2:mem:imdb1
#hibernate.connection.url jdbc:h2:tcp://dbserv:8084/sample;
#hibernate.connection.url jdbc:h2:ssl://secureserv:8085/sample;
#hibernate.connection.url jdbc:h2:ssl://secureserv/testdb;cipher=AES

## MySQL

#hibernate.dialect org.hibernate.dialect.MySQLDialect
#hibernate.dialect org.hibernate.dialect.MySQLInnoDBDialect
#hibernate.dialect org.hibernate.dialect.MySQLMyISAMDialect
#hibernate.connection.driver_class com.mysql.jdbc.Driver
#hibernate.connection.url jdbc:mysql:///test
#hibernate.connection.username gavin
#hibernate.connection.password

## Oracle

#hibernate.dialect org.hibernate.dialect.Oracle8iDialect
#hibernate.dialect org.hibernate.dialect.Oracle9iDialect
#hibernate.dialect org.hibernate.dialect.Oracle10gDialect
#hibernate.connection.driver_class oracle.jdbc.driver.OracleDriver
#hibernate.connection.username ora
#hibernate.connection.password ora
#hibernate.connection.url jdbc:oracle:thin:@localhost:1521:orcl
#hibernate.connection.url jdbc:oracle:thin:@localhost:1522:XE

## PostgreSQL

#hibernate.dialect org.hibernate.dialect.PostgreSQLDialect
#hibernate.connection.driver_class org.postgresql.Driver
#hibernate.connection.url jdbc:postgresql:template1
#hibernate.connection.username pg
#hibernate.connection.password

## DB2

#hibernate.dialect org.hibernate.dialect.DB2Dialect
#hibernate.connection.driver_class com.ibm.db2.jcc.DB2Driver
#hibernate.connection.driver_class COM.ibm.db2.jdbc.app.DB2Driver
#hibernate.connection.url jdbc:db2://localhost:50000/somename
#hibernate.connection.url jdbc:db2:somename
#hibernate.connection.username db2
#hibernate.connection.password db2

## TimesTen

#hibernate.dialect org.hibernate.dialect.TimesTenDialect
#hibernate.connection.driver_class com.timesten.jdbc.TimesTenDriver
#hibernate.connection.url jdbc:timesten:direct:test
#hibernate.connection.username
#hibernate.connection.password

## DB2/400

#hibernate.dialect org.hibernate.dialect.DB2400Dialect
#hibernate.connection.username user
#hibernate.connection.password password

## Native driver
#hibernate.connection.driver_class COM.ibm.db2.jdbc.app.DB2Driver
#hibernate.connection.url jdbc:db2://systemname

## Toolbox driver
#hibernate.connection.driver_class com.ibm.as400.access.AS400JDBCDriver
#hibernate.connection.url jdbc:as400://systemname

## Derby (not supported!)

#hibernate.dialect org.hibernate.dialect.DerbyDialect
#hibernate.connection.driver_class org.apache.derby.jdbc.EmbeddedDriver
#hibernate.connection.username
#hibernate.connection.password
#hibernate.connection.url jdbc:derby:build/db/derby/hibernate;create=true

## Sybase

#hibernate.dialect org.hibernate.dialect.SybaseDialect
#hibernate.connection.driver_class com.sybase.jdbc2.jdbc.SybDriver
#hibernate.connection.username sa
#hibernate.connection.password sasasa
#hibernate.connection.url jdbc:sybase:Tds:co3061835-a:5000/tempdb

## Mckoi SQL

#hibernate.dialect org.hibernate.dialect.MckoiDialect
#hibernate.connection.driver_class com.mckoi.JDBCDriver
#hibernate.connection.url jdbc:mckoi:///
#hibernate.connection.url jdbc:mckoi:local://C:/mckoi1.0.3/db.conf
#hibernate.connection.username admin
#hibernate.connection.password nimda

## SAP DB

#hibernate.dialect org.hibernate.dialect.SAPDBDialect
#hibernate.connection.driver_class com.sap.dbtech.jdbc.DriverSapDB
#hibernate.connection.url jdbc:sapdb://localhost/TST
#hibernate.connection.username TEST
#hibernate.connection.password TEST
#hibernate.query.substitutions yes 'Y', no 'N'

## MS SQL Server

#hibernate.dialect org.hibernate.dialect.SQLServerDialect
#hibernate.connection.username sa
#hibernate.connection.password sa

## JSQL Driver
#hibernate.connection.driver_class com.jnetdirect.jsql.JSQLDriver
#hibernate.connection.url jdbc:JSQLConnect://1E1/test

## JTURBO Driver
#hibernate.connection.driver_class com.newatlanta.jturbo.driver.Driver
#hibernate.connection.url jdbc:JTurbo://1E1:1433/test

## WebLogic Driver
#hibernate.connection.driver_class weblogic.jdbc.mssqlserver4.Driver
#hibernate.connection.url jdbc:weblogic:mssqlserver4:1E1:1433

## Microsoft Driver (not recommended!)
#hibernate.connection.driver_class com.microsoft.jdbc.sqlserver.SQLServerDriver
#hibernate.connection.url jdbc:microsoft:sqlserver://1E1;DatabaseName=test;SelectMethod=cursor

## The New Microsoft Driver
#hibernate.connection.driver_class com.microsoft.sqlserver.jdbc.SQLServerDriver
#hibernate.connection.url jdbc:sqlserver://localhost

## jTDS (since version 0.9)
#hibernate.connection.driver_class net.sourceforge.jtds.jdbc.Driver
#hibernate.connection.url jdbc:jtds:sqlserver://1E1/test

## Interbase

#hibernate.dialect org.hibernate.dialect.InterbaseDialect
#hibernate.connection.username sysdba
#hibernate.connection.password masterkey

## DO NOT specify hibernate.connection.sqlDialect

## InterClient

#hibernate.connection.driver_class interbase.interclient.Driver
#hibernate.connection.url jdbc:interbase://localhost:3060/C:/firebird/test.gdb

## Pure Java

#hibernate.connection.driver_class org.firebirdsql.jdbc.FBDriver
#hibernate.connection.url jdbc:firebirdsql:localhost/3050:/firebird/test.gdb

## Pointbase

#hibernate.dialect org.hibernate.dialect.PointbaseDialect
#hibernate.connection.driver_class com.pointbase.jdbc.jdbcUniversalDriver
#hibernate.connection.url jdbc:pointbase:embedded:sample
#hibernate.connection.username PBPUBLIC
#hibernate.connection.password PBPUBLIC

## Ingres

## older versions (before Ingress 2006)

#hibernate.dialect org.hibernate.dialect.IngresDialect
#hibernate.connection.driver_class ca.edbc.jdbc.EdbcDriver
#hibernate.connection.url jdbc:edbc://localhost:II7/database
#hibernate.connection.username user
#hibernate.connection.password password

## Ingres 2006 or later

#hibernate.dialect org.hibernate.dialect.IngresDialect
#hibernate.connection.driver_class com.ingres.jdbc.IngresDriver
#hibernate.connection.url jdbc:ingres://localhost:II7/database;CURSOR=READONLY;auto=multi
#hibernate.connection.username user
#hibernate.connection.password password

## Mimer SQL

#hibernate.dialect org.hibernate.dialect.MimerSQLDialect
#hibernate.connection.driver_class com.mimer.jdbc.Driver
#hibernate.connection.url jdbc:mimer:multi1
#hibernate.connection.username hibernate
#hibernate.connection.password hibernate

## InterSystems Cache

#hibernate.dialect org.hibernate.dialect.Cache71Dialect
#hibernate.connection.driver_class com.intersys.jdbc.CacheDriver
#hibernate.connection.username _SYSTEM
#hibernate.connection.password SYS
#hibernate.connection.url jdbc:Cache://127.0.0.1:1972/HIBERNATE

#################################
### Hibernate Connection Pool ###
#################################

hibernate.connection.pool_size 1

###########################
### C3P0 Connection Pool###
###########################

#hibernate.c3p0.max_size 2
#hibernate.c3p0.min_size 2
#hibernate.c3p0.timeout 5000
#hibernate.c3p0.max_statements 100
#hibernate.c3p0.idle_test_period 3000
#hibernate.c3p0.acquire_increment 2
#hibernate.c3p0.validate false

##############################
### Proxool Connection Pool###
##############################

## Properties for external configuration of Proxool

hibernate.proxool.pool_alias pool1

## Only need one of the following

#hibernate.proxool.existing_pool true
#hibernate.proxool.xml proxool.xml
#hibernate.proxool.properties proxool.properties

#################################
### Plugin ConnectionProvider ###
#################################

## use a custom ConnectionProvider (if not set, Hibernate will choose a built-in ConnectionProvider using hueristics)

#hibernate.connection.provider_class org.hibernate.connection.DriverManagerConnectionProvider
#hibernate.connection.provider_class org.hibernate.connection.DatasourceConnectionProvider
#hibernate.connection.provider_class org.hibernate.connection.C3P0ConnectionProvider
#hibernate.connection.provider_class org.hibernate.connection.ProxoolConnectionProvider

#######################
### Transaction API ###
#######################

## Enable automatic flush during the JTA beforeCompletion() callback
## (This setting is relevant with or without the Transaction API)

#hibernate.transaction.flush_before_completion

## Enable automatic session close at the end of transaction
## (This setting is relevant with or without the Transaction API)

#hibernate.transaction.auto_close_session

## the Transaction API abstracts application code from the underlying JTA or JDBC transactions

#hibernate.transaction.factory_class org.hibernate.transaction.JTATransactionFactory
#hibernate.transaction.factory_class org.hibernate.transaction.JDBCTransactionFactory

## to use JTATransactionFactory, Hibernate must be able to locate the UserTransaction in JNDI
## default is java:comp/UserTransaction
## you do NOT need this setting if you specify hibernate.transaction.manager_lookup_class

#jta.UserTransaction jta/usertransaction
#jta.UserTransaction javax.transaction.UserTransaction
#jta.UserTransaction UserTransaction

## to use the second-level cache with JTA, Hibernate must be able to obtain the JTA TransactionManager

#hibernate.transaction.manager_lookup_class org.hibernate.transaction.JBossTransactionManagerLookup
#hibernate.transaction.manager_lookup_class org.hibernate.transaction.WeblogicTransactionManagerLookup
#hibernate.transaction.manager_lookup_class org.hibernate.transaction.WebSphereTransactionManagerLookup
#hibernate.transaction.manager_lookup_class org.hibernate.transaction.OrionTransactionManagerLookup
#hibernate.transaction.manager_lookup_class org.hibernate.transaction.ResinTransactionManagerLookup

##############################
### Miscellaneous Settings ###
##############################

## print all generated SQL to the console

#hibernate.show_sql true

## format SQL in log and console

hibernate.format_sql true

## add comments to the generated SQL

#hibernate.use_sql_comments true

## generate statistics

#hibernate.generate_statistics true

## auto schema export

#hibernate.hbm2ddl.auto create-drop
#hibernate.hbm2ddl.auto create
#hibernate.hbm2ddl.auto update
#hibernate.hbm2ddl.auto validate

## specify a default schema and catalog for unqualified tablenames

#hibernate.default_schema test
#hibernate.default_catalog test

## enable ordering of SQL UPDATEs by primary key

#hibernate.order_updates true

## set the maximum depth of the outer join fetch tree

hibernate.max_fetch_depth 1

## set the default batch size for batch fetching

#hibernate.default_batch_fetch_size 8

## rollback generated identifier values of deleted entities to default values

#hibernate.use_identifer_rollback true

## enable bytecode reflection optimizer (disabled by default)

#hibernate.bytecode.use_reflection_optimizer true

#####################
### JDBC Settings ###
#####################

## specify a JDBC isolation level

#hibernate.connection.isolation 4

## enable JDBC autocommit (not recommended!)

#hibernate.connection.autocommit true

## set the JDBC fetch size

#hibernate.jdbc.fetch_size 25

## set the maximum JDBC 2 batch size (a nonzero value enables batching)

#hibernate.jdbc.batch_size 5
#hibernate.jdbc.batch_size 0

## enable batch updates even for versioned data

hibernate.jdbc.batch_versioned_data true

## enable use of JDBC 2 scrollable ResultSets (specifying a Dialect will cause Hibernate to use a sensible default)

#hibernate.jdbc.use_scrollable_resultset true

## use streams when writing binary types to / from JDBC

hibernate.jdbc.use_streams_for_binary true

## use JDBC 3 PreparedStatement.getGeneratedKeys() to get the identifier of an inserted row

#hibernate.jdbc.use_get_generated_keys false

## choose a custom JDBC batcher

# hibernate.jdbc.factory_class

## enable JDBC result set column alias caching
## (minor performance enhancement for broken JDBC drivers)

# hibernate.jdbc.wrap_result_sets

## choose a custom SQL exception converter

#hibernate.jdbc.sql_exception_converter

##########################
### Second-level Cache ###
##########################

## optimize chache for minimal "puts" instead of minimal "gets" (good for clustered cache)

#hibernate.cache.use_minimal_puts true

## set a prefix for cache region names

hibernate.cache.region_prefix hibernate.test

## disable the second-level cache

#hibernate.cache.use_second_level_cache false

## enable the query cache

#hibernate.cache.use_query_cache true

## store the second-level cache entries in a more human-friendly format

#hibernate.cache.use_structured_entries true

## choose a cache implementation

#hibernate.cache.provider_class org.hibernate.cache.EhCacheProvider
#hibernate.cache.provider_class org.hibernate.cache.EmptyCacheProvider
hibernate.cache.provider_class org.hibernate.cache.HashtableCacheProvider
#hibernate.cache.provider_class org.hibernate.cache.TreeCacheProvider
#hibernate.cache.provider_class org.hibernate.cache.OSCacheProvider
#hibernate.cache.provider_class org.hibernate.cache.SwarmCacheProvider

## choose a custom query cache implementation

#hibernate.cache.query_cache_factory

############
### JNDI ###
############

## specify a JNDI name for the SessionFactory

#hibernate.session_factory_name hibernate/session_factory

## Hibernate uses JNDI to bind a name to a SessionFactory and to look up the JTA UserTransaction;
## if hibernate.jndi.* are not specified, Hibernate will use the default InitialContext() which
## is the best approach in an application server

#file system
#hibernate.jndi.class com.sun.jndi.fscontext.RefFSContextFactory
#hibernate.jndi.url file:/

#WebSphere
#hibernate.jndi.class com.ibm.websphere.naming.WsnInitialContextFactory
#hibernate.jndi.url iiop://localhost:900/

seal 2010-02-09 11:05 发表评论

ORA-12519, TNS:no appropriate service handler found(�?

seal — Wed, 03 Feb 2010 01:02:00 GMT

遇到�q�种错误�Q�一般是因�ؓ�q�发�q�大引�v的�?/p>

查询解决�Ҏ��:

查看一下数据库现有的进�E�数�Q�是否已�l�达到参数processes的大��?/p>

1.select count(*) from v$process; 取得数据库目前的�q�程数�?br /> 2.select value from v$parameter where name = 'processes'; 取得�q�程数的上限�?br /> 3.如已辑ֈ�上限�Q�修改initSID.ora中的processes的大��?br /> 4.重新启动数据库到nomount状态下�Q�执行create spfile from pfile; �q�startup open�?/p>

查询数据库自启动以来最大的�q�发数量

select * from v$license

seal 2010-02-03 09:02 发表评论

Hibernate报错org.hibernate.LazyInitializationException: illegal access to loading collection

seal — Thu, 21 Jan 2010 12:36:00 GMT

org.hibernate.LazyInitializationException: illegal access to loading collection
at org.hibernate.collection.AbstractPersistentCollection.initialize(AbstractPersistentCollection.java:341)
at org.hibernate.collection.AbstractPersistentCollection.read(AbstractPersistentCollection.java:86)

原因在与pojo里面�? public int hashCode() {... } �Ҏ��调用了set对象成员的hashCode()�Ҏ��
如this.getSets().hashCode();
删除该方法的调用卛_��Q�调用非set对象成员�?hashCode()�Ҏ��没有问题�?

seal 2010-01-21 20:36 发表评论

seal — Thu, 21 Jan 2010 05:57:00 GMT

摘要: 一、JPA通用�{�略生成�? 通过annotation来映��hibernate实体�?��Z��annotation的hibernate主键标识为@Id, 其生成规则由@GeneratedValue讑֮��?�q�里的@id和@GeneratedValue都是JPA的标准用�? JPA提供四种标准用法,由@GeneratedValue的源代码可以明显看出. Java代码 ... 阅读全文

seal 2010-01-21 13:57 发表评论

OpenSessionInViewFilter 的两个异�?Illegal attempt to associate a collection with two open sessions; Write operations are not allowed in read-only mode (FlushMode.NEVER/MANUAL)

seal — Thu, 29 Oct 2009 14:23:00 GMT

使用 Spring 整合 Hibernate, 在懒加蝲的情况下, 有时候需要在 JSP/View 层显�C�数�? �q�时候就要用到Spring内置�? OpenSessionInViewFilter, 一般来说配�|�如�?web.xml):

<filter>

<filter-name>hibernateFilterfilter-name>

<filter-class>

org.springframework.orm.hibernate3.support.OpenSessionInViewFilter

    filter-class>

<init-param>

<param-name>singleSessionparam-name>

        <param-value>trueparam-value>

init-param>

 filter>

<filter-mapping><filter-name>hibernateFilterfilter-name><url-pattern>*.dourl-pattern>-- *.jsp, *.do-->filter-mapping>

不过, �q�时候又会导致更新数据时抛出如下异常:

Write operations are not allowed in read-only mode (FlushMode.NEVER/MANUAL): Turn your Session into FlushMode.COMMIT/AUTO or remove 'readOnly' marker from transaction definition.

�q�时候再�ȝ��上找解决�Ҏ��, 会有��: 把参�?singleSession改�ؓfalse, ��p��? 不过, 改完�? 估计不久��׃��遇到另一个郁��L��异常:

org.hibernate.HibernateException: Illegal attempt to associate a collection with two open sessions

�q�下完了, 两个�Ҏ��都不�? 到底怎么�? �q�好, �?a title="http://xuliangyong.javaeye.com/blog/144818" >http://xuliangyong.javaeye.com/blog/144818的主��上, �l�了一个方�? ��是改写 OpenSessionInViewFilter 的代�? 非常感谢, 下面�l�出的就是最�l�方�?

web.xml

< filter-name >hibernateFilterfilter-name>

< filter-class > org.springframework.orm.hibernate3.support.OurOpenSessionInViewFilter filter-class>

OurOpenSessionInViewFilter.java 代码:

package org.springframework.orm.hibernate3.support;







import org.hibernate.*;







/** * 单session模式�? 默认会发生无法提交的错误: * Write operations are not allowed in read-only mode (FlushMode.NEVER/MANUAL): Turn your Session into FlushMode.COMMIT/AUTO or remove 'readOnly' marker from transaction definition. * 需要设�|�FlushMode�q�刷新session. * 参�? http://xuliangyong.javaeye.com/blog/144818 * @author 刘长�?/span> */publicclass OurOpenSessionInViewFilter extends OpenSessionInViewFilter {







public OurOpenSessionInViewFilter() {



super.setFlushMode(FlushMode.AUTO);



}







protectedvoid closeSession(Session session, SessionFactory sessionFactory) {



session.flush();







try {



session.getTransaction().commit();



} catch (HibernateException e) {



// TODO Auto-generated catch block//e.printStackTrace();



}







super.closeSession(session, sessionFactory); 



} 



}

如果各位有更好的解决�Ҏ��, �Ƣ迎讨论�?!!

题外�?

感觉 Spring + Hibernate 的健壮性还是不够啊! �Ҏ��抛异�? �q�是事实, 也许�q�是开源��Y件的通病�?

seal 2009-10-29 22:23 发表评论

seal — Thu, 27 Aug 2009 08:56:00 GMT

About a year and an half ago I wrote an entry about the problem that rises when mapping an entity with multiple bags using eager fetching. At the end of the entry I suggested three different solutions: (a) to use lazy fetching, (b) to use sets instead of bags, and (c) to use the @IndexColumn annotation. Few months later I elaborated on the usage of @IndexColumn, this time another way – using the @CollectionId annotation.

Environment

· Hibernate Entity Manager – 3.3.1.GA

· Hibernate core – 3.2.5.GA

· Hibernate annotations- 3.3.0.GA

· Database – PostgreSQL 8.1

First one, first…

Just before we start a warning – the @CollectionId annotation is a Hibernate specific annotation – not a part of the specification. And it doesn't work on one-to-many associations (but it can be used in conjunction with one-to-many associations). After putting that behind of us lets see the problem.

The Problem

Assume the following entities relation, a parent entity has two collections of child entities. Both collections should be eagerly loaded.

First try will be to just to map it as is (Child1 has a many-to-many association; Child2 has a one-to-many):

@ManyToMany( fetch = FetchType.EAGER, cascade=CascadeType.ALL)

@JoinTable(name = "PARENT_CHILD1",

joinColumns = @JoinColumn(name = "PARENT_ID", referencedColumnName = "ID"),

inverseJoinColumns = @JoinColumn(name = "CHILD1_ID", referencedColumnName = "ID"))

List child1s = new LinkedList();

@OneToMany(mappedBy = "parent", cascade = CascadeType.ALL, fetch = FetchType.EAGER)

List child2s = new LinkedList();

But when loading a persistence unit with the above configuration the "org.hibernate.HibernateException: cannot simultaneously fetch multiple bags" will be thrown.

Using an idbag

The reason is that when we add the @CollectionId to a List or a Collection its semantics changes from "just a bag" to "a bag with primary key" (a.k.a, idbag). It means that a surrogate key is assigned to each row on the collection

When transforming the association to Child1 into an idbag (using the @CollectionId annotation) the problem is solved. The reason is that when we switch the association semantics from "a simple bag" to "a bag with primary key" (a.k.a, idbag) it means that a surrogate key is assigned to each row on the collection.

@Entity

public class Parent {

………

@ManyToMany( fetch = FetchType.EAGER, cascade=CascadeType.ALL)

@JoinTable(name = "PARENT_CHILD1",

joinColumns = @JoinColumn(name = "PARENT_ID", referencedColumnName = "ID"),

inverseJoinColumns = @JoinColumn(name = "CHILD1_ID", referencedColumnName = "ID"))

@GenericGenerator(name="uuid-gen", strategy = "uuid")

@CollectionId(columns = @Column(name = "COL_ID"), type = @Type(type = "string"), generator = "uuid-gen")List child1s = new LinkedList();

@OneToMany(mappedBy = "parent", cascade = CascadeType.ALL, fetch = FetchType.EAGER)

List child2s = new LinkedList();

The problem with bags is that when Hibernate eagerly loads multiple collections it issues an outer join select to the RDBMS which can cause multiple entries on some of the collections. But when using an idbag each row in the collections is uniquely identified by the surrogate key, therefore Hibernate can identify it within the collection, even if the SQL statement returns an entry more than once.

Notice the usage of a generator assigned to the collection id, the generator is responsible for creating the surrogate keys of the collection rows. I decided to use the UUID strategy. You can, of course, use JPA standard generators (such as Sequence or Table generators). The @CollectionId references the COL_ID column on PARENT_CHILD1 table (the join table). The value of the collection id is invisible to the application (it is not being mapped to a property).

So why not on one-to-many

The Hibernate annotations documentation says that to announce idbag semantics you should assign the @CollectionId to a @ManyToMany, @CollectionOfElements, or @OneToMany (look at the table on this section), but the Hibernate core documentation it says "Hibernate provides a feature that allows you to map many to many associations and collections of values to a table with a surrogate key." (here). I've tried it and indeed when annotating a @OneToMany collection with the @CollectionId an exception with the message "one-to-many collections with identifiers are not supported " is thrown by Hibernate.

Idbag - Not Just For Eager Fetching

Don't forge that you can use idbag for reasons other than solving multiple eager associations. For example it can give a major performance boost over simple bags for mutative operations. If entries in a collection have surrogate keys Hibernate will be able to locate the matching rows in the database using these keys (each row in the association table becomes unique) – there is no need for the fetch -> delete-all -> insert-all cycle when updating the collection.

Posted at 03:49PM Jan 18, 2008 by Eyal Lupu in Persistence | Comments[6]

Comments:

Actually a @OneToMany @JoinTable would work (as opposed to @OneToMany @JoinColumn)

Posted by Emmanuel Bernard on January 21, 2008 at 09:33 PM GMT+02:00 #

Thanks Emmanuel,

Maybe it worth a comment in the documentation. I guess this is actually an Hibernate core's issue (not an Hibernate annotation one - is it?).

Posted by Eyal Lupu on January 21, 2008 at 11:56 PM GMT+02:00 #

So, if I have 2 parallel OneToMany collections it's not fixable with:

@OneToMany @CollectionId
List getSons() {...}

@OneToMany @CollectionId
List getDaughter() {...}

But if they were ManyToMany collections it is fixable?

Strange :) Any particular reason?

Posted by Geoffrey De Smet on January 23, 2008 at 11:11 AM GMT+02:00 #

Hi Geoffrey,
Yes - you have understood it correctly.

I guess the reason is that regular one-to-many associations have a foreign key on the child record and there is no place to store the collection id there.

However, see Emmanuel comment above - you can solve it using a join table.

Posted by Eyal Lupu on January 23, 2008 at 11:59 AM GMT+02:00 #

Year the documentation should be clearer.

Posted by Emmanuel Bernard on January 23, 2008 at 04:48 PM GMT+02:00 #

There is fourth solution of this problem. Works for both @OneToMany and @ManyToMany:

@OneToMany(mappedBy="account", cascade=CascadeType.ALL)
@LazyCollection(LazyCollectionOption.FALSE)
private List entries;

Annotation @LazyCollection(LazyCollectionOption.FALSE) makes that collecion is loaded like with FetchType.EAGER and you can use it on two and more collections.
This solution is (in my opinion) better because it's simplier. :)

Posted by Bartosz Jakubowski on October 22, 2008 at 01:26 PM GMT+02:00 #

seal 2009-08-27 16:56 发表评论

seal — Wed, 19 Aug 2009 03:00:00 GMT

get和load方式是根据id取得一个记�?

下边详细说一下get和load的不同，因�ؓ有些时候�ؓ了对比也会把find加进来�?

1.从返回结果上�Ҏ��Q?

load方式��索不到的话会抛出org.hibernate.ObjectNotFoundException异常

get�Ҏ��索不到的话会�q�回null

2.从检索执行机制上�Ҏ��Q?

get�Ҏ��和find�Ҏ��都是直接从数据库中检�?

而load�Ҏ��的执行则比较复杂

�?首先查找session的persistent Context中是否有�~�存�Q�如果有则直接返�?

�?如果没有则判断是否是lazy�Q�如果不是直接访问数据库��索，查到记录�q�回�Q�查不到抛出异常

�?如果是lazy则需要徏立代理对象，对象的initialized属性�ؓfalse�Q�target属性�ؓnull

�?在访问获得的代理对象的属性时,��索数据库�Q�如果找到记录则把该记录的对象复制到代理对象的target上，�q�将initialized=true�Q�如果找不到��抛出异�?�?

3.�Ҏ��区别说明

�? 如果你��用load�Ҏ��Q�hibernate认�ؓ该id对应的对象（数据库记录）在数据库中是一定存在的�Q�所以它可以攑ֿ�的��用，它可以放心的使用代理�? 延迟加蝲该对象。在用到对象中的其他属性数据时才查询数据库�Q�但是万一数据库中不存在该记录�Q�那没办法，只能抛异常。所说的load�Ҏ��抛异常是指在使用该对象的数据�Ӟ��数据库中不存在该数据时抛异常�Q�而不是在创徏�q�个对象�?注意�Q�这��是�׃��“延迟加蝲”在作�?�?

�׃��session中的�~�存对于hibernate来说是个相当廉�h的资源，所以在load时会先查一下session�~�存看看该id对应的对象是否存在，不存在则创徏代理。所以如果你知道该id在数据库中一定有对应记录存在��可以��用load�Ҏ��来实现�g�q�加载�?

�?对于get�Ҏ��Q�hibernate会确认一下该id对应的数据是否存在，首先在session�~�存中查找，然后在二�U�缓存中查找�Q�还没有��查数据库，数据库中没有��p��回null�?

对于load和get�Ҏ��q�回�c�d��Q�虽然好多书中都�q�么��_��“get()永远只返回实�? �c?#8221;�Q�但实际上这是不正确的，get�Ҏ��如果�? session�~�存中找��C��该id对应的对象，如果刚好该对象前面是被代理过的，如被load�Ҏ��使用�q�，或者被其他兌��对象延迟加蝲�q�，那么�q�回的还�? 原先的代理对象，而不是实体类对象�Q�如果该代理对象�q�没有加载实体数据（��是id以外的其他属性数据）�Q�那么它会查询二�U�缓存或者数据库来加载数据，但是 �q�回的还是代理对象，只不�q�已�l�加载了实体数据�?

get�Ҏ��首先查询session�~�存�Q�没有的话查询二�U�缓存，最后查询数据库�Q�反而load�Ҏ��创徏旉��先查询session�~�存�Q�没有就创徏代理�Q�实际��用数据时才查询二�U�缓存和数据库�?

4.��单�ȝ��

��M��对于get和load的根本区别，一句话�Q�hibernate对于load�Ҏ��认�ؓ该数据在数据库中一定存在，可以攑ֿ�的��用代理来延迟加蝲�Q�如果在使用�q�程中发��C��问题�Q�只能抛异常�Q�而对于get�Ҏ��Q�hibernate一定要获取到真实的数据�Q�否则返回null�?/p>

文章出处�Q?a >http://www.diybl.com/course/3_program/java/javajs/2008531/118292.html

hibernate的各�U�保存方式的�?save,persist,update,saveOrUpdte,merge,flush,lock)�?对象的三�U�状�?/p>

hibernate的保�?/p>

hibernate对于对象的保存提供了太多的方法，他们之间有很多不同，�q�里�l�说一下，以便区别�?/p>

一、预备知�?/p>

对于hibernate�Q�它的对象有三种状态，transient、persistent、detached

下边是常见的��译办法�Q?/p>

transient�Q�瞬态或者自由�?/p>

(new DeptPo(1,”行政�?#8221;,20,”行政相关”)�Q�该po的实例和session没有兌��Q�该po的实例处于transient)

persistent�Q�持久化状�?/p>

(和数据库中记录想影射的Po实例�Q�它的状态是persistent, 通过get和load�{�得到的对象都是persistent)

detached�Q�脱��状态或者游��L�?/p>

(1)当通过get或load�Ҏ��得到的po对象它们都处于persistent,但如果执行delete(po)�?但不能执行事�?,该po状态就处于detached, (表示和session��q��兌��),因delete而变成游��L��可以通过save或saveOrUpdate()变成持久�?/p>

(2)当把session关闭�Ӟ��session�~�存中的persistent的po对象也变成detached

因关闭session而变成游��L��的可以通过lock、save、update变成持久�?/p>

持久态实例可以通过调用 delete()变成��q��状态�?/p>

通过get()或load()�Ҏ��得到的实例都是持久化状态的�?/p>

��q��状态的实例可以通过调用lock()或者replicate()�q�行持久化�?/p>

save()和persist()��会引发SQL的INSERT�Q�delete()会引发SQLDELETE�Q?/p>

而update()或merge()会引发SQL UPDATE。对持久化（persistent�Q�实例的修改在刷新提交的时候会被检��到�Q�它也会引�vSQL UPDATE�?/p>

saveOrUpdate()或者replicate()会引发SQLINSERT或者UPDATE

二、save 和update区别

把这一�Ҏ��在第一位的原因是因��一�Ҏ��最常用的�?/p>

save的作用是把一个新的对象保�?/p>

update是把一个脱��状态的对象或自由态对象（一定要和一个记录对应）更新到数据库

三、update 和saveOrUpdate区别

�q�个是比较好理解的，��֐�思义�Q�saveOrUpdate基本上就是合成了save和update,而update只是update;引用hibernate reference中的一�D�话来解释他们的使用场合和区�?/p>

通常下面的场景会使用update()或saveOrUpdate()�Q?

�E�序在第一个session中加载对�?接着把session关闭

该对象被传递到表现�?

对象发生了一些改�?

该对象被�q�回��C��务逻辑层最�l�到持久�?

�E�序创徏�W�二session调用�W�二个session的update()�Ҏ��持久�q�些改动

saveOrUpdate(po)做下面的�?

如果该po对象已经在本session中持久化了，在本session中执行saveOrUpdate不做��M��?

如果savaOrUpdate(新po)与另一个与本session兌��的po对象拥有相同的持久化标识(identifier)�Q�抛��Z��个异�?

org.hibernate.NonUniqueObjectException: a different object with the same identifier value was already associated with the session: [org.itfuture.www.po.Xtyhb#5]

saveOrUpdate如果对象没有持久化标�?identifier)属性，对其调用save() �Q�否则update() �q�个对象

四、persist和save区别

�q�个是最�q�L��的一对，表面上看��h��使用哪个都行�Q�在hibernate reference文档中也没有明确的区分他�?

�q�里�l�出一个明��的区分。（可以跟进src看一下，虽然实现步骤�c�M��Q�但是还是有�l�微的差别）

主要内容区别�Q?/p>

1�Q�persist把一个瞬态的实例持久化，但是�q?不保�?标识�W?identifier主键对应的属�?被立��d��入到持久化实例中�Q�标识符的填入可能被推迟到flush的时候�?/p>

2�Q�save, 把一个瞬态的实例持久化标识符�Q�及时的产生,它要�q�回标识�W�，所以它会立��x��行Sql insert

五、saveOrUpdate,merge和update区别

比较update和merge

update的作用上边说了，�q�里说一下merge�?/p>

如果session中存在相同持久化标识(identifier)的实例，用用��L��出的对象覆盖session已有的持久实�?

(1)当我们��用update的时候，执行完成后，会抛出异�?

(2)但当我们使用merge的时候，把处理自由态的po对象A的属性copy到session当中处于持久态的po的属性中�Q�执行完成后原来是持久状态还是持久态，而我们提供的A�q�是自由�?/p>

六、flush和update区别

�q�两个的区别好理�?/p>

update操作的是在自由态或��q��状�?因session的关闭而处于脱��状�?的对�?/updateSQL

而flush是操作的在持久状态的对象�?/p>

默认情况下，一个持久状态的对象的改动（包含set容器�Q�是不需要update的，只要你更改了对象的��|��{�待hibernate flush��p��动更新或保存到数据库了。hibernate flush发生在以下几�U�情况中�Q?/p>

1�Q?调用某些查询的和手动flush(),session的关闭、SessionFactory关闭�l�合

get()一个对象，把对象的属性进行改�?把资源关闭�?/p>

2�Q�transaction commit的时候（包含了flush�Q?/p>

七、lock和update区别

update是把一个已�l�更改过的脱��状态的对象变成持久状�?/p>

lock是把一个没有更改过的脱��状态的对象变成持久状�?针对的是因Session的关闭而处于脱��状态的po对象(2)�Q�不能针对因delete而处于脱��状态的po对象)

对应更改一个记录的内容�Q�两个的操作不同�Q?/p>

update的操作步骤是�Q?/p>

(1)属性改动后的脱��的对象的修�?>调用update

lock的操作步骤是�Q?/p>

(2)调用lock把未修改的对象从��q��状态变成持久状�?->更改持久状态的对象的内�?->�{�待flush或者手动flush

八、clear和evcit的区�?/p>

clear完整的清除session�~�存

evcit(obj)把某个持久化对象从session的缓存中清空�?/p>

seal 2009-08-19 11:00 发表评论

EJB3.0中关于Jpa的复合主键（转）

seal — Wed, 19 Aug 2009 00:23:00 GMT

当我们需要��用一个或多个属性变量（表中的一列或多列�Q�联合�v来作��Z��键，我们需要��用复合主键。在EJB3.0中复合主键要求我们编写一个复合主键类( Composite Primary Key Class )。下面是个小例子�Q�在Student中要用sid和name做复合主键�?br /> Student实体�c�：

1 import javax.persistence.Column;
2 import javax.persistence.Entity;
3 import javax.persistence.Id;
4 import javax.persistence.IdClass;
5
6 @Entity
7 @IdClass(StudentPK.class)
8 public class Student {
9
10     private String sid;
11     private String name;
12     private String age;
13
14     @Id
15     public String getSid() {
16         return sid;
17     }
18     public void setSid(String sid) {
19         this.sid = sid;
20     }
21
22     @Id
23     public String getName() {
24         return name;
25     }
26     public void setName(String name) {
27         this.name = name;
28     }
29
30     @Column
31     public String getAge() {
32         return age;
33     }
34     public void setAge(String age) {
35         this.age = age;
36     }
37
38 }

主键StudentPK�c�：

1 import java.io.Serializable;
2
3 public class StudentPK implements Serializable{
4
5     private static final long serialVersionUID = 1L;
6
7     private String sid;
8     private String name;
9
10     public StudentPK(){}
11     public StudentPK(String sid,String name){
12         this.sid = sid;
13         this.name = name;
14     }
15
16     public String getSid() {
17         return sid;
18     }
19     public void setSid(String sid) {
20         this.sid = sid;
21     }
22     public String getName() {
23         return name;
24     }
25     public void setName(String name) {
26         this.name = name;
27     }
28
29     @Override
30     public int hashCode() {
31         final int prime = 31;
32         int result = 1;
33         result = prime * result + ((name == null) ? 0 : name.hashCode());
34         result = prime * result + ((sid == null) ? 0 : sid.hashCode());
35         return result;
36     }
37
38     @Override
39     public boolean equals(Object obj) {
40         if (this == obj)
41             return true;
42         if (obj == null)
43             return false;
44         if (getClass() != obj.getClass())
45             return false;
46         final StudentPK other = (StudentPK) obj;
47         if (name == null) {
48             if (other.name != null)
49                 return false;
50         } else if (!name.equals(other.name))
51             return false;
52         if (sid == null) {
53             if (other.sid != null)
54                 return false;
55         } else if (!sid.equals(other.sid))
56             return false;
57         return true;
58     }
59
60 }

主键�c�d��需满��下列条�g�Q?br /> (1)必需被序列化
(2)必需有一个公��q��无参构造方�?br /> (3)必需实现equals()和hashCode()�Ҏ��

当你查询Student实体时必��M��用主键类才能识别实体�?

StudentPK pk = new StudentPK("bj1001","jakin");
Student student = entityManager.find(Student.class, pk);

在测试本例时�W�者犯了两个低�U�的错误�Q�一是测试环境的数据库不是项目运行的数据库，二是实体�c�M��的属性命名用了关键字�Q�请引以为戒�?

seal 2009-08-19 08:23 发表评论

seal — Tue, 30 Jun 2009 05:18:00 GMT

实体Entity中通过@Enumerated标注枚�D�c�d��Q�例如将CustomerEO实体中增加一�?/span>CustomerType�c�d��的枚丑֞�属性，标注实体后的代码如下所�C��?/span>

@Entity

@Table(name = "customer")

public class CustomerEO implements java.io.Serializable {

……

private CustomerType type;

@Enumerated(EnumType.STRING)

public CustomerType getType() {

return type;

}

public void setType(CustomerType type) {

this.type = type;

}

public enum CustomerType {

COMPETITOR, INVESTOR, PARTNER, VENDER

}

在实体中虽然标注成枚丄��型，但当实体持久化后�Q�表中所对应的��g��旧是基本的数据类型，以上代码创徏表的SQL语句是：

CREATE TABLE customer (

id int(20) NOT NULL auto_increment,

name varchar(255),

type varchar(255),

PRIMARY KEY (id)

)

使用枚�D�c�d��后，在创建实体时便可以直接引用枚丄��型，例如以下代码所�C��?/font>

CustomerEO customer = new CustomerEO();

customer.setName("Janet2");

customer.setType(CustomerType.PARTNER);

entityManager.persist(customer);

在��?/span>@Enumerated注释�Ӟ��需要注意以下几个问题：

l 因�ؓ枚�D�c�d��的有名称和��g��个属性，所以在持久化时可以选择持久化名�U�或是持久化倹{��通过EnumType来定义，它有两个值如下所�C��?/span>

public enum EnumType {

ORDINAL,

STRING

}

ORDINAL表示持久化的为枚丄��型的��|��STRING表示持久化的为枚丄��型的名称。默认�ؓORDINAL�Q�持久化倹{��例如以上示例中标注的�ؓSTRING�Q�这��h��久化实体后，数据库中保存的是枚�D�c�d��的名�U�ͼ�如图所�C��?/span>

若此时改�?/span>ORDINAL�Q�代码如下：

@Enumerated(EnumType.ORDINAL)

public CustomerType getType() {

return type;

}

则同��h��久化的实体后�Q�数据库保存的结果如�?/span>所�C��?/span>

l 如何选择STRING�?/span>ORDINAL�Q?/span>

如果使用STRING保存�Q�虽然从数据库中查询数据旉��常直观，能够清楚的看��c�d��代表意义�Q�但�q�样也会带来其他的问题。若此时枚�D�c�d��的定义改变，例如上例中的枚�D�c�d��名称改�ؓ�Q?/span>

public enum CustomerType {

CUST_COMPETITOR, INVESTOR, PARTNER, VENDER

}

则此时数据库中保存的“COMPETITOR”的值将不能转化为枚丄��?/span>CustomerType中的“CUST_COMPETITOR”的倹{��但若��?/span>ORDINAL则不会带来这�U�问题。所以徏议��?/span>ORDINAL�c�d��来持久化枚�D�c�d��?/span>

l 枚�D�c�d��的定义位�|�，实体外部VS实体内部�?/span>

上例�?/span>CustomerType枚�D�c�d��定义�?/span>CustomerEO实体内部�Q�这是因为只�?/span>CustomerEO�q�个实体会��?/span>CustomerType�c�d��Q�其他的实体不会使用该类型。该�c�d��与这个实体关�pȝ��密联�p�R�?/span>

但若此时多个实体公用一个枚丄��型时�Q�则可以��枚丄��型单独定义，定义在实体的外部。有�q�样一个枚丄��?/span>BusinessLine�Q�它定义在实体外部，代码如下�Q?/span>

public enum BusinessLine {

REAL_ESTATE,FINANCE, NON_PROFIT

}

例如CustomerEO实体增加一�?/span>BusinessLine的枚丄��型，代码如下所�C��?/span>

@Entity

@Table(name = "customer")

public class CustomerEO implements java.io.Serializable {

……

private BusinessLine businessLine;

@Enumerated(EnumType.STRING)

public BusinessLine getBusinessLine() {

return businessLine;

}

public void setBusinessLine(BusinessLine businessLine) {

this.businessLine = businessLine;

}

seal 2009-06-30 13:18 发表评论

org.hibernate.HibernateException: Found shared references to a collection

seal — Wed, 06 May 2009 02:45:00 GMT

BeanUtil.copyProperties()的方式复制一个实体bean的时候，如果�q�个实体bean有一个集合属性，因�ؓ�q�个�Ҏ��只是做了一个浅拯��Q�所以新拯��的实体跟旧的实体引用了同一个集合，而这在hibernate中是不允许的�Q�所以报错�?br /> 解决�Ҏ��Q?br /> 在拷贝后�Q�新��Z��个集合，��原来的集合元素��d��q�去�Q��ƈ赋值给新拷贝的实体�?br />

seal 2009-05-06 10:45 发表评论

Sorted collections in Hibernate

seal — Tue, 05 May 2009 07:09:00 GMT

Problem

We want a collection field belonging to an entity object to be sorted.

Solution

There are two possible solutions:

If you want the collection to be sorted when loaded, but not necessarily keep that sorting order all the time, use the OrderBy annotation where you set the actual ORDER BY SQL clause. In that case, the collection can be of any type (e.g. Collection).
If you want the collection to be sorted at all times, make it of type SortedSet or SortedMap and set the Sort annotation.
- If the objects in the collection implements Comparable set type to SortType.NATURAL.
- Otherwise set it to SortType.COMPARATOR and specify your own Comparator class in the comparator attribute.

Remarks

There exists an annotation with name OrderBy in both the javax.persistence package as well as the org.hibernate.annotations package. The former should be used.

seal 2009-05-05 15:09 发表评论

javax.persistence.PersistenceException: org.hibernate.MappingException: Cannot use identity column key generation with mapping for xxxxxxxxxxxxxxxx

seal — Mon, 09 Feb 2009 06:19:00 GMT

今天在将ejb3的工�E�部�|�到jboss启动时报错：
State: FAILED
Reason: javax.persistence.PersistenceException: org.hibernate.MappingException: Cannot use identity column key generation with mapping for: com.xxx.xxxx

后来发现问题所在：

�l�承�{�略我选择了@Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)�Q?br /> 同时在父�c�M��讄��了ID生成�{�略为：
@Id
   @GeneratedValue(strategy=GenerationType.IDENTITY)
   public Long getId() {
       return id;
   }
而在�q�种�{�略下��用unnion-subclass 元素�?父类的标识属性生成器不能使用“indentity” �Q�将�{�略改�ؓ @GeneratedValue(strategy=GenerationType.TABLE)
问题解决�?br />

seal 2009-02-09 14:19 发表评论

EJB/JPA�l�承详解(�?

seal — Mon, 05 Jan 2009 06:18:00 GMT

因�ؓ关系数据库的表之间不存在�l�承关系�Q�Entity 提供三种基本的��承映��策略：
每个�c�d��层结构一张表(table per class hierarchy)
每个子类一张表(table per subclass)
每个具体�c�M��张表(table per concrete class)

一、每个类分层�l�构一张表(table per class hierarchy)
       �q�种映射方式只需为基�c�d��Z��个表卛_��。在表中不仅提供基类所有属性对应的字段�Q�还要提供所有子�c�d��性对应的字段�Q�此外还需要一个字�D는�于区分子�cȝ��具体�c�d��
       要��用每个类分层�l�构一张表(table per class hierarchy) �{�略�Q�需要把@javax.persistence.Inheritance 注释�?font color="#0000ff">strategy属性设�|��ؓInheritanceType.SINGLE_TABLE。除非你要改变子�cȝ��映射�{�略�Q�否�?strong>@Inheritance 注释只能攑֜��l�承层次的基�c?/strong>。通过鉴别字段的��|��持久化引掣可以区分出各个�c�，�q�且知道每个�c�d��应那些字�D�c�?font color="#cc99ff">鉴别字段通过@javax.persistence.DiscriminatorColumn 注释�q�行定义�Q?font color="#0000ff">name 属性定�?font color="#cc99ff">鉴别字段的列�?/font>�Q?/font>discriminatorType 属性定�?font color="#cc99ff">鉴别字段的类�?/font>�Q�可选值有�Q�String, Char, Integer�Q�，如果鉴别字段的类型�ؓString 或Char�Q�可以用length 属性定义其长度�?font color="#ff0000">@DiscriminatorValue 注释为��承关�p�M��?font color="#cc99ff">每个�c�d��义鉴别�?/font>�Q�如果不指定鉴别��|��默认采用�c�d��
�?
    @SuppressWarnings("serial")
    @Entity
    @Table(name="Vehicle_Hierarchy")
    @Inheritance(strategy=InheritanceType.SINGLE_TABLE)
    @DiscriminatorColumn(name="Discriminator",
                                         discriminatorType = DiscriminatorType.STRING,
                                         length=30)
    @DiscriminatorValue("Vehicle")
    public class Vehicle implements Serializable{       //基类
    private Long id;
    private Short speed;//速度
    @Id
    @GeneratedValue
    @Column(columnDefinition="integer")//指定使用适配Integer长度的数据类�?br />     public Long getId() {
    return id;
    }
    public void setId(Long id) {
    this.id = id;
    }

    @SuppressWarnings("serial")
    @Entity
    @DiscriminatorValue("Car")
    public class Car extends Vehicle{        //Vehicle的子�c?/font>
    private String engine;//发动�?br />     @Column(nullable=true,length=30)
    public String getEngine() {
    return engine;
    }
    public void setEngine(String engine) {
    this.engine = engine;
        }
    }

     @SuppressWarnings("serial")
     @Entity
     @DiscriminatorValue("Camion")
     public class Camion extends Car{         //Car的子�c?/font>
     private String container;//集装��?br />      @Column(nullable=true,length=30)
     public String getContainer() {
     return container;
     }
     public void setContainer(String container) {
     this.container = container;
          }
     }
分析:
       �? 以看出，每个子类没有单独的映��，在数据库中没有对应的表存在。而只有一个记录所有自�w�属性和子类所有属性的表，在基�c�MؓVehicle 的时候，Discriminator 字段的值将为Vehicle,在子�c�MؓCar 的时候，Discriminator 字段的值将为Car�Q�子�c�MؓCamion 的时候，Discriminator 字段的值将为Camion。那么，如果业务逻辑要求Car 对象的engine 属性不允许为null�Q�显然无法在Vehicle_Hierarchy 表中为engine 字段定义not null �U�束�Q�可见这�U�映��方式无法保证关�p�L��据模型的数据完整性�?/font>

二、每个类分层�l�构一张表(table per class hierarchy)
       �q�种映射方式为每个类创徏一个表。在每个�c�d��应的表中只需包含和这个类本��n的属性对应的字段�Q�子�c�d��应的表参照父�c�d��应的�?使用每个子类一张表 (table per subclass)�{�略�Q�需要把@javax.persistence.Inheritance 注释�?strong>strategy 属性设�|��ؓInheritanceType.JOINED

     @SuppressWarnings("serial")
     @Entity
     @Inheritance(strategy=InheritanceType.JOINED)
     @Table(name="Vehicle")
     public class Vehicle implements Serializable{      //基类
     private Long id;
     private Short speed;//速度
     @Id
     @GeneratedValue
     @Column(columnDefinition="integer")
     public Long getId() {
     return id;
     }
     public void setId(Long id) {
     this.id = id;
     }
     public Short getSpeed() {
     return speed;
     }
     public void setSpeed(Short speed) {
     this.speed = speed;
     }
     }

     @SuppressWarnings("serial")
     @Entity
     @Table(name="Car")
     @PrimaryKeyJoinColumn(name="CarID")     //把主键对应的列名更改为CarID
     public class Car extends Vehicle{                 //Vehicle的子�c?/font>
     private String engine;//发动�?br />      @Column(nullable=true,length=30)
     public String getEngine() {
     return engine;
     }
     public void setEngine(String engine) {
     this.engine = engine;
     }
     }

     @SuppressWarnings("serial")
     @Entity
     @Table(name="Camion")
     @PrimaryKeyJoinColumn(name="CamionID")     //把主键对应的列名更改为CamionID
     public class Camion extends Car{                    //Car的子�c?/font>
     private String container;
     @Column(nullable=true,length=30)
     public String getContainer() {
     return container;
     }
     public void setContainer(String container) {
     this.container = container;
     }
     }
        �q�种映射方式支持多态关联和多态查询，而且�W�合关系数据模型的常规设计规则。在�q�种�{�略中你可以对子�cȝ��属性对应的字段定义not null �U�束。该�{�略的缺点：
        它的查询性能不如上面介绍的映��策略。在�q�种映射�{�略下，必须通过表的内连接或左外�q�接来实现多态查询和多态关联�?br /> 选择原则�Q�子�c�d��性非常多�Q�需要对子类某些属性对应的字段�q�行not null �U�束�Q�且�Ҏ��能要求不是很严格时�Q�优先选择该策�?/font>

三、每个具体类一张表(table per concrete class)
       �q�种映射方式为每个类创徏一个表。在每个�c�d��应的表中包含和这个类所有属性（包括从超�cȝ��承的属性）对应的字�D?使用每个具体�c�M��张表(table per concrete class)�{�略�Q�需要把@javax.persistence.Inheritance 注释�?strong>strategy 属性设�|��ؓInheritanceType.TABLE_PER_CLASS

        注意:一旦��用这�U�策略就意味着你不能��用AUTO generator 和IDENTITY generator�Q�即主键��g��能采用数据库自动生成.

     @SuppressWarnings("serial")
     @Entity
     @Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)
     @Table(name="Vehicle")
     public class Vehicle implements Serializable{            //基类
     private Long id;
     private Short speed;//速度
     @Id
     @Column(columnDefinition="integer")
     public Long getId() {
     return id;
     }
     public void setId(Long id) {
     this.id = id;
     }
     public Short getSpeed() {
     return speed;
     }
     public void setSpeed(Short speed) {
     this.speed = speed;
     }
     }

     @SuppressWarnings("serial")
     @Entity
     @Table(name="Car")
    public class Car extends Vehicle{               //Vehicle的子�c?/font>
     private String engine;//发动�?br />      @Column(nullable=true,length=30)
     public String getEngine() {
     return engine;
     }
     public void setEngine(String engine) {
     this.engine = engine;
     }
     }

     @SuppressWarnings("serial")
     @Entity
     @Table(name="Camion")
     public class Camion extends Car{              //Car的子�c?/font>
     private String container;//集装��?br />      @Column(nullable=true,length=30)
     public String getContainer() {
     return container;
     }
     public void setContainer(String container) {
     this.container = container;
     }
     }

注意:在查询时,例如: from Vehicle v
         查询所有Vehicle�Ӟ��因�ؓ他是最�l�承树中的根�Q�查询结果会得到所有��承于Vehicle�cȝ��记录
(构造的SQL Where部分�Q?strong>where Discriminator in ('Car', 'Camion'))
         delete from Vehicle v
         执行该操作会删除自��n对应记录�Q�还会删除所有��承Vehicle的记�?因�ؓ他是最�l�承树中的根�Q�就相当于清除整个表的数�?br />
该策略的优点�Q?br />                      在这�U�策略中你可以对子类的属性对应的字段定义not null �U�束�?br /> 该策略的�~�点�Q?br />                      不符合关�p�L��据模型的常规设计规则�Q�每个表中都存在属于基类的多余的字段。同�Ӟ��Z��支持�{�略的映��，持久化管理者需要决定��用什么方法，一�U�方法是�? entity 载入或多态关联时�Q�容器��用多�ơ查询去实现�Q�这�U�方法需要对数据库做几次来往查询�Q�非常媄响执行效率。另一�U�方法是容器通过使用SQLUNIOU 查询来实现这�U�策略�?br /> 选择原则�Q?br />                      除非你的现实情况必须使用�q�种�{�略�Q�一般情况下不要选择�?/font>

seal 2009-01-05 14:18 发表评论

seal — Fri, 09 May 2008 07:59:00 GMT

最�q�在��目中遇��C��个奇怪的问题�Q�在使用Hibernate拦截器捕获实体变化�ƈ�q�行处理�Ӟ��发现其中的onFlushDirty()函数执行了很多次�Q�导致进行处理时产生很多重复数据。具体问题如下：
使用一个类�l�承Hibernate的EmptyInterceptor�c�L��对程序中的实体变化进行拦截，�q�在其中的onFlushDirty()函数中对捕获的数据进行处理，产生对应的event数据�q�保存到数据库中�?例如�Q?br /> public class EventInterceptor extends EmptyInterceptor {
public boolean onFlushDirty(
        Object entity,
        Serializable id,
        Object[] currentState,
        Object[] previousState,
        String[] propertyNames,
        Type[] types ) throws CallbackException {

        if(isAuditable(entity)){//如果该实体需要被记录�Q�生成对应的event�?br />             //此处生成对应的event�?br />         }
        return false;
    }

在程序执行后�Q�发现对应一条实体的变化生成了多条重复的event记录�Q�非�怸�解�?br /> 后来google发现�Q�有��Z��到�q�对应的问题�Q��ƈ在Hibernage论坛中提��q�个问题�Q�鉴定�ؓHibernate的一个小Bug�?br /> �Q�原文地址�Q�http://forum.hibernate.org/viewtopic.php?t=940410&highlight=interceptor+onflushdirty�Q?br /> 解决�Ҏ��如下�Q?br /> ��FlushMode改�ؓ�Q�FlushMode.COMMIT
或者也可以提前�q�行flush()
都可以解册��个问题�?br />

seal 2008-05-09 15:59 发表评论