抛弃框架，如何实现分层架构下JDBC事务的控制

  现在很多项目，特别是web项目，为了提高开发效率，基本上都用上了框架，struts1，struts2.，spring，hibernate，springmvc，ibatise等等，在事务处理方面，spring的尤其突出，它对事务做了很好的封装，通过AOP的配置，可以灵活的配置在任何一层。但是很多时候，基于需求和应用方面考虑，直接使用JDBC进行事务控制还是很有必要的。

    事务应该是以业务逻辑为基础的；一个完整的业务应该对应业务层里的一个方法，而不应该是多个方法；如果业务执行过程出现异常，则整个事务应该回滚；所以，应该事务控放在业务层里；然而持久层的设计应该遵循一个很重要的原则：持久层应该保证操作的原子性，就是说持久层里的每个方法都应该是不可以分割的，也就是说数据库的连接自始至终都应该是同一个连接，而不是执行完某个Dao操作完毕并且数据库连接关闭后又重新打开一个新的数据库连接执行另一个Dao操作！

  上面的说法可能有点抽象，举个简单的例子来说：针对班级（clazze）和学生（student）的操作，要想删除某个班级，就需要先把该班级下的所有学生删除，再删除班级，这两个操作是应该放在同一个事务里的，要么同时删除学生和班级成功，要么同时失败，不能学生的数据被删除没了，而班级却没被删除，这就是上面所说的----原子性。

    可能上面的描述还是有点抽象，没关系，我们用代码说话。

先定义两个Dao接口，一个是班级的接口（ClazzeDao），一个是学生的接口（StudentDao），里面只提供删除的功能。

ClazzeDao：

[java]  view plain copy

1. /** 
2.  * FileName:     ClazzeDao.java 
3.  * CreationTime: 2011-8-14 
4.  * Author:       yjd 
5.  * EMail:        908599713@qq.com 
6.  * Site:         http://hi.csdn.net/tjcyjd 
7.  */  
8. package com.tjcyjd.dao;  
9.   
10. /** 
11.  * 班级接口 
12.  *  
13.  * @author yjd 
14.  */  
15. public interface ClazzeDao {  
16.     /** 根据id删除对应的班级 */  
17.     public void deleteClazzeByClazzeId(int clazzeId) throws DaoException;  
18.   
19. }  

StudentDao：

[java]  view plain copy

1. /** 
2.  * FileName:     StudentDao.java 
3.  * CreationTime: 2011-8-14 
4.  * Author:       yjd 
5.  * EMail:        908599713@qq.com 
6.  * Site:         http://hi.csdn.net/tjcyjd 
7.  */  
8. package com.tjcyjd.dao;  
9.   
10. /** 
11.  * 学生接口 
12.  *  
13.  * @author yjd 
14.  */  
15. public interface StudentDao {  
16.     /** 根据班级id删除该班级下的所有学生 */  
17.     public void deleteStudentByClazzeId(int clazzeId) throws DaoException;  
18. }  

定义完这两个Dao接口以后，应该是在对应的业务层（ClazzeService）中的删除班级的方法里调用这两个方法的。这样就把它们放在同一个事务中了。在调用前，我们还得做点事，弄个数据库连接工厂类（ConnectionFactory）和事务管理器类（TransactionManager）。

ConnectionFactory：

[java]  view plain copy

1. /** 
2.  * FileName:     ConnectionFactory.java 
3.  * CreationTime: 2011-8-14 
4.  * Author:       yjd 
5.  * EMail:        908599713@qq.com 
6.  * Site:         http://hi.csdn.net/tjcyjd 
7.  */  
8. package com.tjcyjd.commom;  
9.   
10. import java.io.IOException;  
11. import java.sql.Connection;  
12. import java.sql.SQLException;  
13. import java.util.Properties;  
14. import javax.sql.DataSource;  
15. import com.mchange.v2.c3p0.DataSources;  
16.   
17. /** 
18.  * 数据库连接工厂 
19.  *  
20.  * @author yjd 
21.  */  
22. public class ConnectionFactory {  
23.     private static Properties prop = new Properties();  
24.     // 数据源  
25.     private static DataSource ds = null;  
26.     // 用来把数据库连接绑定到当前线程上的变量  
27.     private static ThreadLocal<Connection> tl = new ThreadLocal<Connection>();  
28.     static {  
29.         try {  
30.             prop.load(Thread.currentThread().getContextClassLoader()  
31.                     .getResourceAsStream("jdbc.properties"));  
32.         } catch (IOException e) {  
33.             e.printStackTrace();  
34.             System.out.println("在classpath下没有找到jdbc.properties文件");  
35.         }  
36.         // 这里使用的是c3p0连接  
37.         try {  
38.             Class.forName("com.mysql.jdbc.Driver");  
39.             DataSource unpooled = DataSources.unpooledDataSource(prop  
40.                     .getProperty("url"), prop.getProperty("user"), prop  
41.                     .getProperty("password"));  
42.             ds = DataSources.pooledDataSource(unpooled);  
43.         } catch (ClassNotFoundException e) {  
44.             e.printStackTrace();  
45.         } catch (SQLException e) {  
46.             e.printStackTrace();  
47.         }  
48.     }  
49.   
50.     /** 
51.      * 获取数据库的Connection对象 
52.      *  
53.      * @return 
54.      */  
55.     public static synchronized Connection getConnection() {  
56.         Connection conn = tl.get(); // 当前线程取出连接实例  
57.         if (null == conn) {  
58.             try {  
59.                 conn = ds.getConnection(); // 从连接池中取出一个连接实例  
60.                 tl.set(conn); // 把它绑定到当前线程上  
61.             } catch (SQLException e) {  
62.                 e.printStackTrace();  
63.             }  
64.         }  
65.         return conn;  
66.     }  
67.   
68.     public static synchronized TransactionManager getTranManager() {  
69.         return new TransactionManager(getConnection());  
70.     }  
71. }  

TransactionManager：

[java]  view plain copy

1. /** 
2.  * FileName:     TransactionManager.java 
3.  * CreationTime: 2011-8-14 
4.  * Author:       yjd 
5.  * EMail:        908599713@qq.com 
6.  * Site:         http://hi.csdn.net/tjcyjd 
7.  */  
8. package com.tjcyjd.commom;  
9.   
10. import java.sql.Connection;  
11. import java.sql.SQLException;  
12. import com.tjcyjd.dao.DaoException;  
13.   
14. /** 
15.  * 事务管理器类 
16.  *  
17.  * @author yjd 
18.  */  
19. public class TransactionManager {  
20.     private Connection conn;  
21.   
22.     protected TransactionManager(Connection conn) {  
23.         this.conn = conn;  
24.     }  
25.   
26.     /** 
27.      * 开启事务 
28.      *  
29.      * @throws DaoException 
30.      */  
31.     public void beginTransaction() throws DaoException {  
32.         try {  
33.             if (null != conn && !conn.isClosed()) {  
34.                 conn.setAutoCommit(false); // 把事务提交方式改为手工提交  
35.             }  
36.         } catch (SQLException e) {  
37.             throw new DaoException("开户事务时出现异常", e);  
38.         }  
39.     }  
40.   
41.     /** 
42.      * 提交事务并关闭连接 
43.      *  
44.      * @throws DaoException 
45.      */  
46.     public void commitAndClose() throws DaoException {  
47.         try {  
48.             conn.commit(); // 提交事务  
49.             System.out.println("提交事务");  
50.         } catch (SQLException e) {  
51.             throw new DaoException("开启事务时出现异常", e);  
52.         } finally {  
53.             close(conn);  
54.         }  
55.     }  
56.   
57.     /** 
58.      * 回滚并关闭连接 
59.      *  
60.      * @throws DaoException 
61.      */  
62.     public void rollbackAndClose() throws DaoException {  
63.         try {  
64.             conn.rollback();  
65.             System.out.println("回滚事务");  
66.         } catch (SQLException e) {  
67.             throw new DaoException("回滚事务时出现异常", e);  
68.         } finally {  
69.             close(conn);  
70.         }  
71.     }  
72.   
73.     /** 
74.      * 关闭连接 
75.      *  
76.      * @param conn 
77.      * @throws DaoException 
78.      */  
79.     private void close(Connection conn) throws DaoException {  
80.         if (conn != null) {  
81.             try {  
82.                 conn.close();  
83.             } catch (SQLException e) {  
84.                 throw new DaoException("关闭连接时出现异常", e);  
85.             }  
86.         }  
87.     }  
88. }  

好了，可以开始进行我们的业务了（ClazzeService）。

ClazzeService：

[java]  view plain copy

1. /** 
2.  * FileName:     ClazzeService.java 
3.  * CreationTime: 2011-8-14 
4.  * Author:       yjd 
5.  * EMail:        908599713@qq.com 
6.  * Site:         http://hi.csdn.net/tjcyjd 
7.  */  
8. package com.tjcyjd.service;  
9.   
10. import com.tjcyjd.commom.ConnectionFactory;  
11. import com.tjcyjd.commom.TransactionManager;  
12. import com.tjcyjd.dao.ClazzeDao;  
13. import com.tjcyjd.dao.DaoException;  
14. import com.tjcyjd.dao.DaoFactory;  
15. import com.tjcyjd.dao.StudentDao;  
16.   
17. /** 
18.  * 班级操作业务类 
19.  *  
20.  * @author yjd 
21.  */  
22. public class ClazzeService {  
23.     private ClazzeDao clazzeDao = DaoFactory.getInstance("clazzeDao",  
24.             ClazzeDao.class);  
25.     private StudentDao studentDao = DaoFactory.getInstance("studentDao",  
26.             StudentDao.class);  
27.   
28.     /** 
29.      * 删除指定ID的班级 
30.      *  
31.      * @param clazzeId 
32.      */  
33.     public void deleteClazze(int clazzeId) {  
34.   
35.         TransactionManager tx = ConnectionFactory.getTranManager();  
36.         try {  
37.             tx.beginTransaction();  
38.             // 删除指定班级下的所有学生  
39.             studentDao.deleteStudentByClazzeId(clazzeId);  
40.             // 删除指定班级  
41.             clazzeDao.deleteClazzeByClazzeId(clazzeId);  
42.             // 提交事务并关闭连接  
43.             tx.commitAndClose();  
44.         } catch (DaoException e) {  
45.             e.printStackTrace();  
46.             // 异常回滚  
47.             tx.rollbackAndClose();  
48.         }  
49.     }  
50. }  

上面我们定义的两个Dao，我们没写它们的实现类呢，为了更明白，还是把他们（ClazzeDaoImpl，StudentDaoImpl）贴出来吧。

ClazzeDaoImpl：

[java]  view plain copy

1. /** 
2.  * FileName:     ClazzeDaoImpl.java 
3.  * CreationTime: 2011-8-14 
4.  * Author:       yjd 
5.  * EMail:        908599713@qq.com 
6.  * Site:         http://hi.csdn.net/tjcyjd 
7.  */  
8. package com.tjcyjd.dao.impl;  
9.   
10. import java.sql.Connection;  
11. import java.sql.SQLException;  
12.   
13. import org.apache.commons.dbutils.QueryRunner;  
14.   
15. import com.tjcyjd.commom.ConnectionFactory;  
16. import com.tjcyjd.dao.ClazzeDao;  
17. import com.tjcyjd.dao.DaoException;  
18.   
19. /** 
20.  * 班级接口实现类 
21.  *  
22.  * @author yjd 
23.  */  
24. public class ClazzeDaoImpl implements ClazzeDao {  
25.     private QueryRunner qr = new QueryRunner();  
26.   
27.     /** 删除指定班级 */  
28.     public void deleteClazzeByClazzeId(int clazzeId) throws DaoException {  
29.         Connection conn = ConnectionFactory.getConnection();  
30.         // 故意错写sql语句，多了个*。  
31.         String sql = "delete * from  clazze where clazze_id=?";  
32.         try {  
33.             qr.update(conn, sql, clazzeId);  
34.             System.out.println("成功执行了deleteStudentByClazzeId方法，但未提交事务");  
35.         } catch (SQLException e) {  
36.             throw new DaoException("删除指定ID的部门时出现异常", e);  
37.         }  
38.     }  
39. }  

StudentDaoImpl：

[java]  view plain copy

1. /** 
2.  * FileName:     StudentDaoImpl.java 
3.  * CreationTime: 2011-8-14 
4.  * Author:       yjd 
5.  * EMail:        908599713@qq.com 
6.  * Site:         http://hi.csdn.net/tjcyjd 
7.  */  
8. package com.tjcyjd.dao.impl;  
9.   
10. import java.sql.Connection;  
11. import java.sql.SQLException;  
12.   
13. import org.apache.commons.dbutils.QueryRunner;  
14.   
15. import com.tjcyjd.commom.ConnectionFactory;  
16. import com.tjcyjd.dao.DaoException;  
17. import com.tjcyjd.dao.StudentDao;  
18.   
19. /** 
20.  * 学生接口实现类 
21.  *  
22.  * @author yjd 
23.  */  
24. public class StudentDaoImpl implements StudentDao {  
25.     private QueryRunner qr = new QueryRunner();  
26.   
27.     /** 删除指定班级下的所有学生 */  
28.     public void deleteStudentByClazzeId(int clazzeId) throws DaoException {  
29.         Connection conn = ConnectionFactory.getConnection();  
30.         String sql = "delete from student where clazze_id=?";  
31.         try {  
32.             qr.update(conn, sql, clazzeId);  
33.             System.out.println("成功执行了deleteStudentByClazzeId方法，但未提交事务");  
34.         } catch (SQLException e) {  
35.             throw new DaoException("删除指定ID的部门时出现异常", e);  
36.         }  
37.     }  
38. }  

最后我们写个测试类（ClazzeServiceTest）进行代码的测试。

ClazzeServiceTest：

[java]  view plain copy

1. /** 
2.  * FileName:     ClazzeServiceTest.java 
3.  * CreationTime: 2011-8-14 
4.  * Author:       yjd 
5.  * EMail:        908599713@qq.com 
6.  * Site:         http://hi.csdn.net/tjcyjd 
7.  */  
8. package com.tjcyjd.service;  
9.   
10. /** 
11.  * ClazzeService的测试类 
12.  *  
13.  * @author yjd 
14.  */  
15. public class ClazzeServiceTest {  
16.   
17.     /** 
18.      * 主方法 
19.      *  
20.      * @param args 
21.      */  
22.     public static void main(String[] args) {  
23.         testDeleteDept(2);  
24.     }  
25.   
26.     /** 
27.      * 删除指定班级 
28.      */  
29.     public static void testDeleteDept(int clazzeId) {  
30.         ClazzeService sf = new ClazzeService();  
31.         sf.deleteClazze(clazzeId);  
32.   
33.     }  
34.   
35. }  

项目的整体结构如下图：