国产精品区一区二区三含羞草,日韩在线看片,亚洲人成精品久久久久久

蓝色�q�默 — Fri, 17 Aug 2007 15:12:00 GMT

蓝色�q�默 2007-08-17 23:12 发表评论

Hibernate二��~�存�ȝ��

蓝色�q�默 — Fri, 10 Aug 2007 05:24:00 GMT

　　很多人对二��~�存都不太了解，或者是有错误的认识�Q�我一直想写一��文章介�l�一�?a target="_blank">Hibernate的二�U�缓存的�Q�今天终于忍不住了�?

　　我的�l�验主要来自hibernate2.1版本�Q�基本原理和3.0�?.1是一��L��Q�请原谅我的��固不化�?

　　hibernate的session提供了一�U�缓存，每个session�Q�对同一个id�q�行两次load�Q�不会发送两条sql�l?a target="_blank">数据�?/font>�Q�但是session关闭的时候，一�U�缓存就失效了�?br />
　　二��~�存是SessionFactory�U�别的全局�~�存�Q�它底下可以使用不同的缓存类库，比如ehcache、oscache�{�，需要设�|�hibernate.cache.provider_class�Q�我们这里用ehcache�Q�在2.1中就�?hibernate.cache.provider_class=net.sf.hibernate.cache.EhCacheProvider如果使用查询�~�存�Q�加上hibernate.cache.use_query_cache=true

　　�~�存可以��单的看成一个Map�Q�通过key在缓存里面找value�?br />
　　Class的缓�?/b>

　　对于一条记录，也就是一个PO来说�Q�是�Ҏ(gu��)��ID来找的，�~�存的key��是ID�Q�value是POJO。无论list�Q�load�q�是iterate�Q�只要读��Z��个对象，都会填充�~�存。但是list不会使用�~�存�Q�而iterate会先取数据库select id出来�Q�然后一个id一个id的load�Q�如果在�~�存里面有，��׃��~�存取，没有的话��去数据库load。假设是��d��~�存�Q�需要设�|�：

�Q�cache usage="read-write"/�Q?

　　如果你��用的二��~�存实现是ehcache的话�Q�需要配�|�ehcache.XML

�Q�cache name="com.xxx.pojo.Foo" maxElementsInMemory="500" eternal="false" timeToLiveSeconds="7200" timeToIdleSeconds="3600" overflowToDisk="true" /�Q?

　　其中eternal表示�~�存是不是永�q�不��时�Q�timeToLiveSeconds是缓存中每个元素�Q�这里也��是一个POJO�Q�的��时旉��Q�如果eternal="false"�Q�超�q�指定的旉��Q�这个元素就被移��C��。timeToIdleSeconds是发呆时��_��是可选的。当往�~�存里面put的元素超�q?00个时�Q�如果overflowToDisk="true"�Q�就会把�~�存中的部分数据保存在硬盘上的��时文仉��面�?

　　每个需要缓存的class都要�q�样配置。如果你没有配置�Q�hibernate会在启动的时候警告你�Q�然后��用defaultCache的配�|�，�q�样多个class会共享一个配�|��?

　　当某个ID通过hibernate修改�Ӟ��hibernate会知道，于是�U�除�~�存�?

　　�q�样大家可能会想�Q�同��L��查询条�g�Q�第一�ơ先list�Q�第二次再iterate�Q�就可以使用到缓存了。实际上�q�是很难的，因�ؓ你无法判断什么时候是�W�一�ơ，而且每次查询的条仉��常是不一��L��Q�假如数据库里面�?00条记录，id�?�?00�Q�第一�ơlist的时候出了前50个id�Q�第二次iterate的时候却查询�?0�?0号id�Q�那�?0-50是从�~�存里面取的�Q?1�?0是从数据库取的，共发�?+20条sql。所以我一直认为iterate没有什么用�Q��L��会有1+N的问题�?

　　�Q�题外话�Q�有说法说大型查询用list会把整个�l�果集装入内存，很慢�Q�而iterate只select id比较好，但是大型查询��L��要分��|��的，谁也不会真的把整个结果集装进来，假如一��?0条的话，iterate共需要执�?1条语句，list虽然选择若干字段�Q�比iterate�W�一条select id语句慢一些，但只有一条语句，不装入整个结果集hibernate�q�会�Ҏ(gu��)��数据库方�a�做优化，比如使用MySQL的limit�Q�整体看来应该还是list快。）

　　如果惌��对list或者iterate查询的结果缓存，��p��用到查询�~�存�?br />
　　查询�~�存

　　首先需要配�|�hibernate.cache.use_query_cache=true

　　如果用ehcache�Q�配�|�ehcache.xml�Q�注意hibernate3.0以后不是net.sf的包名了�Q?br />
�Q�cache name="net.sf.hibernate.cache.StandardQueryCache"
maxElementsInMemory="50" eternal="false" timeToIdleSeconds="3600"
timeToLiveSeconds="7200" overflowToDisk="true"/�Q?
�Q�cache name="net.sf.hibernate.cache.UpdateTimestampsCache"
maxElementsInMemory="5000" eternal="true" overflowToDisk="true"/�Q?

　　然后

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

　　�W�二行指定要使用的cacheRegion是myCacheRegion�Q�即你可以给每个查询�~�存做一个单独的配置�Q��用setCacheRegion来做�q�个指定�Q�需要在ehcache.xml里面配置它：

�Q�cache name="myCacheRegion" maxElementsInMemory="10" eternal="false" timeToIdleSeconds="3600" timeToLiveSeconds="7200" overflowToDisk="true" /�Q?

　　如果省略�W�二行，不设�|�cacheRegion的话�Q�那么会使用上面提到的标准查询缓存的配置�Q�也��是�Q�net.sf.hibernate.cache.StandardQueryCache

　　对于查询�~�存来说�Q�缓存的key是根据hql生成的sql�Q�再加上参数�Q�分��늭�信息�Q�可以通过日志输出看到�Q�不�q�它的输��Z��是很可读�Q�最好改一下它的代码）�?

　　比如hql�Q?

from Cat c where c.name like ?

　　生成大致如下的sql�Q?

select * from cat c where c.name like ?

　　参数�?tiger%"�Q�那么查询缓存的key*大约*是这��L��字符�Ԍ��我是凭记忆写的，�q�不�_��Q�不�q�看了也该明白了�Q�：

select * from cat c where c.name like ? , parameter:tiger%

　　�q�样�Q�保证了同样的查询、同��L��参数�{�条件下��h��一��L��key�?

　　现在说说�~�存的value�Q�如果是list方式的话�Q�value在这里�ƈ不是整个�l�果集，而是查询出来的这一串ID。也��是��_��不管是list�Ҏ(gu��)��q�是iterate�Ҏ(gu��)��Q�第一�ơ查询的时候，它们的查询方式很它们�q�x��的方式是一��L��Q�list执行一条sql�Q�iterate执行1+N条，多出来的行�ؓ是它们填充了�~�存。但是到同样条�g�W�二�ơ查询的时候，��都和iterate的行��Z��样了�Q�根据缓存的key�ȝ��存里面查��C��value�Q�value是一串id�Q�然后在到class的缓存里面去一个一个的load出来。这样做是�ؓ了节�U�内存�?

　　可以看出来，查询�~�存需要打开相关�cȝ��class�~�存。list和iterate�Ҏ(gu��)��W�一�ơ执行的时候，都是既填充查询缓存又填充class�~�存的�?
�q�里�q�有一个很�Ҏ(gu��)��被忽视的重要问题�Q�即打开查询�~�存以后�Q�即使是list�Ҏ(gu��)��也可能遇�?+N的问题！相同条�g�W�一�ơlist的时候，因�ؓ查询�~�存中找不到�Q�不��class�~�存是否存在数据�Q��L��发送一条sql语句到数据库获取全部数据�Q�然后填充查询缓存和class�~�存。但是第二次执行的时候，问题��来了，如果你的class�~�存的超时时间比较短�Q�现在class�~�存都超时了�Q�但是查询缓存还在，那么list�Ҏ(gu��)��在获取id串以后，��会一个一个去数据库load�Q�因此，class�~�存的超时时间一定不能短于查询缓存设�|�的��时旉��Q�如果还讄��了发呆时间的话，保证class�~�存的发呆时间也大于查询的缓存的生存旉��。这里还有其他情况，比如class�~�存被程序强制evict了，�q�种情况��p��自己注意了�?br />
　　另外�Q�如果hql查询包含select字句�Q�那么查询缓存里面的value��是整个�l�果集了�?br />
　　当hibernate更新数据库的时候，它怎么知道更新哪些查询�~�存呢？

　　hibernate在一个地方维护每个表的最后更新时��_��其实也就是放在上面net.sf.hibernate.cache.UpdateTimestampsCache所指定的缓存配�|�里面�?

　　当通过hibernate更新的时候，hibernate会知道这�ơ更新媄响了哪些表。然后它更新�q�些表的最后更新时间。每个缓存都有一个生成时间和�q�个�~�存所查询的表�Q�当hibernate查询一个缓存是否存在的时候，如果�~�存存在�Q�它�q�要取出�~�存的生成时间和�q�个�~�存所查询的表�Q�然后去查找�q�些表的最后更新时��_��如果有一个表在生成时间后更新�q�了�Q�那么这个缓存是无效的�?

　　可以看出�Q�只要更新过一个表�Q�那么凡是涉及到�q�个表的查询�~�存��失效了�Q�因此查询缓存的命中率可能会比较低�?br />
Collection�~�存

　　需要在hbm的collection里面讄��Q?br />
�Q�cache usage="read-write"/�Q?

　　假如class是Cat�Q�collection叫children�Q�那么ehcache里面配置

�Q�cache name="com.xxx.pojo.Cat.children"
maxElementsInMemory="20" eternal="false" timeToIdleSeconds="3600" timeToLiveSeconds="7200"
overflowToDisk="true" /�Q?

　　Collection的缓存和前面查询�~�存的list一��P��也是只保持一串id�Q�但它不会因��个表更新�q�就失效�Q�一个collection�~�存仅在�q�个collection里面的元素有增删时才失效�?

　　�q�样有一个问题，如果你的collection是根据某个字�D�|��序的�Q�当其中一个元素更��C��该字�D�|��Q�导致顺序改变时�Q�collection�~�存里面的顺序没有做更新�?br />
　　�~�存�{�略

　　只读�~�存�Q�read-only�Q�：没有什么好说的

　　�?写缓存（read-write�Q?�E�序可能要的更新数据

　　不严格的�?写缓存（nonstrict-read-write�Q�：需要更新数据，但是两个事务更新同一条记录的可能性很��，性能比读写缓存好
事务�~�存�Q�transactional�Q�：�~�存支持事务�Q�发生异常的时候，�~�存也能够回滚，只支持jta环境�Q�这个我没有怎么研究�q?br />
　　��d��~�存和不严格��d��~�存在实��C��的区别在于，��d��~�存更新�~�存的时候会把缓存里面的数据换成一个锁�Q�其他事务如果去取相应的�~�存数据�Q�发现被锁住了，然后��q��接取数据�?/font>查询�?

　　�?a target="_blank">Hibernate2.1的ehcache实现中，如果锁住部分�~�存的事务发生了异常�Q�那么缓存会一直被锁住�Q�直�?0�U�后��时�?

　　不严��D��写缓存不锁定�~�存中的数据�?使用二��~�存的前�|�条件�?br />
　　你的hibernate�E�序�Ҏ(gu��)��据库有独占的写访问权�Q�其他的�q�程更新了数据库�Q�hibernate是不可能知道的。你操作数据库必需直接通过hibernate�Q�如果你调用存储�q�程�Q�或者自�׃��?a target="_blank">JDBC更新数据库，hibernate也是不知道的。hibernate3.0的大扚w��更新和删除是不更��C��U�缓存的�Q�但是据�?.1已经解决了这个问题�?

　　�q�个限制相当的棘手，有时候hibernate做批量更新、删除很慢，但是你却不能自己写jdbc来优化，很郁闷吧�?

　　SessionFactory也提供了�U�除�~�存的方法，你一定要自己写一些JDBC的话�Q�可以调用这些方法移除缓存，�q�些�Ҏ(gu��)��是：

void evict(Class persistentClass)
Evict all entries from the second-level cache.
void evict(Class persistentClass, Serializable id)
Evict an entry from the second-level cache.
void evictCollection(String roleName)
Evict all entries from the second-level cache.
void evictCollection(String roleName, Serializable id)
Evict an entry from the second-level cache.
void evictQueries()
Evict any query result sets cached in the default query cache region.
void evictQueries(String cacheRegion)
Evict any query result sets cached in the named query cache region.

　　不过我不��q�样做，因�ؓ�q�样很难�l�护。比如你现在用JDBC扚w��更新了某个表�Q�有3个查询缓存会用到�q�个表，用evictQueries(String cacheRegion)�U�除�?个查询缓存，然后用evict(Class persistentClass)�U�除了class�~�存�Q�看上去好像完整了。不�q�哪天你��d��了一个相��x��询缓存，可能会忘记更新这里的�U�除代码。如果你的jdbc代码到处都是�Q�在你添加一个查询缓存的时候，�q�知道其他什么地方也要做相应的改动吗�Q?br />
　　�ȝ���Q?

　　不要惛_��然的以�ؓ�~�存一定能提高性能�Q�仅仅在你能够驾驭它�q�且条�g合适的情况下才是这��L��。hibernate的二�U�缓存限制还是比较多的，不方便用jdbc可能会大大的降低更新性能。在不了解原理的情况下�ؕ用，可能会有1+N的问题。不当的使用�q�可能导致读��数据�?
如果受不了hibernate的诸多限�Ӟ��那么�q�是自己在应用程序的层面上做�~�存吧�?

　　在越高的层面上做�~�存�Q�效果就会越好。就好像��管��盘有缓存，数据库还是要实现自己的缓存，��管数据库有�~�存�Q�咱们的应用�E�序�q�是要做�~�存。因为底层的�~�存它�ƈ不知道高层要用这些数据干什么，只能做的比较通用�Q�而高层可以有针对性的实现�~�存�Q�所以在更高的��别上做缓存，效果也要好些吧�?

蓝色�q�默 2007-08-10 13:24 发表评论

Hibernate+Struts分页代码(节�?

蓝色�q�默 — Mon, 06 Aug 2007 16:47:00 GMT
     摘要: 转自�Q�http://blog.csdn.net/yeno/archive/2007/01/25/1492788.aspxCode highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->public class HibernateUtil {    private Hi...  阅读全文

蓝色�q�默 2007-08-07 00:47 发表评论

[原创]Hibernate入门(1)

蓝色�q�默 — Sat, 04 Aug 2007 12:20:00 GMT

说明下，我也是新手，我现在的目的是�ؓ了快速上手Hibernate�Q�以下简�U�H�Q�，因此�q�没有作深入研究�?/i>

参考资料：《Hibernate_Reference》、《深入浅出Hibernate�?br />

正文

下面我们��创��Z��个简单的��Z��控制台的(console-based)Hibernate应用�E�序�?br />
我们所做的�W�一件事��是创徏我们的开发目录，�q�且把所有需要用到的Java库文件放�q�去。万�q�的是我们有了myeclipse�Q�由他创建的工程可以很方便地打包�Q�然后交�l�另一个同��h��有myeclipse的��用者，只需要简单的导入卛_��使用^_^
右键工程目录 �?myeclipse �?Add Hibernate…�?/u>
�q�样子你的工�E�就可以导入Hibernate所需要的所有库文�g�Q�接下来我们创徏一个类�Q�用来代表那些我们希望储存在数据库里的event�?

1.1
�q�里假设你已�l�拥有了一个数据库�Q��ƈ且尽量将数据库中的各�U�关联设�|�完毕，如果你能�q�样子做�Q�接下来的事情将会变得非常简单^_^

打开透视图（perspective�Q�中的myeclipse database exploer

在里面我们要配置下数据源

完成后即可徏立连接，然后我们��可以用myec自带的工兯��行映��配�|�，如下图：

1.2

一路默认即可，最后将会生成一堆配�|�的文�g一共有3�c�：
1.持久化类�Q�就是一个带有一些属性（property�Q�的��单JavaBean�c�d��Q?br />
public abstract class AbstractTest implements java.io.Serializable {

    // Fields

    private Integer id;

    private String name;

    private Set<Testaddr> testaddr = new HashSet<Testaddr>(0);

    public Set<Testaddr> getTestaddr() {
        return testaddr;
    }

    public void setTestaddr(Set<Testaddr> testaddr) {
        this.testaddr = testaddr;
    }

    /** default constructor */
    public AbstractTest() {
    }

    /** full constructor */
    public AbstractTest(Integer id, String name) {
        this.id = id;
        this.name = name;
    }

    // Property accessors

    public Integer getId() {
        return this.id;
    }

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

    public String getName() {
        return this.name;
    }

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

}

你可以看到这个类对属性的存取�Ҏ(gu��)��Q�getter and setter method�Q��用了标准JavaBean命名�U�定�Q�同时把�c�d��性（field�Q�的讉K��U�别设成�U�有的（private�Q�。这是推荐的设计�Q�但�q�不是必��ȝ��?br />
2.xml映射配置

Hibernate需要知道怎样��d��载（load�Q�和存储�Q�store�Q�持久化�cȝ��对象。这正是Hibernate映射文�g发挥作用的地斏V��映��文件告诉Hibernate它，应该讉K��数据�?database)里面的哪个表�Q�table�Q�及应该使用表里面的哪些字段�Q�column�Q��?
一个映��文件的基本�l�构看�v来像�q�样�Q?/p>
xml version="1.0" encoding="utf-8"?>
DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
    <class name="HibernateFactory.Test" table="test"
        catalog="himessage">
        <id name="id" type="java.lang.Integer">
            <column name="id" />
            <generator class="native" />
        id>
        <property name="name" type="java.lang.String">
            <column name="name" not-null="true" />
        property>

        <set name="testaddr" cascade="all" lazy="false" inverse="true">
            <key column="test_id">key>
            <one-to-many class="HibernateFactory.Testaddr" />
        set>

    class>
hibernate-mapping>
�?code class="literal">hibernate-mapping标签�Q�tag�Q�之�? 含有一�?code class="literal">class元素。所有的持久化实体类�Q�再�ơ声明，或许接下来会有依赖类�Q�就是那些次要的实体�Q�都需要一个这��L��映射�Q�来把类对象映射到SQL数据库里的表�?
id元素是标识符属性的声明�Q?code class="literal">name="id" 声明了Java属性的名字 �Q?Hibernate会��?code class="literal">getId()�?code class="literal">setId()来访问它�?column属性则告诉Hibernate, 我们使用EVENTS表的哪个字段作�ؓ主键。嵌套的generator元素指定了标识符生成�{�略�Q�在�q�里我们指定native�Q�它�Ҏ(gu��)��已配�|�的数据库自动选择最佳的标识�W�生成策略。Hibernate支持由数据库生成�Q�全局唯一性（globally unique�Q�和应用�E�序指定�Q�或者你自己��Z�Q何已有策略所写的扩展�Q�这些策略来生成标识�W��?
关于具体的配�|�请参阅《深入浅出Hibernate》P146 数据兌��Q�所有的参数表请查此书P411

3.Hibernate配置
现在我们已经有了一个持久化�c�d��它的映射文�g�Q�该是配�|�Hibernate的时候了�?br />
xml version='1.0' encoding='UTF-8'?>
DOCTYPE hibernate-configuration PUBLIC
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
          "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

    <session-factory>
        <property name="show_sql">trueproperty>
        <property name="connection.username">rootproperty>
        <property name="connection.url">
            jdbc:mysql://localhost/himessage?useUnicode=true&characterEncoding=utf-8
        property>
        <property name="dialect">
            org.hibernate.dialect.MySQLDialect
        property>
        <property name="myeclipse.connection.profile">Hbproperty>
        <property name="connection.password">1234property>
        <property name="connection.driver_class">
            com.mysql.jdbc.Driver
        property>
        <mapping resource="HibernateFactory/Admin.hbm.xml" />
        <mapping resource="HibernateFactory/Test.hbm.xml" />
        <mapping resource="HibernateFactory/Testaddr.hbm.xml" />

    session-factory>

hibernate-configuration>

�q�里需要特别指出的�?span style="color: rgb(0, 0, 0);"><property name="show_sql">trueproperty>
用了�q�句我们可以直接在ec控制台看�?/font>Hibernate生成的sql语句�Q�对调试�E�序是相当有帮助的！

�C�Z��的基本框架完成了 �Q?现在我们可以用Hibernate来做些真正的工作�?

1.3
我们�l�于可以使用Hibernate来加载和存储对象了，�~�写一个带�?code class="literal">main()�Ҏ(gu��)��?code class="literal">AdminActionr�c�：
public class AdminAction {
    public static void main(String[] args) {
        Session session = HibernateSessionFactory.getSession();
        session.beginTransaction();
        Admin admin = new Admin();
        admin.setEmail("tantan85@163.com");
        admin.setName("tantan");
        admin.setPsw("111111");
        admin.setAddAdmin(2);
        session.save(admin);
        session.getTransaction().commit();
    }
}

我们创徏了个新的Admin对象�q�把它传递给Hibernate。现在Hibernate负责与SQL打交道，�q�把INSERT命��o传给数据库。在�q�行之前�Q�让我们看一下处�?code class="literal">Session�?code class="literal">Transaction的代码�?

一�?code class="literal">Session��是个单一的工作单元。我们暂时让事情��单一些，�q�假设HibernateSession和数据库事务是一一对应的�?br />HibernateSessionFactory.getSession()是干什么的呢？�q�回“当前的”工作单元�?br />getTransaction()则表�C�取��Z��个事务对象，commit()则是事务的提交，卛_��~�存中的数据写入数据库�?br />
��是�q�么面向对象的方法，你就完成了传�l�的sql语句的功能，是不是很爽？更爽的是你还可以用hql语言来完成更强大的功能，当然�q�里不可能一一列�D�Q�只有看书了�Q�请参考《深入浅出Hibernate》P173 ^_^

蓝色�q�默 2007-08-04 20:20 发表评论

蓝色�q�默 — Sat, 04 Aug 2007 10:30:00 GMT
最�q�在��目中��用了Struts + Hibernate的组合，在session和事务管理上遇到了些问题�Q�查阅了一些资料后�Q�决定采用servlet的过滤器来解决管理问题�?br />
主要修改�?span style="color: rgb(0, 0, 0);">HibernateSessionFactory.java�Q�由原文件由myeclipse自动生成的）

public class HibernateSessionFactory {

    /**
     * Location of hibernate.cfg.xml file. Location should be on the classpath
     * as Hibernate uses #resourceAsStream style lookup for its configuration
     * file. The default classpath location of the hibernate config file is in
     * the default package. Use #setConfigFile() to update the location of the
     * configuration file for the current session.
     */
    private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.xml";

    private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();

    private static final ThreadLocal<Transaction> tLocaltx = new ThreadLocal<Transaction>();

    private static Configuration configuration = new Configuration();

    private static org.hibernate.SessionFactory sessionFactory;

    private static String configFile = CONFIG_FILE_LOCATION;

    private HibernateSessionFactory() {
    }

    /**
     * Returns the ThreadLocal Session instance. Lazy initialize the
     * SessionFactory if needed.
     *
     * @return Session
     * @throws HibernateException
     */
    public static Session getSession() throws HibernateException {
        Session session = (Session) threadLocal.get();

        if (session == null || !session.isOpen()) {
            if (sessionFactory == null) {
                rebuildSessionFactory();
            }
            session = (sessionFactory != null) ? sessionFactory.openSession() : null;
            threadLocal.set(session);
        }

        return session;
    }

    /**
     * Rebuild hibernate session factory
     *
     */
    public static void rebuildSessionFactory() {
        try {
            configuration.configure(configFile);
            sessionFactory = configuration.buildSessionFactory();
        } catch (Exception e) {
            System.err.println("%%%% Error Creating SessionFactory %%%%");
            e.printStackTrace();
        }
    }

    /**
     * Close the single hibernate session instance.
     *
     * @throws HibernateException
     */
    public static void closeSession() throws HibernateException {
        Session session = (Session) threadLocal.get();
        threadLocal.set(null);

        if (session != null) {
            session.close();
        }
    }

    /**
     * return session factory
     *
     */
    public static org.hibernate.SessionFactory getSessionFactory() {
        return sessionFactory;
    }

    /**
     * return session factory
     *
     * session factory will be rebuilded in the next call
     */
    public static void setConfigFile(String configFile) {
        HibernateSessionFactory.configFile = configFile;
        sessionFactory = null;
    }

    /**
     * return hibernate configuration
     *
     */
    public static Configuration getConfiguration() {
        return configuration;
    }

    /**
     * 打开一个事�?br />     */
    public static void beginTransaction() {
        Transaction tx = tLocaltx.get();
        try {
            if (tx == null) {
                tx = getSession().beginTransaction();
                tLocaltx.set(tx);
            }
        } catch (Exception e) {
            System.err.println("%%%% Error beginTransaction %%%%");
            e.printStackTrace();
        }
    }

    /**
     * 关闭一个事�?br />     */
    public static void commitTransaction() {
        Transaction tx = tLocaltx.get();
        try {
            if (tx != null && !tx.wasCommitted() && !tx.wasRolledBack()) {
                tx.commit();
                //一个事务结束就立即解除与tLocaltx的关�?/span>
                tLocaltx.set(null);
            }
        } catch (Exception e) {
            System.err.println("%%%% Error commitTransaction %%%%");
            e.printStackTrace();
        }
    }

    /**
     * 事务回滚
     */
    public static void rollbackTransaction() {
        Transaction tx = tLocaltx.get();
        try {
            tLocaltx.set(null);
            if (tx != null && !tx.wasCommitted() && !tx.wasRolledBack())
                tx.rollback();
        } catch (Exception e) {
            System.err.println("%%%% Error rollbackTransaction %%%%");
            e.printStackTrace();
        }
    }
}

在myec生成的HibernateSessionFactory源代�?/span>中，保证了在一�ơ请求过�E�中�׃�n单一的session实例�Q�我们现在要加入的内容就是在一�ơ请求中�׃�n一�?span style="color: rgb(0, 0, 0);">Transaction实例�Q?/span>很明显，中文部分是增加的内容。添加的代码��装了事务的开始，提交以及回滚。这样子session�?span style="color: rgb(0, 0, 0);">Transaction实例可以跨越一�ơ请求的多种�Ҏ(gu��)��Q�这有助于实现集合的延迟加蝲�{?/span>Hibernate�Ҏ(gu��)��?br />
在用的时候，我们��应该��用封装后�?/span>事务�Ҏ(gu��)��和session�Ҏ(gu��)��Q��用方法如下：

//获得唯一的session 实例
Session session = HibernateSessionFactory.getSession();

HibernateSessionFactory.beginTransaction();
//do something……（数据库操作如�Q�添加、删除等�Q?/span>
HibernateSessionFactory.commitTransaction();

在我们的��目中，BaseDAO�c�d��装了Hibernate常用的数据库操作�Ҏ(gu��)��Q�其�?/span>HibernateSessionFactory.beginTransaction()已经一起封入了BaseDAO�c�，于是�Q�我们便不用在��用代码中加入事务开始的�Ҏ(gu��)��Q�直接调�?span style="color: rgb(0, 0, 0);">BaseDAO�cȝ��Ҏ(gu��)��卛_��。在调试�q�程中，如果我们需要测试数据是否能够写入数据库�Q�就应该手工调用事务�l�束�Ҏ(gu��)��HibernateSessionFactory.commitTransaction()�Q�即可立�?/span>写入数据库�?br />
注意�Q�在一�ơ业务逻辑中，只能用一�ơ事务提交，也只需要一�ơ事务提交，我们一般把事务提交攑ֈ�语句执行的最后面。（如果你用了多�ơ提交，只对�W�一�ơ提交有效！�Q?/b>

下面举例�Q?br />
//testDAO �l�承 BaseDAO

public class testDAO extends BaseDAO {
    testDAO(){
        super();
    }
}

public class testAction {
    public static void main(String[] args) {
        ActionDAO ad = new ActionDAO();
        ad.add(object);
        // 手工调用事务提交�Q�可��缓存中的数据立卛_��入数据库
        HibernateSessionFactory.commitTransaction();
        // 手工调用session关闭
        HibernateSessionFactory.closeSession();
    }
}

但在实际的应用中�Q�我们应该把��试用的手工代码删除�Q�因��Z��务和session的关闭还有事务的回滚是通过�q��o器来完成的，当然�q��o器需要servlet的支持，我们先来看看�q��o器的代码�Q?br />
public class CloseSessionFilter extends HttpServlet implements Filter {
    /**
     *
     */
    private static final long serialVersionUID = 1L;

    private FilterConfig filterConfig;

    protected boolean enable; // 是否��L��此过滤器

    public void init(FilterConfig filterConfig) throws ServletException {
        this.filterConfig = filterConfig;
        loadConfigParams();
    }

    public void loadConfigParams() { // 取得初始化参�?/span>
        String enableStr = this.filterConfig.getInitParameter("enable");
        if (enableStr.trim().equals("true")) {
            this.enable = true;
        } else {
            this.enable = false;
        }
    }

    // Process the request/response pair
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) {
        try {
            filterChain.doFilter(request, response);
        } catch (Exception sx) {
        } finally {
            if (enable) {
                try {
                    HibernateSessionFactory.commitTransaction();
                } catch (Exception e) {
                    HibernateSessionFactory.rollbackTransaction();
                } finally {
                    HibernateSessionFactory.closeSession();
                }
            }
        }
    }

    // Clean up resources
    public void destroy() {
    }
}

相应的web.xml配置�Q?br />

    <filter>
        <filter-name>CloseSessionFilterfilter-name>
        <filter-class>
            com.struts.common.CloseSessionFilter
        filter-class>
        <init-param>
            <param-name>enableparam-name>
            <param-value>trueparam-value>
        init-param>
    filter>

    <filter-mapping>
        <filter-name>CloseSessionFilterfilter-name>
        <servlet-name>actionservlet-name>
    filter-mapping>

需要注意的是多个过滤器之间的顺序位�|�，filterChain.doFilter(request, response);是指调用下一个过滤器�Q�也��是��_��要调用完所有过滤器后，才会�l�箋�q�行filterChain.doFilter(request, response);下面的内容，�q�是一个递归的过�E�。所以，在web.xml的配�|�中�Q�我们要�?/span>Hibernate�q��o器放在第一位，��保所有servlet�q�行完毕后，才调用最后的关闭�Ҏ(gu��)��?br />

蓝色�q�默 2007-08-04 18:30 发表评论

蓝色�q�默 — Wed, 01 Aug 2007 15:59:00 GMT
     摘要: 转自�Q�http://lavasoft.blog.51cto.com/62575/d-5 说明�Q�一个客户可以对应多个订单。以此�ؓ例说明用myeclipse如何来实现这个应用，看看myeclipse是如何做的，生成配置文�g质量如何�? 环境�Q?开发工��P��myeclipse 5.5.1 GA �?�?库：mysql-5.0.37 操作�pȝ��Q�windows xp profess...  阅读全文

蓝色�q�默 2007-08-01 23:59 发表评论