问题：客户在其数据库操作过程中需要调用我们的工作流接口，这样就需要将我们的工作流操作与他们的业  务操作置于同一个事务中。我们的服务采用的都是spring的声明式事务，而客户采用的是对connection进行事务处理。

如何保证JDBC事务的一致性？

想到的解决方案一：使用jta事务，用tomcat+jotm提供事务管理器。为什么一开始就想到要使用jta事务？？实际上我们和客户都是使用的同一个数据库，为了方便，各自使用了不同的数据库连接方式，使用jta的话确实有bt的意思在里面。但是事实上是我们的第一反应都是jta。最后没有采用该方法的原因也很简单：我没有将jotm配置成功！汗一个。

想到的解决方案二：将客户的这些特定代码用spring管理起来。因为要修改客户部分代码，这个方案遭到了客户的强烈反对。于是放弃。

想到的解决方案三：客户数据库操作与我们的服务使用同一个数据库连接。然后编程处理事务。存在两种方式：一种是把客户的连接传给我们，另一种则是把我们的连接传给客户。第一种方式对我们的影响太大，所以最后决定采用后一种方式：从hibernate session中获取connection然后传递给客户。接下来查看一下HibernateTemplate的execute()方法，思路就很简单了：获取定义的sessionFactory-->创建一个新的session并打开-->将session与当前线程绑定-->给客户代码返回connection-->打开事务-->客户使用我们传递的connection进行数据库操作-->我们不带声明事务的服务操作-->提交事务-->解除绑定。

JDBC事务实际要注意的地方是：

1、将session与当前线程绑定使用的TransactionSynchronizationManager.bindResource()方法，这样在HibernateTemplate里才能找到session；

2、我们的服务一定要把声明式事务彻底干掉，否则会有commit;

3、我们服务调用完毕后一定要flush session，否则客户代码不会感知数据库里的数据变化。

最终解决：使用了spring里常用的模板和回调。JDBC事务代码如下：

public class TransactionTemplate {  
    protected final Log logger = LogFactory.getLog(TransactionTemplate.class);  
    private FlushMode flushMode = FlushMode.ALWAYS;  
    public Object execute(TransactionCallback callback) {  
        //首先获取sessionFactory  
        SessionFactory sessionFactory = (SessionFactory) Framework.getEngine()  
                .getContainer().getComponent("sessionFactory");  
        //创建一个新的session并打开  
        logger.debug("Opening single Hibernate Session in TransactionTemplate");  
        Session session = getSession(sessionFactory);  
        //将session与当前线程绑定  
        TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(session));  
        //获取数据库连接  
        Connection conn = session.connection();  
        Object result = null;  
        Transaction transaction = null;  
        try {  
            //开始处理JDBC事务  
            transaction = session.beginTransaction();  
            try {  
                result = callback.doInTransaction(conn);  
            }  
            catch (RuntimeException ex) {  
                doRollback(session, transaction);  
                throw ex;  
            }  
            catch (Error err) {  
                doRollback(session, transaction);  
                throw err;  
            }  
            //如果数据库操作过程中没有发生异常则提交事务  
            transaction.commit();  
        } catch (WorkflowException e) {  
            logger.error("数据库操作失败，事务回滚也失败！");  
            throw e;  
        } catch (RuntimeException ex) {  
            logger.error("数据库操作失败，事务被回滚！");  
            throw ex;  
        } catch (Error err) {  
            logger.error("数据库操作失败，事务被回滚！");  
            throw err;  
        } finally {  
            // 将session与当前线程解除绑定  
            TransactionSynchronizationManager.unbindResource(sessionFactory);  
            doClose(session);  
        }  
        return result;  
    }  
 
    protected Session getSession(SessionFactory sessionFactory) {  
        Session session = SessionFactoryUtils.getSession(sessionFactory, true);  
        FlushMode flushMode = getFlushMode();  
        if (flushMode != null) {  
            session.setFlushMode(flushMode);  
        }  
        return session;  
    }  
 
    private void doRollback(Session session, Transaction transaction) {  
        logger.debug("数据库操作异常，开始回滚事务");  
        try {  
            transaction.rollback();  
            logger.debug("回滚事务成功！");  
        }  
        catch (Exception e) {  
            logger.error("回滚事务失败！");  
            throw new WorkflowException("回滚事务失败！");  
        } finally {  
            session.clear();  
        }  
    }  
 
    private void doClose(Session session) {  
        logger.debug("开始关闭连接");  
        try {  
            session.close();  
        }  
        catch (Exception e) {  
            logger.error("关闭连接失败！");  
            throw new WorkflowException("关闭连接失败！");  
        }  
    }  
 
    public FlushMode getFlushMode() {  
        return flushMode;  
    }  
 
    public void setFlushMode(FlushMode flushMode) {  
        this.flushMode = flushMode;  
    }  
}  
public interface TransactionCallback {  
 
    Object doInTransaction(Connection conn);  
}调用伪代码：  
    public void methodA(){  
        TransactionTemplate transactionTemplate=new TransactionTemplate();  
        transactionTemplate.execute(new TransactionCallback(){  
            public Object doInTransaction(Connection conn) {  
                //客户代码  
                client.method1("1");  
                //我们代码 直接使用  
                our.method2();  
                //客户代码  
                client.method3("l");  
                return null;    
            }  
        });  
    } 

【编辑推荐】

1. 在Weblogic中实现JDBC的功能
2. 详解JDBC与Hibernate区别
3. JDBC连接MySQL数据库关键四步
4. 五步精通SQL Server 2000 JDBC驱动安装与测试
5. 详解JDBC驱动的四种类型
6. JDBC存储过程在Oracle中的获取结果集