今天在测试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

advice-ref="txAdvice" />
advice-ref="txAdvice" />
/aop:config

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

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是不被事务管理的，后其他都没有关系

多线程下如何保证事务？

白开水233

1个回复