Spring事务的问题，bulkUpdate,或query.executeUpdate

今天在测试spring任务调度时，突然发现我配的声明事务不起作用了，找了好久才发现不是我的事务的问题，是我在Dao中用了一个方法有问题

方法如下：
public void updateByIds(final Set updateIds)throws DaoException{
try {
String queryString="update from Yaoyueyingyue y set y.state='2' where y.yaoyueid in (?)";
getHibernateTemplate().bulkUpdate(queryString, updateIds.toArray());
} catch (Exception e) {
e.printStackTrace();
throw new DaoException(this.getClassName()+e.getMessage());
}

updateIds是一个包含要更新的编号集合，我发现用这个方法在我Manager中调用Dao事务就不起作用了，后来又改成这样
public void updateByIds(final Set updateIds)throws DaoException{
try {
getHibernateTemplate().execute(new HibernateCallback(){
final String hql="update Yaoyueyingyue y set y.state=2 where yaoyueid in (:yaoyueid)";
public Object doInHibernate(Session session) throws HibernateException, SQLException {
Query query=session.createQuery(hql);
query.setParameterList("yaoyueid", updateIds);
query.executeUpdate();
return null;
}

    });

} catch (Exception e) {
e.printStackTrace();
throw new DaoException(this.getClassName()+e.getMessage());
}

}

事务还是不行，这两个方法好像不受spring AOP事务管理，只要执行到这个Dao的方法就自动提交了，出来异常也不能回滚，真是郁闷，小弟对这块不是很明白，为什么事务就不行了呢，希望那位牛人，帮我解释下，谢谢了，

我的spring声明事务大概如下：



true

<bean id="atomikosUserTransaction" class="com.atomikos.icatch.jta.UserTransactionImp">  
    <property name="transactionTimeout" value="300"/>    
</bean>  

<bean id="springTransactionManager" class="org.springframework.transaction.jta.JtaTransactionManager">  
    <property name="transactionManager"><ref bean="atomikosTransactionManager"  /></property>  
    <property name="userTransaction"><ref bean="atomikosUserTransaction"  /></property>  
</bean>  

aop:config
<!--
This definition creates auto-proxy infrastructure based on the given pointcut,
expressed in AspectJ pointcut language. Here: applying the advice named
"txAdvice" to all methods on classes named PetStoreImpl.
-->
advice-ref="txAdvice" />
advice-ref="txAdvice" />
/aop:config

<!-- @Transactional 时要使用下面一行 -->

<!-- -->
<!-- Transaction advice definition, based on method name patterns.
Defaults to PROPAGATION_REQUIRED for all methods whose name starts with
"insert" or "update", and to PROPAGATION_REQUIRED with read-only hint
for all other methods.-->
<!-- 引用springTransactionManager -->

tx:attributes


....

/tx:attributes
/tx:advice

atomikosTransactionManager这个东西不用管，是一个开源的支持JTA分布式的JAR，希望有人能够为我解答........
[b]问题补充：[/b]
谢谢你的解答，但是我还是不明白你的意思，你是指我的Dao中用了内部类吗，你所指的 “调用updateByIds方法 的代码 跳出你的当前类 然后在别的类调用当前了类的接口中的方法updateByIds ”是指什么意思，能不能说明白点，谢谢了！！！
[b]问题补充：[/b]
谢谢你的答复，你的意思我也理解，但好像不是这个问题，因为我并没有像你说的那样在类的内部调用，我的所有方法都是在业务逻辑层调用的Manager层，Manager层我是在Spring中配置了的声明事务的，我给你据个例子：
这两个方法都是Dao中的
方法一:
[code="java"]
public void updateByIds(final Set updateIds)throws DaoException{
try {
/*String queryString="update from Yaoyuepub y set y.state='2' where y.yaoyueid in (?)";
getHibernateTemplate().bulkUpdate(queryString, updateIds.toArray());*/

        getHibernateTemplate().execute(new HibernateCallback(){
            final String hql="update Yaoyuepub y set y.state=2 where yaoyueid in (:yaoyueid)";
            public Object doInHibernate(Session session) throws HibernateException, SQLException {
                Query query=session.createQuery(hql);
                query.setParameterList("yaoyueid", updateIds);
                query.executeUpdate();
                return null;
            }

        }
        );
    } catch (Exception e) {
        e.printStackTrace();
        throw new DaoException(this.getClassName()+e.getMessage());
    }       
}

[/code]

这个方法是把所有的要改的ID都一次性更新调，我是不想执行多条sql,在Manager中调用这个方法事务就起不了作用，还有一个方法，就是普通的更新对象
[code="java"]
public void update(T t) throws DaoException {
try {
getHibernateTemplate().update(t);
} catch (Exception e) {
throw new DaoException(getClassName() + " update exception...",e);
}

}

[/code]

要是把刚才Manager中调用改成循环执行下面的方法一个一个对象，就是有事务的，所以调用都一样，更类的内部调用应给没有关系的，我认为不管是query.executeUpdate还是spring自己提供的bulkUpdate这两个方法都是要写sql的，目的是满足批量更新和更大的灵活性，但是事务就不行了，我认为肯定可以让声明式事务支持这两个方法，就是不知道怎么配置一下，你可以自己在代码中分别做个例子试试，看看是不是用批量更新事务就控制不了了，

这就是我的理解，还请多多指教，谢谢诶！！！
[b]问题补充：[/b]

我测试过了，以为可以了，但是还是不行，下面是我调用的一小部分代码
[code="java"]
public void runThread() {
Set updateIds = new HashSet();
for (Yaoyueyingyue yaoyueyingyue : yaoyueyingyues) {

updateIds.add(yaoyueyingyue.getYaoyueid());

}

if (updateIds.size() > 0) {
yaoyuepubDao.updateByIds(updateIds);
if(true)
throw new RuntimeException("AAAAAAAAAAAAAAAAAAAAAAAAA");
yaoyueyingyueDao.updateByIds(updateIds);
}

[/code]
上面是我Manager中Spring任务调度自动执行的方法的一小部分，我中间估计抛出了异常，但是yaoyuepubDao数据库中都更新了，事务不起作用，我估计其实就是和bulkUpdate方法一样，只要这个方法能用事务控制了的话，应该没问题了
[b]问题补充：[/b]
下面是我在网上拷贝的--------------------------------

　　Spring的HibernateTemplate提供了Hibernate的完美封装，即通过匿名类实现回调，来保证Session的自动资源管理和事务的管理。其中核心方法是：

　　java代码:

HibernateTemplate.execute(new HibernateCallback() {
　public Object doInHibernate(Session session) throws HibernateException {
　　....
　}
}

　　回调方法提供了session作为参数，有了session，就可以自由的使用Hibernate API编程了。使用了spring的之后，代码修改如下：

　　web层代码：

　　java代码:

DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Department.class);
detachedCriteria.createAlias("employees", "e").add(Restrictions.eq("name", "department")).add(Restrictions.gt(("e.age"), new Integer(20)));
departmentManager.findByCriteria(detachedCriteria);

　　构造detachedCriteria，作为参数传递给departmentManager

　　业务层代码使用spring，DepartmentManager的findByCriteria如下：

　　java代码:

public List findByCriteria(final DetachedCriteria detachedCriteria) {
　return (List) getHibernateTemplate().execute(new HibernateCallback() {
　　public Object doInHibernate(Session session) throws HibernateException {
　　　Criteria criteria = detachedCriteria.getExecutableCriteria(session);
　　　return criteria.list();
　　}
　});
}

　　实际上也就是：

　　java代码:

Criteria criteria = detachedCriteria.getExecutableCriteria(session);
return criteria.list();

　　而已

　　但是该程序代码执行，会抛出强制类型转换异常！

　　我跟踪了一下spring和Hibernate源代码，原因如下：

　　spring的HibernateTemplate的execute方法提供的回调接口具有Session作为参数，但是实际上，默认情况下，HibernateTemplate传递给回调接口的session并不是org.hibernate.impl.SessionImpl类，而是SessionImpl类的一个Proxy类。之所以替换成为一个Proxy类，HibernateTemplate的注释说明，Proxy提供了一些额外的功能，包括自动设置Cachable，Transaction的超时时间，Session资源的更积极的关闭等等。

　　java代码:

private boolean exposeNativeSession = false;
...

　　execute方法内部：

Session sessionToExpose = (exposeNativeSession ? session : createSessionProxy(session));

　　但是遗憾的是，Hibernate的DetachedCriteria的setExecutableCriteria方法却要求将session参数强制转为SessionImpl，但是spring传过来的却是一个Proxy类，因此就报错了。

　　java代码:

public Criteria getExecutableCriteria(Session session) {
　impl.setSession( (SessionImpl) session ); // 要求SessionImpl，Spring传递的是Proxy
　return impl;
}

　　解决方法，禁止Spring的HibernateTemplate传递Proxy类，强制要求它传递真实的SessionImpl类，即给exexute方法增加一个参数，提供参数为true，如下：

　　java代码:

public List findByCriteria(final DetachedCriteria detachedCriteria) {
　return (List) getHibernateTemplate().execute(new HibernateCallback() {
　　public Object doInHibernate(Session session) throws HibernateException {
　　　Criteria criteria = detachedCriteria.getExecutableCriteria(session);
　　　return criteria.list();
　　}
　}, true);
}

[b]问题补充：[/b]
bulkUpdate这个方法按你给的源码，那我是用错了，但是你所说的我的模拟异常不再AOP的事务之内，我就不同意你的观点了，[code="java"]

if (updateIds.size() > 0) {

yaoyuepubDao.updateByIds(updateIds); // 事务开启 执行updateByIds 事务提交

if(true)

throw new RuntimeException("AAAAAAAAAAAAAAAAAAAAAAAAA");

yaoyueyingyueDao.updateByIds(updateIds); // 事务开启 执行updateByIds 事务提交

}

[/code]

我这段代码是两个Dao的操作，而这两个Dao的操作是被封装在一个Manger中的方法中的，Manager的每个方法都是有事务的，在操作玩第一个Dao后抛出一个RunTime异常，这时候第一个Dao操作已经执行了，这时候事务应该回滚的，不应该去更新的第一个Dao的操作，Manager中本来就业务层，中间有好多的Dao操作，事务应该控制这些Dao要不都提交，要不都回滚，你说呢，而你说的在11-12行之间加异常，那在一个Dao中，再说的的Dao是没有配事务的，又何谈回滚呢，要是把我上面两个Dao操作改成普通的对象更新，是可以回滚的，这个我肯定
比如这样
[code="java"]
yaoyuepubDao.update(yaoyuepub);
if(true)

throw new RuntimeException("AAAAAAAAAAAAAAAAAAAAAAAAA");

yaoyueyingyueDao.update(yaoyueyingyue);

[/code]

这个时候如果抛出异常，yaoyuepub是不会更新到数据库的，会回滚的，所以我总结就是executeUpdate(sql)这个方法我们直接sql,和操作对象是不一样的的，具体我也没有研究
[b]问题补充：[/b]
[code="java"]
public void updateByIds(final Set updateIds)throws DaoException{

try {

    getHibernateTemplate().execute(new HibernateCallback(){   
        final String hql="update Yaoyuepub y set y.state=2 where yaoyueid in (:yaoyueid)";   
        public Object doInHibernate(Session session) throws HibernateException, SQLException {   
            Query query=session.createQuery(hql);   
            query.setParameterList("yaoyueid", updateIds);   
            query.executeUpdate();   
            return null;   
        }   

    }   
    , true);   
} catch (Exception e) {   
    e.printStackTrace();   
    throw new DaoException(this.getClassName()+e.getMessage());   
}   

}

[/code]

把上面的updateIds方法改成：
[code="java"]
public void updateByIds(final Set updateIds)throws DaoException{
try {
DetachedCriteria dc=DetachedCriteria.forClass(Yaoyuepub.class);
dc.add(Restrictions.in("yaoyueid", updateIds));
List yaoyuepubs=select(dc);
for(Yaoyuepub y:yaoyuepubs){
update(y);
}

                } catch (Exception e) {
        e.printStackTrace();
        throw new DaoException(this.getClassName()+e.getMessage());
    }       
}

[/code]

所有的调用都不变，spring事务就起作用了，说明自己createQuery然后executeUpdate是不被事务管理的，后其他都没有关系