分层架构下的纯JDBC事务控制简单解决方案

对目前的JavaEE企业应用开发来说，基本都会采用分层的架构, 这样可以分散关注、松散耦合、逻辑复用、标准定义。例如，目前使用SSH组合时典型的四层架构：表示层、业务层、持久层和数据层；那么，在四层架构中，事务的控制应该放在哪一层呢？

如果使用Spring框架，它对事务做了很好的封装，通过它的AOP配置，可以灵活的配置在任何一层；但是在很多的需求和应用，直接使用JDBC事务控制还是有其优势的。所以，本文来讨论纯JDBC事务的控制问题。

其实，事务是以业务逻辑为基础的；一个完整的业务应该对应业务层里的一个方法；如果业务操作失败，则整个事务回滚；所以，事务控制是绝对应该放在业务层的；但是,持久层的设计应该遵循一个很重要的原则：持久层应该保证操作的原子性，就是说持久层里的每个方法都应该是不可以分割的。

例如针对一个部门和员工的CRUD操作。如果要删除某个部门，就应该在DeptDao中有一个删除部门的方法：
public class DeptDao {
public void deleteDept(int id) ; //删除指定ID的部门
}
在EmpDao中有一个删除指定部门下的所有员工的方法
public interface EmpDao{
public void deleteEmpByDeptId(int id); //删除指定部门下的所有员工
}
这样，就应该在业务层DeptService中的删除部门方法中组合这两个方法，即把它们放置在同一个事务中：
public class DeptService{
public void deleteDept(int id){
try{
//启动JDBC事务
//调用EmpDao中的deleteEmpByDeptId(id)方法
//调用DeptDao中的deleteDept(id)方法
//操作正常，提交事务
}catch(Exception e){
//异常，回滚事务
}
}
}

要让这两个Dao操作在同一个事务，最主要的一点就是：启动JDBC事务中使用的数据库连接和两个Dao操作方法里获得的数据库连接要是同一个连接。参照Spring的JDBC事务原理，可以使用ThreadLocal类, 在启动JDBC事务中把数据库连接绑定到线程，以保证在同一个线程下获得的都是同一个连接。这样就达到目的了。

如下数据库工具类：

view plain

1. packagecom.tjitcast.common;
2. importjava.io.IOException;
3. importjava.sql.Connection;
4. importjava.sql.SQLException;
5. importjava.util.Properties;
6. importjavax.sql.DataSource;
7. importcom.mchange.v2.c3p0.DataSources;
8. importcom.tjitcast.dao.DaoException;
9. /**
10. *数据库工具类
11. *可以根据classpath下配置文件jdbc.properties中配置的参数来获取数据库连接并绑定到当前线程上
12. *可以获取JDBC的事务管理器
13. *@authorqiujy
14. *@version0.9Beta
15. */
16. publicclassDbUtils{
17. privatestaticPropertiesprop=newProperties();
18. /**数据源*/
19. privatestaticDataSourceds=null;
21. //用来把Connection绑定到当前线程上的变量
22. privatestaticThreadLocal<Connection>tl=newThreadLocal<Connection>();
23. static{
24. try{
25. prop.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("jdbc.properties"));
26. }catch(IOExceptione){
27. e.printStackTrace();
28. System.out.println("在classpath下没有找到jdbc.properties文件");
29. }
31. //使用C3P0连接池技术
32. try{
33. Class.forName("com.mysql.jdbc.Driver");
35. DataSourceunpooled=DataSources.unpooledDataSource(
36. prop.getProperty("url"),
37. prop.getProperty("user"),
38. prop.getProperty("password"));
39. ds=DataSources.pooledDataSource(unpooled);
41. }catch(ClassNotFoundExceptione){
42. e.printStackTrace();
43. }catch(SQLExceptione){
44. e.printStackTrace();
45. }
46. }
48. privateDbUtils(){}
50. /**
51. *根据数据库的默认连接参数获取数据库的Connection对象，并绑定到当前线程上
52. *@return成功，返回Connection对象，否则返回null
53. */
54. publicstaticsynchronizedConnectiongetConnection(){
55. Connectionconn=tl.get();//先从当前线程上取出连接实例
57. if(null==conn){//如果当前线程上没有Connection的实例
58. try{
59. conn=ds.getConnection();//从连接池中取出一个连接实例
60. tl.set(conn);//把它绑定到当前线程上
61. }catch(SQLExceptione){
62. e.printStackTrace();
63. }
64. }
65. returnconn;
66. }
67. /**
68. *获取事务管理器
69. *@return事务管理实例
70. */
71. publicstaticsynchronizedTransactionManagergetTranManager(){
72. returnnewTransactionManager(getConnection());
73. }
75. /**
76. *关闭数据库连接，并卸装线程绑定
77. *@paramconn要关闭数据库连接实例
78. *@throwsDaoException
79. */
80. protectedstaticvoidclose(Connectionconn)throwsDaoException{
81. if(conn!=null){
82. try{
83. conn.close();
84. }catch(SQLExceptione){
85. thrownewDaoException("关闭连接时出现异常",e);
86. }finally{
87. tl.remove();//卸装线程绑定
88. }
89. }
90. }
92. }

如下事务管理器类：

1. packagecom.tjitcast.common;
2. importjava.sql.Connection;
3. importjava.sql.SQLException;
4. importcom.tjitcast.dao.DaoException;
5. /**
6. *事务管理器
7. *@authorqiujy
8. *@version0.9Beta
9. */
10. publicclassTransactionManager{
11. privateConnectionconn;
13. protectedTransactionManager(Connectionconn){
14. this.conn=conn;
15. }
17. /**开启事务*/
18. publicvoidbeginTransaction()throwsDaoException{
19. try{
20. conn.setAutoCommit(false);//把事务提交方式改为手工提交
21. }catch(SQLExceptione){
22. thrownewDaoException("开户事务时出现异常",e);
23. }
24. }
26. /**提交事务并关闭连接*/
27. publicvoidcommitAndClose()throwsDaoException{
28. try{
29. conn.commit();//提交事务
30. }catch(SQLExceptione){
31. thrownewDaoException("提交事务时出现异常",e);
32. }finally{
33. DbUtils.close(conn);
34. }
35. }
37. /**回滚并关闭连接*/
38. publicvoidrollbackAndClose()throwsDaoException{
39. try{
40. conn.rollback();
41. }catch(SQLExceptione){
42. thrownewDaoException("回滚事务时出现异常",e);
43. }finally{
44. DbUtils.close(conn);
45. }
46. }
47. }

如下业务层类：

view plain

1. packagecom.tjitcast.service;
2. importjava.util.List;
3. importcom.tjitcast.common.DbUtils;
4. importcom.tjitcast.common.TransactionManager;
5. importcom.tjitcast.dao.DaoException;
6. importcom.tjitcast.dao.DaoFactory;
7. importcom.tjitcast.dao.DeptDao;
8. importcom.tjitcast.dao.EmployeeDao;
9. importcom.tjitcast.entity.Dept;
10. importcom.tjitcast.entity.Employee;
11. importcom.tjitcast.entity.PageModel;
12. /**
13. *业务层门面-->添加事务控制
14. *@authorqiujy
15. */
16. publicclassServiceFacade{
17. privateDeptDaodeptDao=DaoFactory.getInstance("deptDao",DeptDao.class);
18. privateEmployeeDaoempDao=DaoFactory.getInstance("empDao",EmployeeDao.class);
20. /**
21. *新增部门
22. *@paramdept
23. */
24. publicvoidinsertDept(Deptdept){
25. TransactionManagertx=DbUtils.getTranManager();
26. try{
27. tx.beginTransaction();
29. deptDao.insert(dept);
31. tx.commitAndClose();
32. }catch(DaoExceptione){
33. tx.rollbackAndClose();
34. }
35. }
37. /**
38. *新增员工
39. *@paramemp员工
40. */
41. publicvoidinsertEmp(Employeeemp){
42. TransactionManagertx=DbUtils.getTranManager();
43. try{
44. tx.beginTransaction();
46. empDao.insert(emp);
48. tx.commitAndClose();
49. }catch(DaoExceptione){
50. tx.rollbackAndClose();
51. }
52. }
54. /**
55. *获取所有部门的列表
56. *@return部门列表
57. */
58. publicList<Dept>getDeptList(){
59. List<Dept>list=null;
61. TransactionManagertx=DbUtils.getTranManager();
62. try{
63. tx.beginTransaction();
65. list=deptDao.getDeptList();
67. tx.commitAndClose();
68. }catch(DaoExceptione){
69. e.printStackTrace();
70. tx.rollbackAndClose();
71. }
73. returnlist;
74. }
76. /**
77. *获取指定部门下的员工分页列表
78. *@paramdeptId
79. *@parampageNo
80. *@parampageSize
81. *@return符合条件的PageModel
82. */
83. publicPageModel<Employee>getEmpListByDeptId(intdeptId,intpageNo,intpageSize){
84. PageModel<Employee>pm=null;
85. TransactionManagertx=DbUtils.getTranManager();
86. try{
87. tx.beginTransaction();
89. pm=empDao.getEmpListByDeptId(deptId,pageNo,pageSize);
91. tx.commitAndClose();
92. }catch(DaoExceptione){
93. tx.rollbackAndClose();
94. }
95. returnpm;
96. }
98. /**
99. *删除指定ID的部门
100. *@paramid部门ID
101. */
102. publicvoiddeleteDept(intid){
104. TransactionManagertx=DbUtils.getTranManager();
105. try{
106. tx.beginTransaction();
108. empDao.deleteByDeptId(id);//先删除指定ID部门下的所有员工
109. deptDao.delete(id);//再删除该部门
111. tx.commitAndClose();
112. }catch(DaoExceptione){
113. tx.rollbackAndClose();
114. }
115. }
116. }

具体的示例代码结构如下（Eclipse工程）：

原文 ：

分层架构下的纯JDBC事务控制简单解决方案