91精品国产亚洲爽啪在线影院 ,亚洲成AV人片在线播放无码,自拍偷自拍亚洲精品偷一

【�{】Hibernate Session的Flush模式

黎夕 — Mon, 18 Jan 2010 14:23:00 GMT

首先要知道的是：

Hibernate会尽量将与数据库的操作�g�q�，直到必须要与数据库进行交互，例如save�Ҏ��一般会在提交时才真正执行，最�l�在提交时会以批处理的方式与数据库进行交互，以提高效率�?/p>

而将操作延迟�Q�就是利用缓存，��最后要处理的操作放到缓存中�?/p>

flush�Ҏ��的主要作用就是清理缓存，强制数据库与Hibernate�~�存同步�Q�以保证数据的一致性。它的主要动作就是向数据库发送一�p�d��的sql语句�Q��ƈ执行�q�些sql语句�Q�但是不会向数据库提交。而commit�Ҏ��则会首先调用flush�Ҏ��Q�然后提交事务�?br />
      在下面的情况下，Hibernate会调用Session.flush()以清理缓存：
     1)事务提交�Ӟ��如果flush模式不�ؓFlushMode.NEVER,commit()��调用flush().
     2)在某些查询语句之前（此查询语句之前的语句已经改变了数据库状态，所以需要调用flush�Q�）以同步数据库是查出来的数据是�l�过更改的）�?br />
     除非明确地指定了flush�Q�）命��o�Q�否则关于Session何时会执行这些JDBC调用完全是无法保证的�Q�只能保证他们执行的前后��序�?/p>

通过讄��session.setFlushMode(),可以�_��控制Hibernate的FlushMode.
(1) FlushMode.AUTO:Hibernate判断对象属性有没有改变�Q�如果被更改成�ؓ脏数据，则在一个查询语句前��更新此改动以保证数据库的同步。这也是Hibernate的默认清理模式�?
(2) FlushMode.COMMIT:在事务结束之前清理session的缓存。这��h��可能��D��查出脏数�?
(3) FlushMode.NEVER�Q�除非强制调用Session.flush(),否则永远不清理Session。相当于��数据库讄��Z��个只�ȝ��数据库�?
       【如果此时进行数据的写入操作�Q�会发生错误�?br /> (4) FlushMode.ALWAYS�Q�在每一个查询数据之前都调用Session.flush()。很昄��q�种效率很低�?

在调用Session.flush()�Ӟ��涉及的SQL语句会按照下面的��序执行�?
�Q?�Q?nbsp;        所有的实体�q�行插入的语句，光��序按照对象执行Session.save()的时间顺序�?
�Q?�Q?nbsp;        所有对实体�q�行更新的语�?
�Q?�Q?nbsp;        所有对集合元素�q�行删除�Q�更新或者插入的语句
�Q?�Q?nbsp;        所有对实体�l�行删除的语句，光��序按照对象执行Session.delete()的时间顺序�?
�Q?�Q?nbsp;        有一个例外是�Q�如果对象��用native方式生成的ID�Q�持久化标识�Q�，则他们一执行save��׃��被插入�?
                 【因为native方式若想得到主键�Q�必��M��数据库交互，而hilo方式则不用】）

本文来自CSDN博客�Q��{载请标明出处�Q�http://blog.csdn.net/MageShuai/archive/2009/09/11/4544202.aspx

黎夕 2010-01-18 22:23 发表评论

HIbernate中SQL statements生成�{�略

黎夕 — Mon, 26 Oct 2009 10:22:00 GMT

一�Q�default statements generated on startup
By default, Hibernate creates SQL statements for each persistent class on startup.These statements are simple create, read, update, and delete operations for reading a single row, deleting a row, and so on.
the generated SQL statement updates all columns, and if the value of a particular column isn’t modified, the statement sets it to its old value.

二）dynamic statements generated at runtime
      1)元素 dynamic-insert属�?讄��为true,表示insert对象的时�?生成动态的insert语句,如果�q�个字段的值是null��׃��会加入到insert语句当中.默认false
      2)元素 dynamic-update属�?讄��为true,表示update对象的时�?生成动态的update语句,如果�q�个字段的值是null��׃��会被加入到update语句�?默认false
      3)元素 dynamic-insert属�?讄��为true,表示把所有的元素的dynamic-insert属性设�|��ؓtrue,默认false
      4)元素 dynamic-update属�?讄��为true,表示把所有的元素的dynamic-update属性设�|��ؓtrue,默认false

�ȝ��Q�如果表中包含N多字�D?��把dynamic-update属性和insert属性设�|��ؓtrue,�q�样在插入和修改数据的时�?语句中只包括要插入或者修改的字段.可以节省SQL语句的执行时�?提高�E�序的运行效�?(In some situations, such as a legacy table with hundreds of columns where the SQL statements will be large for even the simplest operations (say, only one column needs updating), you have to turn off this startup SQL generation and switch to dynamic statements generated at runtime.)

其他属性设�|�对SQL Statement影响

      1)元素 insert属�?讄��为false,在insert语句中不包含�q�个字段,表示永远不会被插�?默认true
      2)元素 update属�?讄��为false,在update语句中不包含�q�个字段,表示永远不会被修�?默认true
      3)元素 mutable属�?讄��为false��是把所有的元素的update属性设�|��ؓ了false,说明�q�个对象不会被更�?默认true

黎夕 2009-10-26 18:22 发表评论

Hibernate3的DetachedCriteria使用

黎夕 — Thu, 26 Mar 2009 09:47:00 GMT

Criteria��SQL進行��裝�Q�讓開發人員可以用物件的方式來對資料庫進行操作�Q�例如下面的查詢User表格中的所有資料：

Criteria criteria = session.createCriteria(User.class);
// 查詢user所有欄�?/span>
List users = criteria.list();
Iterator iterator = users.iterator();
System.out.println("id \t name/age");
while(iterator.hasNext()) {
    User user = (User) iterator.next();
    System.out.println(user.getId() +
                               " \t " + user.getName() +
                               "/" + user.getAge());
}

Hibernate實際上��用以下的SQL來查詢資料��n�Q?br />

select this_.id as id0_, this_.name as name0_0_, this_.age as age0_0_ from user this_

Criteria實際上只是個容器，如果惌��a�定查詢條�g�Q�則要��用add()�Ҏ��加入Restrictions的條仉��Ӟ��例如查詢age大於20且小�?0的資料：

Criteria criteria = session.createCriteria(User.class);
criteria.add(Restrictions.gt("age", new Integer(20)));
criteria.add(Restrictions.lt("age", new Integer(40)));
List users = criteria.list();

您也可以使用邏輯�i�合來進行查詢�Q�例如結合age�{�於�Q�eq�Q?0或（or�Q�age為空�Q�isNull�Q�的條�g�Q?

Criteria criteria = session.createCriteria(User.class);
criteria.add(Restrictions.or(
Restrictions.eq("age", new Integer(20)),
Restrictions.isNull("age")
));
List users = criteria.list();

也可以��用sqlRestriction()�Ҏ��來提供SQL語法作限定查詢，例如查詢name以cater開頭的資料：

Criteria criteria = session.createCriteria(User.class);
criteria.add(Restrictions.sqlRestriction("{alias}.name LIKE (?)", "cater%", Hibernate.STRING));
List users = criteria.list();

其中alias��被替換��User��別盔R��的名�E�，�?��被替換為cater%�Q�也��是�W�二個參數所提供的��|��在SQL撰寫時，不必再寫WHERE�Q�如果有多個查詢條�Ӟ��例如BETWEEN子句的查詢，則可以如下：

Criteria criteria = session.createCriteria(User.class);
Integer[] ages = {new Integer(20), new Integer(40)};
Type[] types = {Hibernate.INTEGER, Hibernate.INTEGER};
criteria.add(Restrictions.sqlRestriction("{alias}.age BETWEEN (?) AND (?)", ages, types));
List users = criteria.list();

Restrictions的幾個常用限定查詢方法如下表所�C�：

�Ҏ��	說明
Restrictions.eq	�{�於
Restrictions.allEq	使用Map�Q��用key/value進行多個等於的比對
Restrictions.gt	大於 >
Restrictions.ge	大於�{�於 >=
Restrictions.lt	��於 <
Restrictions.le	��於�{�於 <=
Restrictions.between	��應SQL的BETWEEN子句
Restrictions.like	��應SQL的LIKE子句
Restrictions.in	��應SQL的in子句
Restrictions.and	and關係
Restrictions.or	or關係
Restrictions.sqlRestriction	SQL限定查詢

==============

Hibernate Criteria 兌��查询

前面讲了Criteria看�v来比HQL��眼多了�Q�接着�l�箋�?br />
如果每个��女都有自己的客戯��源（不要��x��了！�Q�，那么需要查询拥有客户Gates的美��x��么办？

使用Criteria可以有两�U�方法：

1�Q?br /> DetachedCriteria beautyCriteria = DetachedCriteria.forClass(Beauty.class).createCriteria("customers");
beautyCriteria.add(Restrictions.eq("name", "Gates")):

2�Q?br /> DetachedCriteria beautyCriteria = DetachedCriteria.forClass(Beauty.class).createAlias("customers", "c");
beautyCriteria.add(Restrictions.eq("c.name", "Gates")):

接着有了新的要求�Q�年�U�太大的��女不要�Q�还是查找拥有客户Gates的，条�g如下�Q?br /> DetachedCriteria beautyCriteria = DetachedCriteria.forClass(Beauty.class, "b").;
DetachedCriteria customerCriteria = beautyCriteria.createAlias("customers", c");
beautyCriteria.add(Restrictions.le("b.age", new Long(20))):
customerCriteria.add(Restrictions.eq("c.name", "Gates")):

关于Criteria更详�l�的资料�Q�Hibernate的源代码和测试是最好的文��?br />
Criteria的缺点？DBA很生气，后果很严重�?/p>

黎夕 2009-03-26 17:47 发表评论

黎夕 — Sat, 17 Jan 2009 08:36:00 GMT

摘要: 在新架构中打��选择Compass或Hibernate Search作�ؓ搜烦引擎框架�Q�比较后�Q�感觉Hibernate Search上还是没有Compass成熟�Q�另外考虑到后期对�|�页的爬取及搜烦需求，军_��q�是��Z��Compass来作为架构缺省的搜烦引擎。网上关�?Compass的文��很多，但说得相对完整其详细的入门文��基本上没有�Q�Compass的官�Ҏ��倒是说得很详�l�，但是例子一塌糊涂，... 阅读全文

黎夕 2009-01-17 16:36 发表评论

黎夕 — Sat, 17 Jan 2009 05:57:00 GMT

【引用】http://davidwei05951983.spaces.live.com/Blog/cns!BED3D557991594B3!812.entry

session的常用基本操作有�Q?

Transient instances may be made persistent by calling save(),persist() or saveOrUpdate(). Persistent instances may be made transient by calling delete(). Any instance returned by a get() or load() method is persistent. Detached instances may be made persistent by calling update(), saveOrUpdate(), lock() or replicate(). The state of a transient or detached instance may also be made persistent as a new persistent instance by calling merge().save() and persist() result in an SQL INSERT, delete() in an SQL DELETE and update() or merge() in an SQL UPDATE. Changes to persistent instances are detected at flush time and also result in an SQL UPDATE. saveOrUpdate() and replicate() result in either an INSERT or an UPDATE.

persist():
Make a transient instance persistent. This operation cascades to associated instances if the association is mapped with cascade="persist". The semantics of this method are defined by JSR-220.
当��联风��gؓpersist�Ӟ��q�个操作会��联操作关联的对象。这个方法的语义是JSR-220定义的�?

persist() is well defined. It makes a transient instance persistent. However,
it doesn't guarantee that the identifier value will be assigned to the persistent
instance immediately, the assignment might happen at flush time. The spec doesn't say
that, which is the problem I have with persist().

persist() also guarantees that it will not execute an INSERT statement if it is
called outside of transaction boundaries. This is useful in long-running conversations
with an extended Session/persistence context.A method like persist() is required.

save() does not guarantee the same, it returns an identifier, and if an INSERT
has to be executed to get the identifier (e.g. "identity" generator, not "sequence"),
this INSERT happens immediately, no matter if you are inside or outside of a transaction. This is not good in a long-running conversation with an extended Session/persistence context."

save():
Persist the given transient instance, first assigning a generated identifier. (Or using the current value of the identifier property if the assigned generator is used.) This operation cascades to associated instances if the association is mapped with cascade="save-update".
首先会赋予一个标志符�Q�然后持久化�l�定的对象。但是如果��用assigned 标志�W��生方法，则会使用当前的标志符倹{��如果��联风��gؓsave�Q�pdate�Q�则会持久化相应的关联对�?

merge():
Copy the state of the given object onto the persistent object with the same identifier. If there is no persistent instance currently associated with the session, it will be loaded. Return the persistent instance. If the given instance is unsaved, save a copy of and return it as a newly persistent instance. The given instance does not become associated with the session. This operation cascades to associated instances if the association is mapped with cascade="merge". The semantics of this method are defined by JSR-220.
拯��当前的对象的状态到相同标志�W�的持久化对象的状态。如果当前关联的session中没有持久化对象�Q�Hibernate会加载该对象�Q��ƈ�q�回�q�个持久化对象。如果给定的对象没有保存�Q�则Hibernate保存该副本，�q�回�q�个新持久化的对象，但给定的对象�q�没有和session兌��。如果指定��联风��gؓmerge�Q�则会��联关联对象。该�Ҏ��的语义是JSR�Q?00定义的�?

saveOrUpdate():
Either {@link #save(String, Object)} or {@link #update(String, Object)} the given instance, depending upon resolution of the unsaved-value checks (see the manual for discussion of unsaved-value checking). This operation cascades to associated instances if the association is mapped with cascade="save-update".
保存或更新给定对象，取决于给定对象的持久化状态。默认情况下是保存，在指定标志符元素属性�ؓunsaved-value时则会调整。如果��联风��gؓ"save-update",则会�U�联相关联的对象

delete():
Remove a persistent instance from the datastore. The object argument may be an instance associated with the receiving Session or a transient instance with an identifier associated with existing persistent state. This operation cascades to associated instances if the association is mapped with cascade="delete".
删除对象�?

lock():
Obtain the specified lock level upon the given object. This may be used to perform a version check (LockMode.READ), to upgrade to a pessimistic lock (LockMode.UPGRADE), or to simply reassociate a transient instance with a session (LockMode.NONE). This operation cascades to associated instances if the association is mapped with cascade="lock".
用于�Ҏ��定对象设�|�参��C��l�定的锁。如果锁为LockMode.READ�Q�可以用来执行版本检查；如果锁�ؓLockMode.UPGRADE则用来执行悲观锁。如果定为LockMode.NONE�Q�则仅仅时持久化一个未持久化的对象。如果��联风��gؓlock�Q�会�U�联相关联的对象�?

refresh():
    Re-read the state of the given instance from the underlying database. It is inadvisable to use this to implement long-running sessions that span many business tasks. This method is, however, useful in certain special circumstances.For example where a database trigger alters the object state upon insert or update after executing direct SQL (eg. a mass update) in the same session after inserting a Blob or Clob.
    从当前数据库中重新读取给定对象的状态。这在执行跨��多个业务�Q务的长时间session中优势不显著�Q�在��数特定环境下还是有用的�Q�例如：插入或更新后数据库触发器更改了对象的状态。当前session中执行完原生SQL后（如批量更斎ͼ��?插入Blob或Clob对象后�?br />
evict():
    Remove this instance from the session cache. Changes to the instance will not be synchronized with the database. This operation cascades to associated instances if the association is mapped with cascade="evict".
    从session的缓存中去除当前实例。执行后对象的改变将不再和数据库保持同步。当指定�U�联风格�?evict’�Ӟ��会��联操作关联对象。我用的时候主要是用于扚w��操作的时候，清空�~�存�Q�防止内存紧张�?

replicate():
Persist the state of the given detached instance, reusing the current identifier value. This operation cascades to associated instances if the association is mapped with cascade="replicate"
重用当前的标志符�Q�持久化当前已经��q��session的对象的状态。具体的操作和要看参数ReplicationMode。如果是ReplicationMode.EXCEPTION,则在复制时如果有重复的行数据�Q�则抛出异常。ReplicationMode.IGNORE则忽略异常。ReplicationMode.OVERWRITE则会覆盖掉已有行数据。ReplicationMode.LATEST_VERSION则是在有重复时��用最新的版本�q�行控制�?

自动状态检��?

Hibernate的用��h��要求一个既可自动分配新持久化标�?identifier)保存瞬时(transient)对象�Q�又可更�?重新兌��q��(detached)实例的通用�Ҏ��?saveOrUpdate()�Ҏ��实现了这个功能�?nbsp;saveOrUpdate()用途和语义可能会��新用��h��到迷惑�?首先�Q�只要你没有��试在某个session中��用来自另一session的实例，你就应该不需要��用update()�Q?saveOrUpdate()�Q�或merge()。有些程序从来不用些�Ҏ��?

通常下面的场景会使用update()或saveOrUpdate()�Q?
�E�序在第一个session中加载对�?
该对象被传递到表现�?
对象发生了一些改�?
该对象被�q�回��C��务逻辑�?
�E�序调用�W�二个session的update()�Ҏ��持久�q�些改动

saveOrUpdate()做下面的�?
如果对象已经在本session中持久化了，不做��M��?
如果另一个与本session兌��的对象拥有相同的持久化标�?identifier)�Q�抛��Z��个异�?
如果对象没有持久化标�?identifier)属性，对其调用save()
如果对象的持久标�?identifier)表明其是一个新实例化的对象�Q�对其调用save()
如果对象是附带版本信息的�Q�通过�?lt;timestamp>�Q?�q�且版本属性的��D��明其是一个新实例化的对象�Q�save()它�?
否则update() �q�个对象

merge()可非�怸��?
如果session中存在相同持久化标识(identifier)的实例，用用��L��出的对象的状态覆盖旧有的持久实例
如果session没有相应的持久实例，则尝试从数据库中加蝲�Q�或创徏新的持久化实�?,最后返回该持久实例
用户�l�出的这个对象没有被兌��到session上，它依旧是��q��?/span>.

Session刷出(flush)
每间隔一�D�|��_��Session会执行一些必需的SQL语句来把内存中的对象的状态同步到JDBC�q�接中。这个过�E�被�U�Cؓ刷出(flush)�Q�默认会在下面的旉��Ҏ��行：
a.在某些查询执行之�?
b.在调用org.hibernate.Transaction.commit()的时�?
c.在调用Session.flush()的时�?

涉及的SQL语句会按照下面的��序发出执行�Q?
所有对实体�q�行插入的语句，光��序按照对象执行Session.save()的时间顺�?
所有对实体�q�行更新的语�?
所有进行集合删除的语句
所有对集合元素�q�行删除�Q�更新或者插入的语句
所有进行集合插入的语句
所有对实体�q�行删除的语句，光��序按照对象执行Session.delete()的时间顺�?

�Q�有一个例外是�Q�如果对象��用native方式来生成ID�Q�持久化标识�Q�的话，它们一执行save��׃��被插入。）
除非你明��地发出了flush()指��o�Q�关于Session何时会执行这些JDBC调用是完全无法保证的�Q�只能保证它们执行的前后��序�?当然�Q�Hibernate保证�Q�Query.list(..)�l�对不会�q�回已经失效的数据，也不会返回错误数据�?

也可以改变默认的讄��Q�来让刷�?flush)操作发生的不那么频繁�?FlushMode�c�d��义了三种不同的方式�?仅在提交时刷�?仅当Hibernate的Transaction API被��用时有效)�Q?按照刚才说的方式刷出�Q?以及除非明确使用flush()否则从不刷出�?最后一�U�模式对于那些需要长旉��保持Session为打开或者断�U�状态的长时间运行的工作单元很有用�?

父子关系的��?cascading)操作准确语义如下�Q?
如果父对象被persist()�Q�那么所有子对象也会被persist()
如果父对象被merge()�Q�那么所有子对象也会被merge()
如果父对象被save()�Q�update()�?saveOrUpdate()�Q�那么所有子对象则会被saveOrUpdate()
如果某个持久的父对象引用了瞬�?transient)或者脱��?detached)的子对象�Q�那么子对象��会被saveOrUpdate()
如果父对象被删除�Q�那么所有子对象也会被delete()

除非被标��Cؓcascade="delete-orphan"�Q�删�?#8220;孤儿”模式�Q�此时不被�Q何一个父对象引用的子对象会被删除�Q�，否则子对象失掉父对象对其的引用时�Q�什么事也不会发生�?如果有特�D�需要，应用�E�序可通过昑ּ�调用delete()删除子对象�?

黎夕 2009-01-17 13:57 发表评论

黎夕 — Fri, 26 Dec 2008 10:07:00 GMT

众所周知�Q?span class="hilite1">List仅仅会填充二�U�缓存，却不能利用二�U�缓存，而iterator可以��M��U�缓存，然而无法命中的话，效率却很低。一个最好的办法��是�Q�第一�ơ查询��?span class="hilite1">List�Q�随后的查询使用iterator�Q�现在的问题是如何做到第一�ơ查询��?span class="hilite1">List�Q�随后查询��用iterator�?

先来考察一下缓存的作用�Q�缓存之所以可以命中，前提条�g是该数据被��用的非常频繁�Q�同时更新的可能性相当小�Q�如果数据会频繁修改�Q�那么毫无疑问，�~�存不会带来��M��好处。明��了�q�一点，我们��明白什么对象应该进行缓存了。显�Ӟ��对于那些�l�常会被讉K��到的��批量的诸如基础信息�Q�用户和权限信息是非帔R��合�q�行�~�存的，�q�些数据我们可以在应用启动的时候就执行一��?span class="hilite1">list�Ҏ��查询�Q�进行缓存填�?例如写一个InitBean�c�进行数据缓存初始化)�Q�此外在数据被修改的时候，再次执行list�Ҏ��Q�进行缓存填充。而在使用�q�些数据的其他地方，�l�统使用iterator�Ҏ��。这样就可以实现所谓的�W�一�ơ查询��?span class="hilite1">List�Q�随后的查询使用iterator了�?

黎夕 2008-12-26 18:07 发表评论

Spring 整合 Hibernate 的一处简化配�|?lt;转蝲>

黎夕 — Wed, 17 Dec 2008 07:23:00 GMT

Spring 整合 Hibernate 的一处简化配�|?br /> 原文�Q�http://www.tkk7.com/steady/archive/2007/08/17/137527.html

在过��M��?Spring 整合 Hibernate 的时候，都是用这��L��配置方式�?br />

<bean id="sessionFactory" lazy-init="true"
      class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
    <property name="mappingResources">
        <list>
            <value>resources/icustomer/Contact.hbm.xmlvalue>
            <value>resources/icustomer/Customer.hbm.xmlvalue>
        list>
    property>
    .
bean>

每当需要加入一个新�?VO �Ӟ��我需要过来修攚w��|�文�Ӟ��来引入对新的 VO 的支持�?/span>

现在我��用的时候，是这么配的：

<bean id="sessionFactory" lazy-init="true"
      class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
    <property name="mappingLocations">
        <list>
            <value>classpath:resources/**/*.hbm.xmlvalue>
        list>
    property>
    .
bean>

做项目开发的时候，��再也没有改�q�配�|��?/span>

黎夕 2008-12-17 15:23 发表评论

Hibernate�E�序性能优化

黎夕 — Mon, 21 Jul 2008 03:57:00 GMT

　【引用】　http://blog.csdn.net/freeglad/archive/2008/07/04/2610720.aspx

初用HIBERNATE的�h也许都遇到过性能问题�Q�实现同一功能�Q�用HIBERNATE与用JDBC性能相差十几倍很正常�Q�如果不及早调整�Q�很可能影响整个��目的进度�?/p>

　　大体上，对于HIBERNATE性能调优的主要考虑点如�?

　　Ø 数据库设计调�?/p>

　　Ø HQL优化

　　Ø API的正��?如根据不同的业务�c�d��选用不同的集合及查询API)

　　Ø 主配�|�参�?日志�Q�查询缓存，fetch_size, batch_size�{?

　　Ø 映射文�g优化(ID生成�{�略�Q�二�U�缓存，延迟加蝲�Q�关联优�?

　　Ø 一�U�缓存的��理

　　Ø 针对二��~�存�Q�还有许多特有的�{�略

　　Ø 事务控制�{�略�?/p>

　　1�?数据库设�?/strong>

　　a) 降低兌��的复杂�?/p>
　　b) ��量不��用联合主�?/p>
　　c) ID的生成机�Ӟ��不同的数据库所提供的机制�ƈ不完全一�?/p>
　　d) 适当的冗余数据，不过分追求高范式

　　2�?HQL优化

　　HQL如果抛开它同HIBERNATE本��n一些缓存机制的兌��Q�HQL的优化技巧同普通的SQL优化技巧一��P��可以很容易在�|�上扑ֈ�一些经验之谈�?/p>
　　3�?主配�|?/strong>

　　a) 查询�~�存�Q�同下面讲的�~�存不太一��P��它是针对HQL语句的缓存，卛_��全一��L��语句再次执行时可以利用缓存数据。但是，查询�~�存在一个交易系�l?数据变更频繁�Q�查询条件相同的机率�q�不�?中可能会起反作用:它会白白耗费大量的系�l�资源但却难以派上用场�?/p>
　　b) fetch_size�Q�同JDBC的相兛_��C��用类��|��参数�q�不是越大越好，而应�Ҏ��业务特征去设�|?/p>
　　c) batch_size同上�?/p>
　　d) 生��pȝ��中，切记要关掉SQL语句打印�?/p>
　　4�?�~�存

　　a) 数据库��~�存:�q��~�存是最高效和安全的�Q�但不同的数据库可管理的层次�q�不一��P��比如�Q�在ORACLE中，可以在徏表时指定��整个表�|�于�~�存当中�?/p>
　　b) SESSION�~�存:在一个HIBERNATE SESSION有效�Q�这�U�缓存的可干预性不强，大多于HIBERNATE自动��理�Q�但它提供清除缓存的�Ҏ��Q�这在大扚w��增加/更新操作是有效的。比如，同时增加十万条记录，按常规方式进行，很可能会发现OutofMemeroy的异常，�q�时可能需要手动清除这一�U�缓�?Session.evict以及 Session.clear

　　c) 应用�~�存:在一个SESSIONFACTORY中有效，因此也是优化的重中之重，因此�Q�各�cȝ��略也考虑的较多，在将数据攑օ��q�一�U�缓存之前，需要考虑一些前提条�?

　　i. 数据不会被第三方修改(比如�Q�是否有另一个应用也在修改这些数�?)

　　ii. 数据不会太大

　　iii. 数据不会频繁更新(否则使用CACHE可能适得其反)

　　iv. 数据会被频繁查询

　　v. 数据不是关键数据(如涉及钱�Q�安全等斚w��的问�?�?/p>
　　�~�存有几�U��Ş式，可以在映��文件中配置:read-only(只读�Q�适用于很��变更的静态数�?历史数据)�Q�nonstrict-read- write�Q�read-write(比较普遍的�Ş式，效率一�?�Q�transactional(JTA中，且支持的�~�存产品较少)

　　d) 分布式缓�?同c)的配�|�一��P��只是�~�存产品的选用不同�Q�在目前的HIBERNATE中可供选择的不多，oscache, jboss cache�Q�目前的大多数项目，对它们的用于集群的��?特别是关键交易系�l?都持保守态度。在集群环境中，只利用数据库�U�的�~�存是最安全的�?/p>
　　5�?延迟加蝲

　　a) 实体延迟加蝲:通过使用动态代理实�?/p>
　　b) 集合延迟加蝲:通过实现自有的SET/LIST�Q�HIBERNATE提供了这斚w��的支�?/p>
　　c) 属性�g�q�加�?

　　6�?�Ҏ��选用

　　a) 完成同样一件事�Q�HIBERNATE提供了可供选择的一些方式，但具体��用什么方式，可能用性能/代码都会有媄响。显�C�，一�ơ返回十万条记录 (List/Set/Bag/Map�{?�q�行处理�Q�很可能��D��内存不够的问题，而如果用��Z��游标(ScrollableResults)�?Iterator的结果集�Q�则不存在这��L��问题�?/p>
　　b) Session的load/get�Ҏ��Q�前者会使用二��~�存�Q�而后者则不��用�?/p>
　　c) Query和list/iterator�Q�如果去仔细研究一下它们，你可能会发现很多有意思的情况�Q�二者主要区�?如果使用了Spring�Q�在HibernateTemplate中对应find,iterator�Ҏ��):

　　i. list只能利用查询�~�存(但在交易�pȝ��中查询缓存作用不�?�Q�无法利用二�U�缓存中的单个实体，但list查出的对象会写入二��~�存�Q�但它一般只生成较少的执行SQL语句�Q�很多情况就是一�?无关�?�?/p>
　　ii. iterator则可以利用二�U�缓存，对于一条查询语句，它会先从数据库中扑և�所有符合条件的记录的ID�Q�再通过ID�ȝ��存找�Q�对于缓存中没有的记录，再构造语句从数据库中查出�Q�因此很�Ҏ��知道�Q�如果缓存中没有��M��W�合条�g的记录，使用iterator会��生N+1条SQL语句(N为符合条件的记录�?

　　iii. 通过iterator�Q�配合缓存管理API�Q�在��量数据查询中可以很好的解决内存问题�Q�如:

　　while(it.hasNext()){

　　YouObject object = (YouObject)it.next();

　　session.evict(youObject);

　　sessionFactory.evice(YouObject.class, youObject.getId());

　　}

　　如果用list�Ҏ��Q�很可能��出OutofMemory错误了�?/p>
　　iv. 通过上面的说明，我想你应该知道如何去使用�q�两个方法了�?/p>
　　7�?集合的选用

　　在HIBERNATE 3.1文档�?#8220;19.5. Understanding Collection performance”中有详细的说明�?/p>
　　8�?事务控制

　　事务斚w��Ҏ��能有媄响的主要包括:事务方式的选用�Q�事务隔��ȝ�别以及锁的选用

　　a) 事务方式选用:如果不涉及多个事务管理器事务的话�Q�不需要��用JTA�Q�只有JDBC的事务控制就可以�?/p>
　　b) 事务隔离�U�别:参见标准的SQL事务隔离�U�别

　　c) 锁的选用:悲观�?一般由具体的事务管理器实现)�Q�对于长事务效率低，但安全。乐观锁(一般在应用�U�别实现)�Q�如在HIBERNATE中可以定�?VERSION字段�Q�显�Ӟ��如果有多个应用操作数据，且这些应用不是用同一�U�乐观锁机制�Q�则乐观锁会失效。因此，针对不同的数据应有不同的�{�略�Q�同前面许多情况一��P��很多时候我们是在效率与安全/准确性上找一个��^衡点�Q�无论如何，优化都不是一个纯技术的问题�Q�你应该对你的应用和业务特征有��够的了解�?/p>
　　9�?扚w��操作

　　即��是��用JDBC�Q�在�q�行大批数据更新�Ӟ��BATCH与不使用BATCH有效率上也有很大的差别。我们可以通过讄��batch_size来让其支持批量操作�?/p>
　　举个例子�Q�要扚w��删除某表中的对象�Q�如“delete Account”�Q�打出来的语句，会发现HIBERNATE扑և�了所有ACCOUNT的ID�Q�再�q�行删除�Q�这主要是�ؓ了维护二�U�缓存，�q�样效率肯定高不了，在后�l�的版本中增加了bulk delete/update�Q�但�q�也无法解决�~�存的维护问题。也��是��_��׃��有了二��~�存的维护问题，HIBERNATE的批量操作效率�ƈ不尽如�h�?

　　从前面许多要点可以看出，很多时候我们是在效率与安全/准确性上找一个��^衡点�Q�无论如何，优化都不是一个纯技术的问题�Q�你应该对你的应用和业务特征有��够的了解�Q�一般的�Q�优化方案应在架构设计期��基本确定，否则可能��D��没必要的�q�工�Q�致佉K��目�g期，而作为架构师和项目经理，�q�要面对开发�h员可能的抱怨，必竟�Q�我们对用户需求更改的控制力不大，但技�?架构风险是应该在初期意识到�ƈ制定好相关的对策�?/p>
　　�q�有一点要注意�Q�应用层的缓存只是锦上添花，永远不要把它当救命稻草，应用的根�?数据库设计，��法�Q�高效的操作语句�Q�恰当API的选择�{?才是最重要的�?/p>

黎夕 2008-07-21 11:57 发表评论

hibernate二��~�存�ȝ��

黎夕 — Wed, 05 Sep 2007 07:33:00 GMT
二��~�存
    hibernate的session提供了一�U�缓存，在同一个session中对同一个id的对象load两次�Q��ƈ不会发送两条sql�l�数据库。但是session关闭的时候，一�U�缓存就失效了�?/p>
    二��~�存是SessionFactory�U�别的全局�~�存�Q�它底下可以使用不同的缓存类库，比如ehcache、oscache�{�，需要��用缓存实现方案�?/p>
    详细��L��: hibernate二��~�存�ȝ��

3.1 基本讄��

1. 如果需要特别设�|�ehcache的属性，把一个ehcache.xml 定义文�g拯��到class-path.

2. jdbc.properties加上

hibernate.cache.use_query_cache=true hibernate.cache.provider_class=org.hibernate.cache.EhCacheProvider

3. applicationContext.xml�?下加�?/p>

"hibernate.cache.use_query_cache">$ {hibernate.cache.use_query_cache} "hibernate.cache.provider_class">$ {hibernate.cache.provider_class}

3.2 Entity�U�二�U�缓�?/h3>
   Entity二��~�存是把PO放进cache�Q�缓存的key��是ID�Q�value是POJO�Q�不同于查询的缓存�?/p>
   Entity二��~�存在BookDao.get(3)�Q�和book.getCategory()的情况下都能用到�Q�把category�q�样的小表完全cache到内存挺不错的�?/p>
在hbm文�g�?

"Product" table="PRODUCT" dynamic-insert="true" dynamic-update="true"> "nonstrict-read-write"/> "id" column="ID"> "native"/>

   如果你��用的二��~�存实现是ehcache的话�Q�需要配�|�ehcache.xml �Q�否则就会��用ehcache默认的配�|?/p>

"com.xxx.pojo.Foo" maxElementsInMemory="500" eternal="false" timeToLiveSeconds="7200" timeToIdleSeconds="3600" overflowToDisk="true" />

3.3 查询�~�存

   上面的二�U�缓存是针对单个对象的，如果要对查询�l�果�Q�则是用下面的语�?/p>

query.setCacheable(true);//�Ȁ�z�L��询缓�? query.setCacheRegion("myCacheRegion");//指定要��用的cacheRegion�Q�可�?/span>

   cacheRegion是可选的�Q�可以对使用的缓存进行特�D�设�|�，在ehcahe.xml里要补上下面的一�D�c�?/p>

"myCacheRegion" maxElementsInMemory="10" eternal="false" timeToIdleSeconds="3600" timeToLiveSeconds="7200" overflowToDisk="true" />

黎夕 2007-09-05 15:33 发表评论

事务��理方式

黎夕 — Tue, 31 Jul 2007 04:19:00 GMT

1�Q?依赖特定事务资源的事务处�?br>�q�是应用开发中最常见的模式，即通过特定资源提供的事务机制进行事务管理�?br>如通过JDBC、JTA 的rollback、commit�Ҏ��Q�Hibernate Transaction 的rollback、commit�Ҏ��{��?br>�q�种�Ҏ��大家已经相当熟悉�?/p>

2�Q?依赖容器的参数化事务��理
通过容器提供的集�U�式参数化事务机�Ӟ��实现事务的外部管理，如EJB 中的事务��理模式�?br> 容器��理的参数化事务为程序开发提供了相当的灵�z�L��，同时因�ؓ��事务委托给容器�q�行��理�Q?br>应用逻辑中无需再编写事务代码，大大节省了代码量�Q�特别是针对需要同时操作多个事务资源的应用�Q�，从而提高了生��率�?br>

【引用�?/font> http://www.tkk7.com/georgehill/archive/2005/07/08/7374.html

事务�?个基本特性（ACID�Q�：
      1. Atomic�Q�原子性）�Q�事务中包含的操作被看作一个逻辑单元�Q�这个逻辑单元中的操作要么全部成功�Q�要么全部失败�?br>      2. Consistency�Q�一致性）�Q�只有合法的数据可以被写入数据库�Q�否则事务应该将其回滚到最初状态�?br>      3. Isolation�Q�隔��L��）�Q�事务允许多个用户对同一个数据的�q�发讉K��Q�而不破坏数据的正��性和完整性。同�Ӟ��q�行事务的修改必��M��其他�q�行事务的修改相互独立�?br>      4. Durability�Q�持久性）�Q�事务结束后�Q�事务处理的�l�果必须能够得到固化�?

      数据库操作过�E�中可能出现�?�U�不��定情况�Q?br>      1. 脏读取（Dirty Reads�Q�：一个事务读取了另一个�ƈ行事务未提交的数据�?br>      2. 不可重复��d��Q�Non-repeatable Reads�Q�：一个事务再�ơ读取之前的数据�Ӟ��得到的数据不一��_��被另一个已提交的事务修攏V�?br>      3. 虚读�Q�Phantom Reads�Q�：一个事务重新执行一个查询，�q�回的记录中包含了因为其他最�q�提交的事务而��生的新记录�?br>
      标准SQL规范中，��Z��避免上面3�U�情�늚�出现�Q�定义了4个事务隔��ȝ��U�：
      1. Read Uncommitted�Q�最低等�U�的事务隔离�Q�仅仅保证了��d��q�程中不会读取到非法数据。上�?�U�不��定情况均有可能发生�?br>      2. Read Committed�Q�大多数��L��数据库的默认事务�{��Q�保证了一个事务不会读到另一个�ƈ行事务已修改但未提交的数据，避免�?#8220;脏读�?#8221;。该�U�别适用于大多数�pȝ��?br>      3. Repeatable Read�Q�保证了一个事务不会修改已�l�由另一个事务读取但未提交（回滚�Q�的数据。避免了“脏读�?#8221;�?#8220;不可重复��d��”的情况，但是带来了更多的性能损失�?br>      4. Serializable�Q�最高等�U�的事务隔离�Q�上�?�U�不��定情况都将被规�ѝ��这个��别将模拟事务的串行执行�?

      Hibernate��事务管理委托给底层的JDBC或者JTA�Q�默认是��Z��JDBC Transaction的�?br>      Hibernate支持“悲观锁（Pessimistic Locking�Q?#8221;�?#8220;乐观锁（Optimistic Locking�Q?#8221;�?br>      悲观锁对数据被外界修�Ҏ��保守态度�Q�因此，在整个数据处理过�E�中�Q�将数据处于锁定状态。悲观锁的实玎ͼ�往往依靠数据库提供的锁机制。Hibernate通过使用数据库的for update子句实现了悲观锁机制。Hibernate的加锁模式有�Q?br>      1. LockMode.NONE�Q�无锁机�?br>      2. LockMode.WRITE�Q�Hibernate在Insert和Update记录的时候会自动获取
      3. LockMode.READ�Q�Hibernate在读取记录的时候会自动获取
      4. LockMode.UPGRADE�Q�利用数据库的for update子句加锁
      5. LockMode.UPGRADE_NOWAIT�Q�Oracle的特定实玎ͼ�利用Oracle的for update nowait子句实现加锁
      乐观锁大多是��Z��数据版本�Q�Version�Q�记录机制实现。Hibernate在其数据讉K��引擎中内�|�了乐观锁实玎ͼ�可以通过class描述�W�的optimistic-lock属性结合version描述�W�指定。optimistic-lock属性有如下可选取��|��
      1. none�Q�无乐观�?br>      2. version�Q�通过版本机制实现乐观�?br>      3. dirty�Q�通过��查发生变动过的属性实��C��观锁
      4. all�Q�通过��查所有属性实��C��观锁

黎夕 2007-07-31 12:19 发表评论

【�{】open session and Hibernate事务处理机制

黎夕 — Wed, 30 May 2007 06:05:00 GMT

在没有��用Spring提供的Open Session In View情况下，因需要在service(or Dao)层里把session关闭�Q�所以lazy loading 为true的话�Q�要在应用层内把关系集合都初始化�Q�如 company.getEmployees()�Q�否则Hibernate抛session already closed Exception;    Open Session In View提供了一�U�简便的�Ҏ��Q�较好地解决了lazy loading问题.

    它有两种配置方式OpenSessionInViewInterceptor和OpenSessionInViewFilter(具体参看SpringSide)�Q�功能相同，只是一个在web.xml配置�Q�另一个在application.xml配置而已�?/p>
    Open Session In View在request把session�l�定到当前thread期间一直保持hibernate session在open状态，使session在request的整个期间都可以使用�Q�如在View层里PO也可以lazy loading数据�Q�如 ${ company.employees }。当View 层逻辑完成后，才会通过Filter的doFilter�Ҏ��或Interceptor的postHandle�Ҏ��自动关闭session�?/p>

OpenSessionInViewInterceptor配置





    class="org.springframework.orm.hibernate3.support.OpenSessionInViewInterceptor">










    class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">













        ...





    ...




OpenSessionInViewFilter配置




    ...



        hibernateFilter



          org.springframework.orm.hibernate3.support.OpenSessionInViewFilter







          singleSession

          true





    ...



        hibernateFilter

        *.do



    ...




很多人在使用OpenSessionInView�q�程中提及一个错误：


    org.springframework.dao.InvalidDataAccessApiUsageException: Write operations

    are not allowed in read-only mode (FlushMode.NEVER) - turn your Session into

    FlushMode.AUTO or remove 'readOnly' marker from transaction definition


看看OpenSessionInViewFilter里的几个�Ҏ��


    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response,FilterChain filterChain) throws ServletException, IOException {　SessionFactory sessionFactory = lookupSessionFactory();　logger.debug("Opening Hibernate Session in OpenSessionInViewFilter");　Session session = getSession(sessionFactory);　TransactionSynchronizationManager.bindResource(　　sessionFactory, new SessionHolder(session));　try {　　filterChain.doFilter(request, response);　}　finally {　TransactionSynchronizationManager.unbindResource(sessionFactory);　logger.debug("Closing Hibernate Session in OpenSessionInViewFilter");　closeSession(session, sessionFactory);　}}

    protected Session getSession(SessionFactory sessionFactory)throws DataAccessResourceFailureException {　Session session = SessionFactoryUtils.getSession(sessionFactory, true);　session.setFlushMode(FlushMode.NEVER);　return session;}
    protected void closeSession(Session session, SessionFactory sessionFactory)throws CleanupFailureDataAccessException {　SessionFactoryUtils.closeSessionIfNecessary(session, sessionFactory);}

           关于�l�定session的方式，通过看spring里TransactionSynchronizationManager的实玎ͼ�发现�Q�它�l�护一个java.lang.ThreadLocal�c�d��的resources�Q�resources负责持有�U�程局部变量，�q�里resources持有的是一个HashMap�Q�通过TransactionSynchronizationManager.bindResource()�Ҏ��在map里绑定和�U�程相关的所有变量到他们的标识上�Q�包括如上所�q�的�l�定在sessionFactory上的�U�程局部session。sessionHolder只不�q�是存放可以hold一个session�q�可以和transtaction同步的容器。可以看到OpenSessionInViewFilter在getSession的时�?会把获取回来的session的flush mode 设�ؓFlushMode.NEVER。然后把该sessionFactory�l�定到TransactionSynchronizationManager�Q��request的整个过�E�都使用同一个session�Q�在��h��q�后再接除该sessionFactory的绑定，最后closeSessionIfNecessary�Ҏ��该session是否已和transaction�l�定来决定是否关闭session。绑定以后，��可以防止每�ơ不会新开一个Session呢？看看HibernateDaoSupport的情况：

     1. public final void setSessionFactory(SessionFactory sessionFactory) {    2.      this.hibernateTemplate = new HibernateTemplate(sessionFactory);    3. }    4. protected final HibernateTemplate getHibernateTemplate() {    5.      return hibernateTemplate;    6. }
        我们的DAO��用这个template�q�行操作.

public abstract class BaseHibernateObjectDao extends HibernateDaoSupport
implements BaseObjectDao {
     protected BaseEntityObject getByClassId(final long id) {
                BaseEntityObject obj =(BaseEntityObject) getHibernateTemplate().execute(new HibernateCallback() {
                        public Object doInHibernate(Session session) throws HibernateException {
                                    return session.get(getPersistentClass(),new Long(id));
                        }
                });
                return obj;
      }
     public void save(BaseEntityObject entity) {
                  getHibernateTemplate().saveOrUpdate(entity);
     }

    public void remove(BaseEntityObject entity) {
              try {
                     getHibernateTemplate().delete(entity);
              } catch (Exception e) {
                      throw new FlexEnterpriseDataAccessException(e);
             }
     }

      public void refresh(final BaseEntityObject entity) {
               getHibernateTemplate().execute(new HibernateCallback() {
                          public Object doInHibernate(Session session) throws HibernateException {
                                      session.refresh(entity);
                                      return null;
                          }
               });
      }

     public void replicate(final Object entity) {
                getHibernateTemplate().execute(new HibernateCallback() {
                          public Object doInHibernate(Session session)throws HibernateException {
                                      session.replicate(entity,ReplicationMode.OVERWRITE);
                                      return null;
               }
                });
      }
}

        而HibernateTemplate试图每次在execute之前去获得Session�Q�执行完��力争关闭Session

1. public Object execute(HibernateCallback action) throws DataAccessException { 2.    Session session = (!this.allowCreate ? 3.          SessionFactoryUtils.getSession(getSessionFactory(),   4.                false) : 5.          SessionFactoryUtils.getSession(getSessionFactory(), 6.                 getEntityInterceptor(), 7.                 getJdbcExceptionTranslator())); 8.     boolean existingTransaction =    9.         TransactionSynchronizationManager.hasResource(getSessionFactory()); 10.    if (!existingTransaction && getFlushMode() == FLUSH_NEVER) { 11.          session.setFlushMode(FlushMode.NEVER); 12.    } 13.    try { 14.          Object result = action.doInHibernate(session); 15.          flushIfNecessary(session, existingTransaction); 16.          return result; 17.    } 18.    catch (HibernateException ex) { 19.          throw convertHibernateAccessException(ex); 20.    } 21.    finally { 22.          SessionFactoryUtils.closeSessionIfNecessary( 23.                  session, getSessionFactory()); 24.    } 25. }
      而这个SessionFactoryUtils能否得到当前的session以及closeSessionIfNecessary是否真正关闭session�Q�端取决于这个session是否用sessionHolder和这个sessionFactory在我们最开始提到的TransactionSynchronizationManager�l�定�?

     public static void closeSessionIfNecessary(Session session, SessionFactory sessionFactory)


          throws CleanupFailureDataAccessException {

        if (session == null || TransactionSynchronizationManager.hasResource(sessionFactory)) {

          return;

        }

        logger.debug("Closing Hibernate session");

        try {

          session.close();

        }

        catch (JDBCException ex) {

          // SQLException underneath

          throw new CleanupFailureDataAccessException("Could not close Hibernate session", ex.getSQLException());

        }

        catch (HibernateException ex) {

          throw new CleanupFailureDataAccessException("Could not close Hibernate session", ex);

        }

      }


    在这个过�E�中�Q�若HibernateTemplate 发现自当前session有不是readOnly的transaction�Q�就会获取到FlushMode.AUTO Session�Q��Ҏ��拥有写权限。也��x��Q�如果有不是readOnly的transaction��可以由Flush.NEVER转�ؓFlush.AUTO,拥有insert,update,delete操作权限�Q�如果没有transaction�Q��ƈ且没有另外�h为地设flush model的话�Q�则doFilter的整个过�E�都是Flush.NEVER。所以受transaction保护的方法有写权限，没受保护的则没有�?/p>
可能的解決方式有�Q?br>1、将singleSession设�ؓfalse�Q�这样只要改web.xml�Q�缺�Ҏ��Hibernate Session的Instance可能会大增，使用的JDBC Connection量也会大增，如果Connection Pool的maxPoolSize讑־�太小�Q�很�Ҏ��出问题�?br>2、在控制器中自行��理Session的FlushMode�Q�麻烦的是每个有Modify的Method都要多几行程式�?br>      session.setFlushMode(FlushMode.AUTO);
      session.update(user);
      session.flush();
3、Extend OpenSessionInViewFilter�Q�Override protected Session getSession(SessionFactory sessionFactory)�Q�将FlushMode直接改�ؓAuto�?br>4、让�Ҏ��受Spring的事务控制。这��是�怋�用的�Ҏ��Q?
采用spring的事务声�?使方法受transaction控制


                                                               PROPAGATION_REQUIRED,readOnly                 PROPAGATION_REQUIRED,readOnly                 PROPAGATION_REQUIRED,readOnly                 PROPAGATION_REQUIRED                 PROPAGATION_REQUIRED                 PROPAGATION_REQUIRED                 PROPAGATION_REQUIRED



对于上例�Q�则以save,add,update,remove开头的�Ҏ��拥有可写的事务，如果当前有某个方法，如命名�ؓimportExcel()�Q�则因没有transaction而没有写权限�Q�这时若�Ҏ��内有insert,update,delete操作的话�Q�则需要手动设�|�flush model为Flush.AUTO,�?/p>


         session.setFlushMode(FlushMode.AUTO);

         session.save(user);

         session.flush();



     ��管Open Session In View看�v来还不错�Q�其实副作用不少。看回上面OpenSessionInViewFilter的doFilterInternal�Ҏ��代码�Q�这个方法实际上是被父类的doFilter调用的，因此�Q�我们可以大�U�了解的OpenSessionInViewFilter调用��程: request(��h��)->open session�q�开始transaction->controller->View(Jsp)->�l�束transaction�q�close session.

     一切看��h��很正��，��其是在本地开发测试的时候没出现问题�Q�但试想下如果流�E�中的某一步被��d��的话�Q�那在这期间connection��׃��直被占用而不释放。最有可能被��d��的就是在写Jsp�q�步�Q�一斚w��可能是页面内容大�Q�response.write的时间长�Q�另一斚w��可能是网速慢�Q�服务器与用户间传输旉��久。当大量�q�样的情况出现时�Q�就有连接池�q�接不��Q�造成��面假死现象�?/p>
Open Session In View是个双刃剑，攑֜�公网上内容多��量大的�|�站��h��用�?/p>

另外�Q�这样会产生一点危险性，毕竟把数据库讉K��的环境放��C��表现层。（用VO�Q?br>

黎夕 2007-05-30 14:05 发表评论

Hibernate查询--(SQL)

黎夕 — Wed, 30 Aug 2006 14:59:00 GMT

Query queryObject = session.createSQLQuery(
"select {record.*}" +
" from " + tableName + " record, Vip_branch branch where branch.companyid = :companyid and branch.branchid = record.branchid order by record.time asc").
addEntity("record", Vip_record.class);
queryObject.setLong("companyid", companyid);
return queryObject.list();

其中tableName��?

得到�l�计�l�果也是�c�M��的：

Query queryObject = session.createSQLQuery(
"select count(*) as count" +
" from " + tableName +
" record where record.userid = :userid").
addScalar("count", Hibernate.INTEGER);

黎夕 2006-08-30 22:59 发表评论

拦截�?--Interceptor

黎夕 — Mon, 28 Aug 2006 12:07:00 GMT

Hibernate拦截器可以有两种:Session范围内的�Q�和SessionFactory范围内的�?

(1)当��用某个重载的SessionFactory.openSession()使用Interceptor作�ؓ参数调用打开一个session的时候，��指定了Session范围内的拦截器�?

Session session = sf.openSession( new AuditInterceptor() );

(2)SessionFactory范围内的拦截器要通过Configuration中注册，而这必须在创�?tt class="literal">SessionFactory之前。在�q�种情况下，�l�出的拦截器会被�q�个SessionFactory所打开的所有session使用了；除非session打开时明��指明了使用的拦截器�?tt class="literal">SessionFactory范围内的拦截器，必须是线�E�安全的�Q�因为多个session可能�q�发使用�q�个拦截器，要因此小心不要保存与session相关的状态�?

new Configuration().setInterceptor( new AuditInterceptor() );

package com.jason.interceptor;
import java.io.Serializable;
import org.hibernate.EmptyInterceptor;
import org.hibernate.Transaction;
import org.hibernate.type.Type;

public class UserInterceptor extends EmptyInterceptor {
    private int updates;
    private int creates;
    private int loads;
    public void onDelete(Object entity,
                         Serializable id,
                         Object[] state,
                         String[] propertyNames,
                         Type[] types) {
        // do nothing
    }
    public boolean onFlushDirty(Object entity,
                                Serializable id,
                                Object[] currentState,
                                Object[] previousState,
                                String[] propertyNames,
                                Type[] types) {
        if ( entity instanceof User ) {
            updates++;

        }
        return false;
    }
    public boolean onLoad(Object entity,
                          Serializable id,
                          Object[] state,
                          String[] propertyNames,
                          Type[] types) {
        if ( entity instanceof User ) {
            loads++;
            for ( int i=0; i                if ( "password".equals( propertyNames[i] ) ) {
                String temp = (state[i]).toString();
                    state[i] = temp.substring(3, temp.length()-3);
                    return true;
                }
            }
        }
        return false;
    }
    public boolean onSave(Object entity,
                          Serializable id,
                          Object[] state,
                          String[] propertyNames,
                          Type[] types) {
        if ( entity instanceof User ) {
            creates++;
            for ( int i=0; i                if ( "password".equals( propertyNames[i] ) ) {
                    state[i] = "abc" +state[i] + "xyz";
                    return true;
                }
            }
        }
        return false;
    }
    public void afterTransactionCompletion(Transaction tx) {
        if ( tx.wasCommitted() ) {
            System.out.println("Creations: "
+ creates + ", Updates: " + updates + ",Loads: " + loads);
        }
        updates=0;
        creates=0;
        loads=0;
    }
}

【注】String[] propertyNames -- 属性名�U?br /> Object[] state -- 属性对应的�?br />

test:
Session session = sf.openSession(new UserInterceptor());

session.load(class, id);
session.save(obj);

黎夕 2006-08-28 20:07 发表评论

Hibernate查询--(Criteria Query)

黎夕 — Mon, 28 Aug 2006 11:36:00 GMT

Hibernate条�g查询(Criteria Query)

1、创��Z��个Criteria实例
net.sf.hibernate.Criteria�q�个接口代表对一个特定的持久化类的查询。Session是用来制造Criteria实例的工厂。�?/font>

Criteria crit = sess.createCriteria(Cat.class);
crit.setMaxResults(50);
List cats = crit.list();

2、羃��结果集范围
一个查询条�?Criterion)是net.sf.hibernate.expression.Criterion接口的一个实例。类net.sf.hibernate.expression.Expression定义了获得一些内�|�的Criterion�c�d��。�?/font>

List cats = sess.createCriteria(Cat.class)
    .add( Expression.like("name", "Fritz%") )
    .add( Expression.between("weight", minWeight, maxWeight) )
    .list();
表达式（Expressions�Q�可以按照逻辑分组.

List cats = sess.createCriteria(Cat.class)
    .add( Expression.like("name", "Fritz%") )
    .add( Expression.or(
     Expression.eq( "age", new Integer(0) ),
     Expression.isNull("age")
    ) )
    .list();
List cats = sess.createCriteria(Cat.class)
    .add( Expression.in( "name", new String[] { "Fritz", "Izi", "Pk" } ) )
    .add( Expression.disjunction()
        .add( Expression.isNull("age") )
     .add( Expression.eq("age", new Integer(0) ) )
     .add( Expression.eq("age", new Integer(1) ) )
     .add( Expression.eq("age", new Integer(2) ) )
    ) )
    .list();
有很多预制的条�g�c�d��Q�Expression的子�c�）。有一个特别有用，可以让你直接嵌入SQL。�?/font>

List cats = sess.createCriteria(Cat.class)
    .add( Expression.sql("lower($alias.name) like lower(?)", "Fritz%", Hibernate.STRING) )
    .list();
其中的{alias}是一个占位符�Q�它��会被所查询实体的行别名所替代�?原文:The {alias} placeholder with be replaced by the row alias of the queried entity.)

3、对�l�果排序
可以使用net.sf.hibernate.expression.Order对结果集排序.

List cats = sess.createCriteria(Cat.class)
    .add( Expression.like("name", "F%")
    .addOrder( Order.asc("name") )
    .addOrder( Order.desc("age") )
    .setMaxResults(50)
    .list();
4、关联（Associations�Q?/strong>
你可以在兌��之间使用createCriteria()�Q�很�Ҏ��地在存在关系的实体之间指定约束。�?/font>

List cats = sess.createCriteria(Cat.class)
    .add( Expression.like("name", "F%")
    .createCriteria("kittens")
        .add( Expression.like("name", "F%")
    .list();
注意�Q�第二个createCriteria()�q�回一个Criteria的新实例�Q�指向kittens集合�cȝ��元素。�?/font>

下面的替代�Ş式在特定情况下有用。�?/font>

List cats = sess.createCriteria(Cat.class)
    .createAlias("kittens", "kt")
    .createAlias("mate", "mt")
    .add( Expression.eqProperty("kt.name", "mt.name") )
    .list();
�Q�createAlias()�Q��ƈ不会创徏一个Criteria的新实例。）

��h��意，前面两个查询中Cat实例所持有的kittens集合�c�dƈ没有通过criteria预先�q��o�Q�如果你希望只返回满��x��件的kittens,你必��M��用returnMaps()。�?/font>

List cats = sess.createCriteria(Cat.class)
    .createCriteria("kittens", "kt")
        .add( Expression.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、动态关联对象获取（Dynamic association fetching�Q?br />可以在运行时通过setFetchMode()来改变关联对象自动获取的�{�略。�?/font>

List cats = sess.createCriteria(Cat.class)
    .add( Expression.like("name", "Fritz%") )
    .setFetchMode("mate", FetchMode.EAGER)
    .list();
�q�个查询会通过外连�?outer join)同时获得 mate和kittens。�?/font>

6、根据示例查询（Example queries�Q?/strong>
net.sf.hibernate.expression.Example�c�d��怽�从指定的实例创造查询条件。�?/font>

Cat cat = new Cat();
cat.setSex('F');
cat.setColor(Color.BLACK);
List results = session.createCriteria(Cat.class)
    .add( Example.create(cat) )
    .list();
版本属性，表示�W�属性和兌��都会被忽略。默认情况下�Q�null值的属性也被排除在外。�?/font>

You can adjust how the Example is applied. 你可以调整示�?Example)如何应用。�?/font>

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();
你甚臛_��以用�C�Z��对关联对象徏立criteria。�?/font>

List results = session.createCriteria(Cat.class)
    .add( Example.create(cat) )
    .createCriteria("mate")
        .add( Example.create( cat.getMate() ) )
    .list();

黎夕 2006-08-28 19:36 发表评论

Hibernate查询--(HQL)

黎夕 — Mon, 28 Aug 2006 06:47:00 GMT

//HQL-Associations
String hql = "select s.name, p.name, p.price from Product p inner join p.supplier as s";
Query query = session.createQuery(hql);
List results = query.list();

//HQL-Delete
String hql = "delete from Product where name = :name";
Query query = session.createQuery(hql);
query.setString("name","Product 1");
int rowCount = query.executeUpdate();

//HQL-Function
String hql = "select min(product.price), max(product.price) from Product product";
Query query = session.createQuery(hql);
List results = query.list();

//HQL-Fetch Associations HQL Inner Join
String hql = "from Supplier s inner join fetch s.products as p";
Query query = session.createQuery(hql);
List results = query.list();

//HQL-Named Parameters
String hql = "from Product where price > :price";
Query query = session.createQuery(hql);
query.setDouble("price",2.0);
List results = query.list();
String hql = "from Product as product where product.supplier=:supplier";
Query query = session.createQuery(hql);
query.setEntity("supplier",supplier);
List results = query.list();

//HQL-Update
String hql = "update Supplier set name = :newName where name = :name";
Query query = session.createQuery(hql);
query.setString("name","Supplier Name 1");
query.setString("newName","s1");
int rowCount = query.executeUpdate();

//HQL-where
String hql = "from Product where price > 2.0 and name like 'P%'";
Query query = session.createQuery(hql);
List results = query.list();

//HQL-Map
String hql = " select new map(usr.name as userName, usr.password as password) from User usr";
Query query = session.createQuery(hql);
List list = query.list();
Map goods =(Map)list.get(0);

【注�?br />    String hql = " select new map(usr.name as userName, usr.password as password)　from com.jason.User usr";
   String hql = " select new map(usr.name as userName, usr.password as password) from com.jason.User usr";
�׃��from之前的空��|��引�vunexpected token: 　from

查询语句可以�q�回��gؓ��M��c�d��的属性或对象�Q�包括返回类型�ؓ某种�l��g(Component)的属�?
select cust.name.firstName from Customer as cust
select cat.mate from Cat cat

查询语句可以�q�回多个对象和（或）属性，存放�?span class="Apple-converted-space"> select mother, offspr, mate.name from DomesticCat as mother     inner join mother.mate as mate     left join mother.kittens as offspr
或存攑֜�一�?tt class="literal">new list(mother, offspr, mate.name) from DomesticCat as mother     inner join mother.mate as mate     left outer join mother.kittens as offspr 也可能直接返回一个实际的�c�d��安全的Java对象(假设�c?tt class="literal">new Family(mother, mate, offspr) from DomesticCat as mother     join mother.mate as mate     left join mother.kittens as offspr 也可以��用关键字max, min(bodyWeight) as min, count(*) as n from Cat cat �q�种做法在与子句new map( max(bodyWeight) as max, min(bodyWeight) as min, count(*) as n ) from Cat cat

黎夕 2006-08-28 14:47 发表评论

composite-id 学习

黎夕 — Thu, 24 Aug 2006 02:42:00 GMT

�l��g作�ؓ联合标识�W?必须满��Q?
它必��d��现java.io.Serializable接口
它必��重新实现equals()和hashCode()�Ҏ��, 始终和组合关键字在数据库中的概念保持一�?
你不能��用一个IdentifierGenerator产生�l�合关键字。一个应用程序必��d��配它自己的标识符�?
【注意：在Hibernate3中，�W�二个要求�ƈ非是Hibernate强制必须的。但最好这样做。�?br />







public class CompositeId implements Serializable{
private int orderId;
private int itemId;
public int getItemId() {
  return itemId;
}
public void setItemId(int itemId) {
  this.itemId = itemId;
}
public int getOrderId() {
  return orderId;
}
public void setOrderId(int orderId) {
  this.orderId = orderId;
}
@Override
public boolean equals(Object obj) {
  return super.equals(obj);
}
@Override
public int hashCode() {
  return (orderId + itemId)^2;
}

}

public class OrderDetail {
private CompositeId id;
private int count;

public int getCount() {
  return count;
}
public void setCount(int count) {
  this.count = count;
}
public CompositeId getId() {
  return id;
}
public void setId(CompositeId id) {
  this.id = id;
}
}

黎夕 2006-08-24 10:42 发表评论

集合映射

黎夕 — Wed, 23 Aug 2006 08:49:00 GMT

Array


















Bag

















Set
















Map












黎夕 2006-08-23 16:49 发表评论

兌��映射----->>>�ȝ��

黎夕 — Sun, 20 Aug 2006 16:31:00 GMT

set的��?br />

      class="com.jason.associations.one2many.unilateralism.one2many.Address"/>


                unique="true"
          class="com.jason.associations.one2many.unilateralism.one2many.table.Address"/>

兌��表的使用


          column="addressId"
       not-null="true"
       cascade="all"
       .../>

//set,Array,bag,map都行


                  unique="true"
           class="com.jason.associations.one2many.unilateralism.one2many.table.Address"/>





<many-to-one name="address"
   class="com.jason.associations.one2one.unilateralism.foreign.Address"
   unique="true"
   column="addressId"
   cascade="all"
   not-null="true"/>
<one-to-one name="person"
   class="com.jason.associations.one2one.unilateralism.primary.Person"
   constrained="true"/>

1、都表示一对一 ,many-to-one指定了对应的column�Q�和column相关的属性cascade�Q�not-null...�Q?br />       而one-to-one没有对应的column�Q�它主要用于id的generator class="foreign"�?br />2、同样也适用�?lt;many-to-many unique="true">�?lt;one-to-many>

不管哪个�Q�对应的表是�q�样的，把one那张表的key�Q�放到many对应的表中，相当于外键�?/p>

      class="com.jason.associations.one2many.unilateralism.one2many.Address"/>


   person


  class="com.jason.associations.one2one.unilateralism.primary.Person"
  constrained="true"/>

�?lt;one-to-one>都没有column属性，因�ؓone对应的那边不需要相应的列，
那么如何保持关系呢？
1、最好不使用�Q?img height="19" src="http://www.tkk7.com/Emoticons/emsmilep.gif" width="19" border="0" />
2、向上面那样指定一�?/p>

column的位�|?br />1、大多数时候在�q�个class对应的表�?br />2、在兌��表中
3、在指定的class对应的表�?br />例如�Q?br />

      class="com.jason.associations.one2many.unilateralism.one2many.Address"/>


unique
    unique="true"
    ..."/>
unique是相对于前面的many

inverse




            inverse="true"
        optional="true">

                    column="personId"
            not-null="true"/>


         1、�ؓ了更好地提高执行效率�Q�需要将“多”的一端设��Z��控方�Q�就是将兌��关系的维护工作交�l�“多”的一端。inverse="true" 说明��L��表是Person表（Address表对面）inverse="false"本��n�Q�默认��|��false

   2�?font face="Courier New">inverse="true"可以出现在关联的��L��一端，即collection端或者join端�?/p>
Constrained : �U�束�Q�表明主控表的主键上是否存在一个外键（foreigh key�Q�对其进行约束�?br />
property-ref:兌��c�M��用于与主控类相关联的属性名�Q�默认�ؓ兌��cȝ��主键属性名

lazy=false:被动方的记录由hibernate负责记取�Q�之后存攑֜��L��Ҏ��定的   Collection�c�d��属性中

batch-size:采用延迟加蝲特征�Ӟ��一�ơ读入的数据数昨

黎夕 2006-08-21 00:31 发表评论

many2many兌��

黎夕 — Sun, 20 Aug 2006 16:28:00 GMT

多对多相对于�q�接表的�Q�有两种
1、��用连接表的单向多对多兌��






       column="addressId"
    class="com.jason.associations.many2many.unilateralism.Address"/>









2、��用连接表的双向多对多兌��






       column="addressId"
    class="com.jason.associations.many2many.both.Address"/>








       column="personId"
    class="com.jason.associations.many2many.both.Person"/>




黎夕 2006-08-21 00:28 发表评论

one2many兌��

黎夕 — Fri, 18 Aug 2006 09:21:00 GMT
二、单向关�p?br /> 1.“单向一对多关系�?br /> ��Z��外键兌��的单向一对多兌��是一�U�很��见的情况，�q�不推荐使用







                class="com.jason.associations.one2many.unilateralism.one2many.Address"/>









2.“单向多对一关系�?br />



         class="com.jason.associations.one2many.unilateralism.many2one.Address"
       column="addressId"
       cascade="all"
       outer-join="auto"
       update="true"
       insert="true"
       access="property"
       not-null="true"/>








3、“单向一对多�q�接表关�p�Z�?br />






                unique="true"
          class="com.jason.associations.one2many.unilateralism.one2many.table.Address"/>









4、“单向多对一�q�接表关�p�Z�?br /> 我们认�ؓ对于�q�种兌��关系最好��用连接表�?br />







                             class="com.jason.associations.one2many.unilateralism.many2one.table.Address"
                  column="addressId"
                  not-null="true"
                  cascade="all"/>








二、双向关�p?br /> 双向一对多关系��是二者的�l�合
��Z��更好地提高执行效率，需要将“多”的一端设��Z��控方�Q�就是将兌��关系的维护工作交�l�“多”的一端�?img src ="http://www.tkk7.com/gm_jing/aggbug/64407.html" width = "1" height = "1" />

黎夕 2006-08-18 17:21 发表评论

one2one兌��

黎夕 — Thu, 17 Aug 2006 09:16:00 GMT

one2one

1、基于外键关联的单向一对一兌��
   和单向多对一兌��几乎是一��L��。唯一的不同就是单向一对一兌��中的外键字段��h��唯一性约束�?




     class="com.jason.associations.one2one.unilateralism.foreign.Address"
   column="addressId"
      unique="true"
      cascade="all"
      not-null="true"/>





2、基于主键关联的单向一对一兌��
   通常使用一个特定的id生成器。（��h��意，在这个例子中我们掉换了关联的方向。）







    person


     class="com.jason.associations.one2one.unilateralism.primary.Person"
   constrained="true"/>

3、基于连接表的单向一对一兌��非常��见�Q�但也是可行的�?







                          column="addressId"
               not-null="true"
            cascade="all"
               unique="true"/>






4、对应的双向兌��
a、单向关联和双向兌��使用的表是一��L��
b、双向关联类中多了属�?br />c、双向关联可以从��M��一个对象开始操作（比如��d��Q�，而单向只能从特定的一�Ҏ��?/p>

黎夕 2006-08-17 17:16 发表评论

�l��g映射

黎夕 — Mon, 07 Aug 2006 15:16:00 GMT

�l��g(Component)是一个被包含的对象，在持久化的过�E�中�Q�它被当作值类型，而�ƈ非一个实体的引用。在�q�篇文��中，�l��g�q�一术语指的是面向对象的合成概念.
·user.java

User.java

package com.jason.component;

public class User{
private Integer id;
private String name;
private String password;
private Contact contact;

/**
* @return Returns the id.
*/
public Integer getId() {
  return id;
}
/**
* @param id The id to set.
*/
public void setId(Integer id) {
  this.id = id;
}
/**
* @return Returns the name.
*/
public String getName() {
  return name;
}
/**
* @param name The name to set.
*/
public void setName(String name) {
  this.name = name;
}
/**
* @return Returns the password.
*/
public String getPassword() {
  return password;
}
/**
* @param password The password to set.
*/
public void setPassword(String password) {
  this.password = password;
}
/**
* @return Returns the contact.
*/
public Contact getContact() {
  return contact;
}
/**
* @param contact The contact to set.
*/
public void setContact(Contact contact) {
  this.contact = contact;
}
}

· contact.java

Contact.java

package com.jason.component;

public class Contact {
private String email;
private String address;

/**
* @return Returns the address.
*/
public String getAddress() {
  return address;
}
/**
* @param address The address to set.
*/
public void setAddress(String address) {
  this.address = address;
}
/**
* @return Returns the email.
*/
public String getEmail() {
  return email;
}
/**
* @param email The email to set.
*/
public void setEmail(String email) {
  this.email = email;
}
}

· User.hbm.xml

User.hbm.xml

"-//Hibernate/Hibernate Mapping DTD//EN"
"

   name="User"
  table="user"
>
  false

     name="Id"
   type="integer"
   column="id"
  >



     name="Name"
   column="name"
   type="string"
   not-null="true"
   length="20"
  />
     name="Password"
   column="password"
   type="string"
   not-null="true"
   length="20"
  />


       column="email"
    length="50"
    name="Email"
    not-null="false"
    type="string"
    />
       column="address"
    length="100"
    name="Address"
    not-null="false"
    type="string"
    />




testComponent.java

package com.jason.component;

import java.util.List;
import java.util.ListIterator;

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

public class testComponent {
    public static void main(String[] args) throws HibernateException {
        SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();

        testInsert(sessionFactory);
        testQuery(sessionFactory);

        sessionFactory.close();

    }
    public static void testInsert( SessionFactory sessionFactory )throws HibernateException {

      Session session = sessionFactory.openSession();
        Transaction tx= session.beginTransaction();
        User user = new User();
        Contact contact=new Contact();
        contact.setEmail("gm_jing@yahoo.com.cn");
        contact.setAddress("beijing");

        user.setName("gm_jing");
        user.setPassword("1111111");
        user.setContact(contact);

        session.save(user);
        tx.commit();
        session.close();
        System.out.println("OK�Q?);
   }

    public static void testQuery( SessionFactory sessionFactory )throws HibernateException {

     Session session = sessionFactory.openSession();
        Transaction tx= session.beginTransaction();
        User user = new User();

        Query query=session.createQuery("from User as user");
        //query.setCharacter(1, 'M');
        List names =query.list();
        for(ListIterator it=names.listIterator();it.hasNext();){
           user= (User)it.next();
           System.out.println("Id: " + user.getId());
            System.out.println("name: " + user.getName());
            System.out.println("password: " + user.getPassword());
            if(user.getContact()!=null){

             if(user.getContact().getEmail()!=null){
              System.out.println("Email: " + user.getContact().getEmail());
             }
             if(user.getContact().getAddress()!=null){
              System.out.println("Address: " + user.getContact().getAddress());

             }
            }

        }

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

    }
}

��像所有的值类型一�? �l��g不支持共享引用�?换句话说�Q�两个Contact可能相同�Q�但是两个User对象应该包含两个独立的Contact对象�Q�只不过�q�两个Contact对象��h��“同样”的倹{�?�l��g的值可以�ؓ�I�，其定义如下�?每当Hibernate重新加蝲一个包含组件的对象,如果该组件的所有字�D��ؓ�I�，Hibernate��假定整个组件�ؓ�I��?在大多数情况�?�q�样假定应该是没有问题的�?

黎夕 2006-08-07 23:16 发表评论

�l�承映射----->>>三种�ȝ��

黎夕 — Mon, 07 Aug 2006 14:00:00 GMT

每个�c�d��层结构一张表

每个子类一个表

每个具体�c�M��个表

表的个数

1

n

n-1

父表

一个表

1

0

子表

n-1

n-1

表的字段

每个�cȝ��所有属性＋�c�d��鉴别

父表 --> 父类属�?/span>
子表 --> 子类属性＋父类 id

子表 --> 子类属性＋父类属�?/span>

表的兌�� / 表的唯一

�c�d��鉴别标识

父类 id

id

黎夕 2006-08-07 22:00 发表评论

�l�承映射3 --每个具体�c�M��个表

黎夕 — Mon, 07 Aug 2006 08:17:00 GMT

   每个具体�c�M��个表的方式是只有具体�c�d��应一张表�Q�包括父�c�d��子类�Q?font color="#0000ff">父类和子�cȝ��关系是通过
在子�c�M��保存父类的id来实现的�?font color="#000000">所以保存一条子�cȝ��信息需要同时向父类和子�cȝ��表中插入记录�?/font>

一个例子如下：
· �c�Person.java

package com.jason.inheritance.three;

public abstract class Person {
private Long id;

private String name;

/**
* @hibernate.id
*   column="ID"
*   generator-class="hilo"
*   unsaved-value="null"
*/
public Long getId() {
  return id;
}

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

/**
* @hibernate.property
*   length = "24"
*/
public String getName() {
  return name;
}

public void setName(String name) {
  this.name = name;
}
}

· 子类Professor.java
package com.jason.inheritance.three;
public class Professor extends Person {
private int salary;
/**
* @hibernate.property
*/
public int getSalary() {
  return salary;
}
public void setSalary(int salary) {
  this.salary = salary;
}
}

· 子类Student.java
package com.jason.inheritance.three;
public class Student extends Person {
private String studentNumber;
/**
* @hibernate.property
*   length = "24"
*/
public String getStudentNumber() {
  return studentNumber;
}
public void setStudentNumber(String studentNumber) {
  this.studentNumber = studentNumber;
}
}

· Professor.hbm.xml

"

   dynamic-update="false" dynamic-insert="false" select-before-update="false"
  optimistic-lock="version">






     access="property" column="salary"/>

     access="property" column="name" length="24"/>


· Student.hbm.xml

"

   dynamic-update="false" dynamic-insert="false" select-before-update="false"
  optimistic-lock="version">






     insert="true" access="property" column="studentNumber" length="24"/>

     access="property" column="name" length="24"/>


      昄��对应的表�?br />      professor(id, name, salary)
      student(id, name, studentNumber)
      插入记录的sql如下�Q?br />      Hibernate: insert into Student (studentNumber, name, ID) values (?, ?, ?)

● 优点：
· 报表操作实现��单：表中包含了具体子�cȝ��所有信息�?

�?�~�点�Q?br />· �cȝ��修改会导致相对应的表及其子类所对应表的更改�?br />· 当含有多重子�c�L��Q�会造成在数据库表格中生成重复的字段�?br />

参考：

· HIBERNATE - �W�合Java习惯的关�p�L��据库持久化（�W?章）

· Hibernate ��化��承映��?/a>

· Mapping Objects to Relational Databases: O/R Mapping In Detail

· Mapping objects to relational databases

黎夕 2006-08-07 16:17 发表评论

�l�承映射2 --每个子类一个表

黎夕 — Thu, 03 Aug 2006 14:11:00 GMT

   每个子类一个表的方式是��所有的�cȝ��成一个表�Q�包括父�c�）�Q�保存子�cȝ��时候，同时向父�c�d��子类��d��数据�Q�然后把父类中生成的id�Q�保存到子类中，保持兌��。在�q�个主题中我们将先说明这个方法�?br />

一个例子如下：
· �c�Vehicle.java

package com.jason.inheritance.two;

public class Vehicle {
private Long id;

private String name;

/**
* @hibernate.id
*   column="ID"
*   generator-class="hilo"
*   unsaved-value="null"
*/
public Long getId() {
  return id;
}

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

/**
* @hibernate.property
*   length = "24"
*/
public String getName() {
  return name;
}

public void setName(String name) {
  this.name = name;
}

}

· 子类Car.java

package com.jason.inheritance.two;

public class Car extends Vehicle {
private String seat;
public String getSeat() {
  return seat;
}

public void setSeat(String seat) {
  this.seat = seat;
}
}

· 子类Truck.java

package com.jason.inheritance.two;

public class Truck extends Vehicle {
private String load;
public String getLoad() {
  return load;
}

public void setLoad(String load) {
  this.load = load;
}
}

· Vehicle.hbm.xml

"

  dynamic-insert="false" select-before-update="false"
  optimistic-lock="version">







      access="property" column="name" length="24"/>

   name="com.jason.inheritance.two.Truck"
   dynamic-update="false" dynamic-insert="false">

        insert="true" access="property" column="loads" length="24"/>


   name="com.jason.inheritance.two.Car"
   dynamic-update="false" dynamic-insert="false">

        insert="true" access="property" column="seat" length="24"/>




      昄��对应的表�?br />       vehicle(id, name)        car(id, seat)          truck(id, loads)
      需要注意的是：car/truck 中的id 和vehicle中的id是一一对应的�?/font>
      /*
      Truck truck = new Truck();
      truck.setName("襉K��卡�R");
      truck.setLoad("10ton");
      sess.save(truck);*/
   插入记录的sql如下�Q?br />    Hibernate: insert into Vehicle (name, ID) values (?, ?)
   Hibernate: insert into Truck (loads, id) values (?, ?)
   保存一条truck信息�Q�要先在Vehicle中保存记录，得到id�Q�然后把得到的id和需要的��g��同保存到Truck中�?br />

�?nbsp;优点�Q?br /> · 与面向对象的概念的一致性最好。对多态的支持最好，对于对象所可能充当的角色仅需要在相应的表中保存记录�?br /> · 易于修改基类和增加新的类�?/div>
· �q�种映射几乎有最佳的�I�间节约性。唯一的容易就是额外的OID�Q�来�q�接不同的层�U�层�ơ�?

�?�~�点�Q?br /> · 数据库中存在大量的表�?br /> · 讉K��数据的时间较�ѝ��在��d��相关的�Q务上�Q�这�U�映��方式相当费资源�Q�这个代仯��随着�l�承层次的增多而增大�?
· �Ҏ��表的支持较差�Q�除非定义视图�?/div>

参考：

· HIBERNATE - �W�合Java习惯的关�p�L��据库持久化（�W?章）

· Hibernate ��化��承映��?/a>

· Mapping Objects to Relational Databases: O/R Mapping In Detail

· Mapping objects to relational databases

黎夕 2006-08-03 22:11 发表评论

�l�承映射1 --每个�c�d��层结构一张表

黎夕 — Tue, 01 Aug 2006 08:14:00 GMT

Hibernate中有以下三种�{�略��这�U�关�p�L��到数据表上�Q?br /> · 每个�c�d��ơ结构一个表�Q�table per class hierarchy�Q?br /> · 每个子类一个表(table per subclass)
· 每个具体�c�M��个表(table per concrete class)�Q�有一些限�Ӟ��

   每个�c�d��ơ结构一个表的方式是��所有��承同一父类别的对象储存在同一个表��g��Q��ؓ了做到这一点，
需要在表中使用识别字段来表�C�某一列（row�Q�是属于某个子类别或父类�?/font>�Q�在�q�个主题中我们将先说明这个方法�?br />

一个例子如下：
· �c�Animal.java

Animal.java

package com.jason.inheritance;

/**
* @hibernate.class
*   table="Animal"
*   discriminator-value="Animal"
* @hibernate.discriminator
*   column="ANIMAL_TYPE"
*   type="string"
*   length = "10"
*/
public class Animal {
private Long id;

private String name;

/**
* @hibernate.id
*   column="ID"
*   generator-class="hilo"
*   unsaved-value="null"
*/
public Long getId() {
  return id;
}

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

/**
* @hibernate.property
*   length = "24"
*/
public String getName() {
  return name;
}

public void setName(String name) {
  this.name = name;
}

public void makeSound(){};
}

· 子类Cat.java

package com.jason.inheritance;
public class Cat extends Animal { privateString FurColor; publicvoid makeSound() { System.out.println("喵喵"); } publicString getFurColor() { return FurColor; } publicvoid setFurColor(String furColor) { FurColor = furColor; } }

· 子类Dog.java

package com.jason.inheritance;

/**
* @hibernate.subclass
*   discriminator-value="Dog"
*/
public class Dog extends Animal {
private String category;

public void makeSound() {
  System.out.println("汪汪");
}

/**
* @hibernate.property
*   length = "24"
*/
public String getCategory() {
  return category;
}

public void setCategory(String category) {
  this.category = category;
}
}

· Animal.hbm.xml

"

  dynamic-update="false" dynamic-insert="true" select-before-update="false"
  optimistic-lock="version" discriminator-value="Animal">








      access="property" column="name" length="24"/>

      dynamic-insert="false" discriminator-value="Cat">

        insert="true" access="property" column="furColor" length="24"/>

      dynamic-insert="false" discriminator-value="Dog">

        insert="true" access="property" column="category" length="24"/>



      昄��对应的表是Animal�Q�ID, ANIMAL_TYPE, name, furColor, category�Q?br />       需要在表中使用识别字段来表�C�某一列（row�Q�是属于某个子类别或父类�?
��是用ANIMAL_TYPE来表�C�的�Q?br />       插入记录的sql如下�Q?br /> Hibernate: insert into Animal (name, ANIMAL_TYPE, ID) values (?, 'Animal', ?)
Hibernate: insert into Animal (name, furColor, ANIMAL_TYPE, ID) values (?, ?, 'Cat', ?)
Hibernate: insert into Animal (name, category, ANIMAL_TYPE, ID) values (?, ?, 'Dog', ?)

�?nbsp;优点�Q?br /> · 实现��单�?br /> · 支持多态——对象角色发生变化，或存在多重角色时�?br /> · 报表操作实现��单：表中包含了所有信息�?/div>

�?�~�点�Q?br /> · 增加�c�d��ơ中的耦合。类层次中�Q何类的属性的增加都会��D��表的变更�Q�某个子�c�d��性的修改会媄响到整个层次�l�构�Q�而不仅仅是该子类�?br /> · ��费了一些数据库�I�间。浪费空间的多少取决于��承层�ơ的深度。层�ơ越深，不同的属性越多，属性的全集��p��大，也就��浪费空间�?br /> · 要求由子�c�d��义的字段不能有非�I�（NOT NULL�Q�约�?/span>�?br />

参考：

· HIBERNATE - �W�合Java习惯的关�p�L��据库持久化（�W?章）

· Hibernate ��化��承映��?/a>

· Mapping Objects to Relational Databases: O/R Mapping In Detail

· Mapping objects to relational databases

黎夕 2006-08-01 16:14 发表评论

黎夕 — Thu, 20 Jul 2006 16:44:00 GMT
1.Criteria
   Criteria criteria = session.createCriteria(User.class);
   criteria.add(Expression.eq("name","liping"));
   //criteria.add(Example.create(user));
   List userList = criteria.list();

2.HQL
   String hql = "from org.hibernate.sample.TUser";
   Query query = session.createQuery(hql);
   List userList = query.list();

3.SQL
   List cats = session.createSQLQuery(
    "SELECT {cat.*} FROM CAT {cat} WHERE ROWNUM<10",
    "cat",Cat.class).list();

4.GET
   User user = session.get("com.jason.User", new Long(69));
    ...
5.Load
   User user = (User) session.load( User.class, new Long(69) );
   ...
//Session.load(Class theClass, Serializable id) �q�个id的类型，对应于theClass中id的类型�?br />

6.Session.find/iterate
List users = session.find("from user");

黎夕 2006-07-21 00:44 发表评论

Hibernate的锁

黎夕 — Wed, 19 Jul 2006 17:49:00 GMT

【引用�?a >http://www.tongyi.net/develop/Java/1025649.html

Hibernate的加锁模式有�Q?br />
Ø LockMode.WRITE �Q�Hibernate在Insert和Update记录的时候会自动获取�?br />         �q�种锁机制一般由Hibernate内部使用�Q�如Hibernate��Z��保证Update�q�程中对象不会被外界修改�Q�会在save�Ҏ��实现中自动�ؓ目标对象加上WRITE锁�?br />
Ø LockMode.NONE �Q?无锁机制�?br />Ø LockMode.READ �Q?Hibernate在读取记录的时候会自动获取�?/select id from User where id =?
Ø LockMode.UPGRADE �Q�利用数据库的for update子句加锁�?/select id from User where id =? for update
Ø LockMode. UPGRADE_NOWAIT �Q�Oracle的特定实玎ͼ�利用Oracle的for update nowait子句实现加锁�?br />上面�q�几�U�锁机制是我们在应用层较为常用的�Q�加锁一般通过以下�Ҏ��实现�Q?br />Criteria.setLockMode
Query.setLockMode
Session.lock
注意�Q�只有在查询开始之前（也就是Hiberate 生成SQL 之前�Q�设定加锁，才会
真正通过数据库的锁机制进行加锁处理，否则�Q�数据已�l�通过不包含for update
子句的Select SQL加蝲�q�来�Q�所谓数据库加锁也就无从谈�v�?/font>

Hibernate 在其数据讉K��引擎中内�|�了乐观锁实现。如果不用考虑外部�pȝ��Ҏ��据库的更新操作，
利用Hibernate提供的透明化乐观锁实现�Q�将大大提升我们的生产力�?br />Hibernate中可以通过class描述�W�的optimistic-lock属性结合version描述�W�指定�?br />现在�Q�我们�ؓ之前�C�Z��中的TUser加上乐观锁机制�?br />1�Q?首先为TUser的class描述�W�添加optimistic-lock属性：

name="org.hibernate.sample.TUser"
table="t_user"
dynamic-update="true"
dynamic-insert="true"
optimistic-lock="version"
>
…�?br />
optimistic-lock属性有如下可选取��|��
Ø none
无乐观锁
Ø version
通过版本机制实现乐观�?br />Ø dirty
通过��查发生变动过的属性实��C��观锁
Ø all
通过��查所有属性实��C��观锁
其中通过version实现的乐观锁机制是Hibernate官方推荐的乐观锁实现�Q�同时也
是Hibernate中，目前唯一在数据对象脱��Session发生修改的情况下依然有效的锁�?br />制。因此，一般情况下�Q�我们都选择version方式作�ؓHibernate乐观锁实现机制�?/p>

黎夕 2006-07-20 01:49 发表评论

Session�Ҏ��

黎夕 — Tue, 18 Jul 2006 16:51:00 GMT

      Session.get/load的区别：
      1.如果未能发现�W�合条�g的记录，get�Ҏ��q�回null�Q�而load�Ҏ��会抛��Z��个ObejctNotFoundException�?br />       2.Load�Ҏ��可返回实体的代理�cȝ��型，而get�Ҏ��永远直接�q�回实体�c�R�?br />       3.Load�Ҏ��可以充分利用内部�~�存和二�U�缓存中现有数据�Q�而get�Ҏ��则仅仅在内部�~�存中进行数据查找，如没有发现对应数据，��越�q�二�U�缓存，直接调用SQL完成数据��d��?

      Session.find/iterate的区别：
      find�Ҏ��执行Select SQL从数据库中获得所有符合条件的记录�q�构造相应的实体对象�Q�实体对象构建完毕之后，��将其纳入缓存。它对缓存只写不读，因此无法利用�~�存�?br />       iterate�Ҏ��首先执行一条Select SQL以获得所有符合查询条件的数据id�Q�随卻I��iterate�Ҏ��首先在本地缓存中�Ҏ��id查找对应的实体对象是否存在，如果�~�存中已�l�存在对应的数据�Q�则直接以此数据对象作�ؓ查询�l�果�Q�如果没有找刎ͼ�再执行相应的Select语句获得对应的库表记录（iterate�Ҏ��如果执行了数据库��d��操作�q�构��Z��完整的数据对象，也会��其查询�l�果�U�_��~�存�Q��?

[实际的情冉|��,如果使用了iterate�Ҏ��q�回Iterator�c�d��的查询结�?那么你一旦关闭session,Iterator中的数据立即��׃��消失.而通过find得到的List则不会如�?我想大部分�h的��用习惯都是操作完成后立即关闭session,很多公司也强制要求这样做.
Iterator的另一个麻烦事是fail-fast,在多�U�程环境�?很容易��?使用�U�程安全的List子类,则不会有�q�个问题]

      Query Cache产生作用的情况：
      1.完全相同的Select SQL重复执行�?br />       2.在两�ơ查询之��_��此Select SQL对应的库表没有发生过改变�?

      Session.save�Ҏ��的执行步骤：
      1.在Session内部�~�存中寻扑־�保存对象。内部缓存命中，则认为此数据已经保存�Q�执行过insert操作�Q�，实体对象已经处于Persistent状态，直接�q�回�?br />       2.如果实体�c�d��C��lifecycle接口�Q�则调用待保存对象的onSave�Ҏ��?br />       3.如果实体�c�d��C��validatable接口�Q�则调用其validate()�Ҏ��?br />       4.调用对应拦截器的Interceptor.onSave�Ҏ��Q�如果有的话�Q��?br />       5.构造Insert SQL�Q��ƈ加以执行�?br />       6.记录插入成功�Q�user.id属性被讑֮�为insert操作�q�回的新记录id倹{�?br />       7.��user对象攑օ�内部�~�存�?br />       8.最后，如果存在�U�联关系�Q�对�U�联关系�q�行递归处理�?

      Session.update�Ҏ��的执行步骤：
      1.�Ҏ��待更新实体对象的Key�Q�在当前session的内部缓存中�q�行查找�Q�如果发玎ͼ�则认为当前实体对象已�l�处于Persistent状态，�q�回�?br />       2.初始化实体对象的状态信息（作�ؓ之后脏数据检查的依据�Q�，�q�将其纳入内部缓存。注意这里Session.update�Ҏ��本��n�q�没有发送Update SQL完成数据更新操作�Q?span style="color: red">Update SQL��在之后的Session.flush�Ҏ��中执行，�Ҏ��id更新所有的字段�Q�如update user set name=?, password=? where id=?�?

      Session.saveOrUpdate�Ҏ��的执行步骤：
      1.首先在Session内部�~�存中进行查找，如果发现则直接返回�?br />       2.执行实体�c�d��应的Interceptor.isUnsaved�Ҏ��Q�如果有的话�Q�，判断对象是否为未保存状态�?br />       3.�Ҏ��unsaved-value判断对象是否处于未保存状态�?br />       4.如果对象未保存（Transient状态）�Q�则调用save�Ҏ��保存对象�?br />       5.如果对象为已保存�Q�Detached状态）�Q�调用update�Ҏ��对象与Session重新兌��?/p>

Session.delete(E)
E 由持久状�?游离状�?-->>自由状�?br />

Session.flush()
调用flush
1.直接调用Session.flush();
2.tx.commit();
//flush before commiting the transaction and closing the session
//Flushing is the process of synchronising the underlying persistent store with persistable state held in memory.

E1=Session.merge(E)
if E is transient instance,则insert数据�?E状态不变化,E1是一个持久化对象;
if E is detached instance,则重新load,变成persistent instance;
if E is persistent instance,则从�~�存中选择;

// Copy the state of the given object onto the persistent object with the same identifier.
// If there is no persistent instance currently associated with the session,  it will be loaded. Return the persistent instance.
// If the given instance is unsaved, save a copy of and return it as a newly persistent instance. The given instance does not become associated with the session.
// This operation cascades to associated instances if the association is mapped with cascade="merge".

Session.persist(E)

persist() is well defined. It makes a transient instance persistent. However,
it doesn't guarantee that the identifier value will be assigned to the persistent
instance immediately, the assignment might happen at flush time. The spec doesn't say
that, which is the problem I have with persist().

persist() also guarantees that it will not execute an INSERT statement if it is
called outside of transaction boundaries. This is useful in long-running conversations
with an extended Session/persistence context.A method like persist() is required.

save() does not guarantee the same, it returns an identifier, and if an INSERT
has to be executed to get the identifier (e.g. "identity" generator, not "sequence"),
this INSERT happens immediately, no matter if you are inside or outside of a transaction. This is not good in a long-running conversation with an extended Session/persistence context."

黎夕 2006-07-19 00:51 发表评论

实体对象识别

黎夕 — Tue, 18 Jul 2006 16:49:00 GMT
【引用�?/font> http://www.tkk7.com/georgehill/archive/2005/06/22/6546.html

在Java语言中，对象之间的比较可以通过引用比较(==)和内�Ҏ��?equals)两种方式�q�行�Q�而在Hibernate的实体对象的比较是通过主键值来比较�Q�如果要实现自己的识别逻辑�Q�则需要重写equals�Ҏ��和hashCode�Ҏ��?br />
      ��查数据对象改变检查的一般策略有下面两种�Q?br />      1. 数据对象监控
         数据对象监控的实现方式，通过拦截器对数据对象的设值方法进行拦截。一旦数据对象的讄��Ҏ��被调用，则将其标志�ؓ“待更新”状态，之后在数据库操作时将其更新到对应的库表�?br />      2. 数据版本�Ҏ��
         在持久层框架中维持数据对象的最�q�读取版本，当数据提交时��提交数据与此版本进行比对，如果发生变化则将其同步到数据库对应的库表�?br />
      Hibernate采取的是�W�二�U�检查策略。它采用一个内部数据结�?EntityEntry"保存对应实体�cȝ��状态信息�?br />
      对于�U�联对象的更斎ͼ�Hibernate��根据unsaved-value�q�行判定。首先Hibernate会取出目标对象的id。之后，��此��g��unsaved-value�q�行比对�Q�如果相�{�，则认为目标对象尚未保存，否则�Q�认为对象已�l�保存，无需再进行保存操作�?img src ="http://www.tkk7.com/gm_jing/aggbug/58880.html" width = "1" height = "1" />

黎夕 2006-07-19 00:49 发表评论

	每个�c�d��层结构一张表	每个子类一个表	每个具体�c�M��个表
表的个数	1	n	n-1
父表	一个表	1	0
子表	一个表	n-1	n-1
表的字段	每个�cȝ��所有属性＋�c�d��鉴别	父表 --> 父类属�?/span> 子表 --> 子类属性＋父类 id	子表 --> 子类属性＋父类属�?/span>
表的兌�� / 表的唯一	�c�d��鉴别标识	父类 id	id

91精品国产亚洲爽啪在线影院 ,亚洲成AV人片在线播放无码,自拍偷自拍亚洲精品偷一

【�{】Hibernate Session的Flush模式

HIbernate中SQL statements生成�{�略

Hibernate3的DetachedCriteria使用

Hibernate Criteria 兌���查询

Spring 整合 Hibernate 的一处简化配�|?lt;转蝲>

Hibernate�E�序性能优化

hibernate二��~�存�ȝ��

3.1 基本讄���

3.3 查询�~�存

事务���理方式

【�{】open session and Hibernate事务处理机制

Hibernate查询--(SQL)

拦截�?--Interceptor

Hibernate查询--(Criteria Query)

Hibernate条�g查询(Criteria Query)

Hibernate查询--(HQL)

composite-id 学习

集合映射

兌���映射----->>>�ȝ��

many2many兌���

one2many兌���

one2one兌���

�l��g映射

�l�承映射----->>>三种�ȝ��

�l�承映射3 --每个具体�c�M��个表

�l�承映射2 --每个子类一个表

�l�承映射1 --每个�c�d��层结构一张表

Hibernate的锁

Session�Ҏ��

实体对象识别

Hibernate Criteria 兌��查询

3.1 基本讄��

事务��理方式

兌��映射----->>>�ȝ��

many2many兌��

one2many兌��

one2one兌��