日本三级在线观看网站,精品国产乱码久久久久软件,国新精品乱码一区二区三区18

hibernate入门 - Transaction

Mon, 01 Sep 2008 12:04:00 GMT

Hibernate是对JDBC的轻量��对象��装�Q�Hibernate本��n是不具备Transaction处理功能的，Hibernate�? Transaction实际上是底层的JDBC Transaction的封装，或者是JTA Transaction的封装，下面我们详细的分析：

Hibernate可以配置为JDBCTransaction或者是JTATransaction�Q�这取决于你在hibernate.properties中的配置:

引用

#hibernate.transaction.factory_class net.sf.hibernate.transaction.JTATransactionFactory
#hibernate.transaction.factory_class net.sf.hibernate.transaction.JDBCTransactionFactory

如果你什么都不配�|�，默认情况下��用JDBCTransaction�Q�如果你配置为：

引用

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

��用JTATransaction

不管你准备让Hibernate使用JDBCTransaction�Q�还是JTATransaction�Q�我的忠告就是什么都不配�Q�将让它保持默认状态，如下�Q?

引用

#hibernate.transaction.factory_class net.sf.hibernate.transaction.JTATransactionFactory
#hibernate.transaction.factory_class net.sf.hibernate.transaction.JDBCTransactionFactory

在下面的分析中我会给出原因�?

一、JDBC Transaction

看看使用JDBC Transaction的时候我们的代码例子�Q?

[code:1]Session session = sf.openSession();
Transaction tx = session.beginTransactioin();
...
session.flush();
tx.commit();
session.close();[/code:1]

�q�是默认的情况，当你在代码中使用Hibernate的Transaction的时候实际上��是JDBCTransaction。那么JDBCTransaction�I�竟是什么东西呢�Q�来看看源代码就清楚了：

Hibernate2.0.3源代码中的类[code:1]net.sf.hibernate.transaction.JDBCTransaction:

public void begin() throws HibernateException {

log.debug("begin");
try {
toggleAutoCommit = session.connection().getAutoCommit();
if (toggleAutoCommit) session.connection().setAutoCommit(false);
}
catch (SQLException e) {
log.error("Begin failed", e);
throw new TransactionException("Begin failed with SQL exception: ", e);
}
begun = true;
}[/code:1]
�q�是启动Transaction的方法，看到 connection().setAutoCommit(false) 了吗�Q�是不是很熟悉？

再来�?

[code:1]public void commit() throws HibernateException {
if (!begun) throw new TransactionException("Transaction not successfully started");
log.debug("commit");
try {
if ( session.getFlushMode()!=FlushMode.NEVER ) session.flush();
try {
session.connection().commit();
committed = true;
}
catch (SQLException e) {
log.error("Commit failed", e);
throw new TransactionException("Commit failed with SQL exception: ", e);
}
}
finally {
session.afterTransactionCompletion();
}
toggleAutoCommit();
}[/code:1]
�q�是提交�Ҏ��Q�看到connection().commit() 了吗�Q�下面就不用我多说了�Q�这个类代码非常��单易懂，通过阅读使我们明白Hibernate的Transaction都在�q�了些什么？我现在把�? Hibernate写的例子��译成JDBC�Q�大家就一目了然了�Q?

[code:1]Connection conn = ...; <--- session = sf.openSession();

conn.setAutoCommit(false); <--- tx = session.beginTransactioin();

... <--- ...

conn.commit(); <--- tx.commit(); (对应左边的两�?
conn.setAutoCommit(true);

conn.close(); <--- session.close();[/code:1]
看明白了吧，Hibernate的JDBCTransaction�Ҏ��是conn.commit而已�Q�根本毫无神�U�可�a��Q�只不过�? Hibernate中，Session打开的时候，��׃��自动conn.setAutoCommit(false)�Q�不像一般的JDBC�Q�默认都�? true�Q�所以你最后不写commit也没有关�p�，�׃��Hibernate已经把AutoCommit�l�关掉了�Q�所以用Hibernate的时候，你在�E? 序中不写Transaction的话�Q�数据库�Ҏ��没有反应�?

二、JTATransaction

如果你在EJB中��用Hibernate�Q�或者准备用JTA来管理跨Session的长事务�Q�那么就需要��用JTATransaction�Q�先看一个例子：

[code:1]javax.transaction.UserTransaction tx = new InitialContext().lookup("javax.transaction.UserTransaction");

Session s1 = sf.openSession();
...
s1.flush();
s1.close();

...

Session s2 = sf.openSession();
...
s2.flush();
s2.close();

tx.commit();[/code:1]
�q�是标准的��用JTA的代码片断，Transaction是跨Session的，它的生命周期比Session要长。如果你在EJB中��? Hibernate�Q�那么是最��单不�q�的了，你什么Transaction代码�l�统都不要写了，直接在EJB的部�|�描�q�符上配�|�某某方法是否��用事务就�? 以了�?

现在我们来分析一下JTATransaction的源代码�Q?net.sf.hibernate.transaction.JTATransaction:

[code:1]public void begin(InitialContext context, ...
...
ut = (UserTransaction) context.lookup(utName);
...[/code:1]
看清楚了吗？和我上面写的代码 tx = new InitialContext().lookup("javax.transaction.UserTransaction"); 是不是完全一��P��

[code:1]public void commit() ...
...
if (newTransaction) ut.commit();
...[/code:1]
JTATransaction的控制稍微复杂，不过仍然可以很清楚的看出来Hibernate是如何封装JTA的Transaction代码的�?

但是你现在是否看��C��什么问题？仔细想一下，Hibernate Transaction是从Session中获得的�Q�tx = session.beginTransaction()�Q�最后要先提交tx�Q�然后再session.close�Q�这完全�W�合JDBC�? Transaction的操作顺序，但是�q�个��序是和JTA的Transactioin操作��序��d��矛盾的！�Q�！ JTA是先启动Transaction�Q�然后启动Session�Q�关闭Session�Q�最后提交Transaction�Q�因此当你��用JTA�? Transaction的时候，那么��千万不要��用Hibernate的Transaction�Q�而是应该像我上面的JTA的代码片断那样��用才行�?

�ȝ��Q?

1、在JDBC上��用Hibernate

必须写上Hibernate Transaction代码�Q�否则数据库没有反应。此时Hibernate的Transaction��是Connection.commit而已

2、在JTA上��用Hibernate

写JTA的Transaction代码�Q�不要写Hibernate的Transaction代码�Q�否则程序会报错

3、在EJB上��用Hibernate

什么Transactioin代码都不要写�Q�在EJB的部�|�描�q�符里面配置

[code:1]
|---CMT(Container Managed Transaction)
|
|---BMT(Bean Managed Transaction)
|
|----JDBC Transaction
|
|----JTA Transaction
[/code:1]

robbin:
你说“Hibernate的JDBCTransaction�Ҏ��是conn.commit而已�Q�根本毫无神�U�可�a��Q�只不过在Hibernate 中，Session打开的时候，��׃��自动conn.setAutoCommit(false)�Q�不像一般的JDBC�Q�默认都是true�Q�所以你最后不�? commit也没有关�p�，�׃��Hibernate已经把AutoCommit�l�关掉了�Q�所以用Hibernate的时候，你在�E�序中不�? Transaction的话�Q�数据库�Ҏ��没有反�?#8221;
但sf.opengSession()�Ӟ��q�没有setAutoCommit(false)�Q�我想问的是�Q�如果不�~�写��M��事务代码�Q�如�Q?
[code:1]Session s = sf.openSession();
......
s.close();[/code:1]数据库会不会有反应（此时应该是默认AutoCommit为true�Q��?

另外�Q�我想问一下：
1. s.flush()是不是必��ȝ��
2. s.close()是不是一定要关闭
比如你上面提到的�Q?
[code:1]javax.transaction.UserTransaction tx = new InitialContext().lookup("javax.transaction.UserTransaction");

Session s1 = sf.openSession();
...
s1.flush();
s1.close();

...

Session s2 = sf.openSession();
...
s2.flush();
s2.close();

tx.commit();[/code:1]

s1不关闭，使用s2�q�行操作的代码中使用s1可不可以�Q�我觉得�q�样更加节约资源�Q�不需要反复的�q�接、关闭）

引用

但sf.opengSession()�Ӟ��q�没有setAutoCommit(false)�Q�我想问的是�Q�如果不�~�写��M��事务代码�Q�如�Q?
Session s = sf.openSession();
......
s.close();
数据库会不会有反应（此时应该是默认AutoCommit为true�Q��?/div>

不会有反应。在sf.openSession() 创徏Session实例的时候，��已�l�调用了conn.setAutoCommit(false)了�?

引用

另外�Q�我想问一下：
1. s.flush()是不是必��ȝ��
2. s.close()是不是一定要关闭

s.flush不是必须的，s.close()会调用一�ơs.flush()

s.close()正常情况下应该关闭，除非你是用ThreadLocal��理Session�?

引用

s1不关闭，使用s2�q�行操作的代码中使用s1可不可以�Q�我觉得�q�样更加节约资源�Q�不需要反复的�q�接、关闭）

在这个例子中看不出来JTA的作用�?
假设
[code:1]Class A {
find() {
Session s1 = sf.openSession();
...
s1.flush();
s1.close();
}
}[/code:1]

[code:1]Class B {
find() {
Session s2 = sf.openSession();
...
s2.flush();
s2.close();
}
}[/code:1]

[code:1]Main {

tx = ...;
A.find();
B.find();
tx.commit();
}[/code:1]

看明白了吗？JTA的Transaction��理是跨�c�调用的�?

中间开�?/a> 2008-09-01 20:04 发表评论

update和saveOrUpdate详解

Mon, 01 Sep 2008 11:31:00 GMT

先来�Ҏ��念：

在Hibernate中，最核心的概念就是对PO的状态管理。一个PO有三�U�状态：

1、未被持久化的VO
此时��是一个内存对象VO�Q�由JVM��理生命周期

2、已被持久化的PO�Q��ƈ且在Session生命周期�?
此时映射数据库数据，由数据库��理生命周期

3、曾被持久化�q�，但现在和Session已经detached了，以VO的��n份在�q�行
�q�种和Session已经detached的PO�q�能够进入另一个Session�Q��l�进行PO状态管理，此时它就成�ؓPO的第二种状态了�?span style="color: red;">�q�种PO实际上是跨了Session�q�行了状态维护的�?/span>

在传�l�的JDO1.x中，PO只有前面两种状态，一个PO一旦脱��PM�Q�就丧失了状态了�Q�不再和数据库数据关联，成�ؓ一个纯�_�的内存VO�Q�它即�ɘq�入一个新的PM�Q�也不能恢复它的状态了�?

Hibernate强的地方��在于，一个PO��q��Session之后�Q�还能保持状态，再进入一个新的Session之后�Q�就恢复状态管理的能力�Q? 但此时状态管理需要��用session.update或者session.saveOrUpdate�Q�这��是Hibernate Reference中提到的“requires a slightly different programming model ”

现在正式�q�入本话题：

��单的来说�Q�update和saveOrUpdate是用来对跨Session的PO�q�行状态管理的�?/span>

假设你的PO不需要跨Session的话�Q�那么就不需要用刎ͼ�例如你打开一个Session�Q�对PO�q�行操作�Q�然后关闭，之后�q�个PO你也不会再用��C��Q�那么就不需要用update�?

因此�Q�我们来看看�Q?
[code:1]Foo foo=sess.load(Foo.class,id);
foo.setXXX(xxx);
sess.flush();
sess.commit(); [/code:1]

PO对象foo的操作都在一个Session生命周期内完成，因此不需要显式的�q�行sess.update(foo)�q�样的操作�? Hibernate会自动监��到foo对象已经被修改过�Q�因此就向数据库发送一个update的sql。当然如果你非要加上 sess.update(foo)也不会错�Q�只不过�q�样做没有�Q何必要�?

而跨Session的意思就是说�q�个PO对象在Session关闭之后�Q�你�q�把它当做一个VO来用�Q�后来你在Session外面又修改了它的属性，然后你又��x��开一个Session�Q�把VO的属性修改保存到数据库里面，那么你就需要用update了�?

[code:1]// in the first session
Cat cat = (Cat) firstSession.load(Cat.class, catId);
Cat potentialMate = new Cat();
firstSession.save(potentialMate);

// in a higher tier of the application
cat.setMate(potentialMate);

// later, in a new session
secondSession.update(cat); // update cat
secondSession.update(mate); // update mate[/code:1]

cat和mate对象是在�W�一个session中取得的�Q�在�W�一个session关闭之后�Q�他们就成了PO的第三种状态，和Session已经 detached的PO�Q�此时他们的状态信息仍然被保留下来了。当他们�q�入�W�二个session之后�Q�立��d��可以�q�行状态的更新。但是由于对cat的修�? 操作�Q�cat.setMate(potentialMate); 是在Session外面�q�行的，Hibernate不可能知道cat对象已经被改�q�了�Q�第二个Session�q�不知道�q�种修改�Q�因此一定要昑ּ�的调�? secondSession.update(cat); 通知Hibernate�Q�cat对象已经修改了，你必��d��送update的sql了�?

所以update的作用就在于此，它只会被用于当一个PO对象跨Session�q�行状态同步的时候才需要写。而一个PO对象当它不需要跨Session�q�行状态管理的时候，是不需要写update的�?

再谈谈saveOrUpdate的用场：

saveOrUpdate和update的区别就在于在跨Session的PO状态管理中�Q�Hibernate对PO采取何种�{�略�?

例如当你写一个DAOImpl的时候，让cat对象增加一个mate�Q�如下定义：
[code:1]public void addMate(Cat cat, Mate mate) {
Session session = ...;
Transacton tx = ...;
session.update(cat);
cat.addMate(mate);
tx.commit();
session.close();
};[/code:1]

昄��你是需要把Hibernate的操作封装在DAO里面的，让业务层的程序员和Web层的�E�序员不需要了解Hibernate�Q�直接对DAO�q�行调用�?

此时问题��来了：上面的代码运行正��有一个必要的前提�Q�那��是�Ҏ��调用参数cat对象必须是一个已�l�被持久化过的PO�Q�也��是来说�Q�它应该首先�? 数据库查询出来，然后才能�q�样用。但是业务层的程序员昄��不知道这�U�内部的玄妙�Q�如果他的业务是现在增加一个cat�Q�然后再增加它的mate�Q�他昄��会这栯��用，new一个cat对象出来�Q�然后就addMate�Q?

[code:1]Cat cat = new Cat();
cat.setXXX();
daoimpl.addMate(cat,mate);[/code:1]

但是��h��意看�Q�这个cat对象只是一个VO�Q�它没有被持久化�q�，它还不是PO�Q�它没有资格调用addMate�Ҏ��Q�因此调用addMate�Ҏ��? 会真正往数据库里面发送update的sql�Q�这个cat对象必须先被save到数据库�Q�在真正成�ؓ一个PO之后�Q�才具备addMate的资根{�?

你必��这��h��操作�Q?

[code:1]Cat cat = new Cat();
cat.setXXX();
daoimpl.addCat(cat);
daoimpl.addMate(cat, mate);[/code:1]

先持久化cat�Q�然后才能对cat�q�行其他的持久化操作。因此要求业务层的程序员必须清楚cat对象处于何种状态，到底是第一�U�，�q�是�W�三�U�。如果是�W�一�U�，��p��先save�Q�再addMate�Q�如果是�W�三�U�，��q��接addMate�?

但是最致命的是�Q�如果整个��Y件分层很多，业务层的�E�序员他拿到�q�个cat对象也可能是上层Web应用层传递过来的cat�Q�他自己也不知道�q�个cat�I�竟是VO�Q�没有被持久化过�Q�还是已�l�被持久化过�Q�那么他�Ҏ��没有办法写�E�序了�?

所以这��L��DAOImpl昄��是有问题的，它会对业务层的程序员造成很多�~�程上的陷阱�Q�业务层的程序员必须深刻的了解他调用的每个DAO对PO�? 象进行了何种状态管理，必须深刻的了解他的PO对象在�Q何时候处于什么确切的状态，才能保证�~�程的正��性，昄��q�是做不到的�Q�但是有�? saveOrUpdate�Q�这些问题就�q�刃而解了�?

现在你需要修改addMate�Ҏ��Q?

[code:1]public void addMate(Cat cat, Mate mate) {
Session session = ...;
Transacton tx = ...;
session.saveOrUpdate(cat);
cat.addMate(mate);
tx.commit();
session.close();
};[/code:1]

如上�Q�如果业务层的程序员传进来的是一个已�l�持久化�q�的PO对象�Q�那么Hibernate会更新cat对象(假设业务层的�E�序员在Session外面修改�q�cat的属�?�Q�如果传�q�来的是一个新new出来的对象，那么向数据库save�q�个PO对象�?

BTW: Hibernate此时�I�竟采取更新cat对象�Q�还是save cat对象�Q�取决于unsave-value的设定�?

�q�样�Q�业务层的程序员��׃��必再操心PO的状态问题了�Q�对于他们来��_��不管cat是new出来的对象，只是一个VO也好�Q�还是从数据库查询出来的的PO对象也好�Q�全部都是直接addMate��OK了：

[code:1]daoimple.addMate(cat, mate);[/code:1]

�q�便是saveOrUpdate的作用�?

中间开�?/a> 2008-09-01 19:31 发表评论