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

import java.io.IOException;  

import java.sql.Connection;  

import java.sql.SQLException;  

import java.util.Properties;  

import javax.sql.DataSource;  

import com.mchange.v2.c3p0.DataSources;  

import com.tjitcast.dao.DaoException;  

/** 

 *  数据库工具类 

 *  可以根据classpath下配置文件jdbc.properties中配置的参数来获取数据库连接并绑定到当前线程上 

 *  可以获取JDBC的事务管理器 

 * @author qiujy 

 * @version 0.9Beta 

 */  

public class DbUtils {  

    private static Properties prop = new Properties();  

    /** 数据源 */  

    private static DataSource ds = null;   

      

    //用来把Connection绑定到当前线程上的变量  

    private static ThreadLocal<Connection> tl = new ThreadLocal<Connection>();  

    static{  

        try {  

            prop.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("jdbc.properties"));  

        } catch (IOException e) {  

            e.printStackTrace();  

            System.out.println("在classpath下没有找到jdbc.properties文件");  

        }  

          

        //使用C3P0连接池技术  

        try {  

            Class.forName("com.mysql.jdbc.Driver");  

              

            DataSource unpooled = DataSources.unpooledDataSource(  

                    prop.getProperty("url"),  

                    prop.getProperty("user"),  

                    prop.getProperty("password"));  

            ds = DataSources.pooledDataSource(unpooled);  

              

        } catch (ClassNotFoundException e) {  

            e.printStackTrace();  

        } catch (SQLException e) {  

            e.printStackTrace();  

        }  

    }  

      

    private DbUtils(){}  

      

    /** 

     * 根据数据库的默认连接参数获取数据库的Connection对象，并绑定到当前线程上 

     * @return 成功，返回Connection对象，否则返回null 

     */  

    public static synchronized Connection getConnection(){  

        Connection conn = tl.get(); //先从当前线程上取出连接实例  

          

        if(null == conn){ //如果当前线程上没有Connection的实例   

            try {  

                conn = ds.getConnection(); // 从连接池中取出一个连接实例   

                tl.set(conn);  //把它绑定到当前线程上  

            } catch (SQLException e) {  

                e.printStackTrace();  

            }  

        }  

        return conn;  

    }  

    /** 

     * 获取事务管理器 

     * @return 事务管理实例 

     */  

    public static synchronized TransactionManager getTranManager(){  

        return new TransactionManager(getConnection());  

    }  

      

    /** 

     * 关闭数据库连接，并卸装线程绑定 

     * @param conn 要关闭数据库连接实例 

     * @throws DaoException  

     */  

    protected static void close(Connection conn) throws DaoException{  

        if(conn != null){  

            try {  

                conn.close();  

            } catch (SQLException e) {  

                throw new DaoException("关闭连接时出现异常",e);  

            } finally {  

                    tl.remove(); //卸装线程绑定  

            }  

        }  

    }  

      

}  

 

 

如下事务管理器类：

 

[java] view plaincopy  

1. package com.tjitcast.common;  
2. import java.sql.Connection;  
3. import java.sql.SQLException;  
4. import com.tjitcast.dao.DaoException;  
5. /** 
6.  * 事务管理器 
7.  * @author qiujy 
8.  * @version 0.9Beta 
9.  */  
10. public class TransactionManager {  
11.     private Connection conn;  
12.       
13.     protected TransactionManager(Connection conn) {  
14.         this.conn = conn;  
15.     }  
16.       
17.     /** 开启事务 */  
18.     public void beginTransaction() throws DaoException{  
19.         try {  
20.             conn.setAutoCommit(false);  //把事务提交方式改为手工提交  
21.         } catch (SQLException e) {  
22.             throw new DaoException("开户事务时出现异常",e);  
23.         }  
24.     }  
25.       
26.     /** 提交事务并关闭连接 */  
27.     public void commitAndClose() throws DaoException{  
28.         try {  
29.             conn.commit(); //提交事务  
30.         } catch (SQLException e) {  
31.             throw new DaoException("提交事务时出现异常",e);  
32.         }finally{  
33.             DbUtils.close(conn);  
34.         }  
35.     }  
36.       
37.     /** 回滚并关闭连接 */  
38.     public void rollbackAndClose()throws DaoException{  
39.         try {  
40.             conn.rollback();  
41.         } catch (SQLException e) {  
42.             throw new DaoException("回滚事务时出现异常",e);  
43.         }finally{  
44.             DbUtils.close(conn);  
45.         }  
46.     }  
47. }  

 

 

如下业务层类：

 

[java] view plaincopy  

1. package com.tjitcast.service;  
2. import java.util.List;  
3. import com.tjitcast.common.DbUtils;  
4. import com.tjitcast.common.TransactionManager;  
5. import com.tjitcast.dao.DaoException;  
6. import com.tjitcast.dao.DaoFactory;  
7. import com.tjitcast.dao.DeptDao;  
8. import com.tjitcast.dao.EmployeeDao;  
9. import com.tjitcast.entity.Dept;  
10. import com.tjitcast.entity.Employee;  
11. import com.tjitcast.entity.PageModel;  
12. /** 
13.  * 业务层门面  --> 添加事务控制 
14.  * @author qiujy 
15.  */  
16. public class ServiceFacade {  
17.     private DeptDao deptDao = DaoFactory.getInstance("deptDao", DeptDao.class);  
18.     private EmployeeDao empDao  = DaoFactory.getInstance("empDao", EmployeeDao.class);  
19.       
20.     /** 
21.      * 新增部门 
22.      * @param dept 
23.      */  
24.     public void insertDept(Dept dept){  
25.         TransactionManager tx = DbUtils.getTranManager();  
26.         try{  
27.             tx.beginTransaction();  
28.               
29.             deptDao.insert(dept);  
30.               
31.             tx.commitAndClose();  
32.         }catch (DaoException e) {  
33.             tx.rollbackAndClose();  
34.         }  
35.     }  
36.       
37.     /** 
38.      * 新增员工 
39.      * @param emp 员工 
40.      */  
41.     public void insertEmp(Employee emp){  
42.         TransactionManager tx = DbUtils.getTranManager();  
43.         try{  
44.             tx.beginTransaction();  
45.               
46.             empDao.insert(emp);  
47.               
48.             tx.commitAndClose();  
49.         }catch (DaoException e) {  
50.             tx.rollbackAndClose();  
51.         }  
52.     }  
53.       
54.     /** 
55.      * 获取所有部门的列表 
56.      * @return 部门列表 
57.      */  
58.     public List<Dept> getDeptList(){  
59.         List<Dept> list = null;  
60.           
61.         TransactionManager tx = DbUtils.getTranManager();  
62.         try{  
63.             tx.beginTransaction();  
64.               
65.             list = deptDao.getDeptList();  
66.               
67.             tx.commitAndClose();  
68.         }catch (DaoException e) {  
69.             e.printStackTrace();  
70.             tx.rollbackAndClose();  
71.         }  
72.           
73.         return list;  
74.     }  
75.       
76.     /** 
77.      * 获取指定部门下的员工分页列表 
78.      * @param deptId 
79.      * @param pageNo 
80.      * @param pageSize 
81.      * @return 符合条件的PageModel 
82.      */  
83.     public PageModel<Employee> getEmpListByDeptId(int deptId, int pageNo, int pageSize){  
84.         PageModel<Employee> pm = null;   
85.         TransactionManager tx = DbUtils.getTranManager();  
86.         try{  
87.             tx.beginTransaction();  
88.               
89.             pm = empDao.getEmpListByDeptId(deptId, pageNo, pageSize);  
90.               
91.             tx.commitAndClose();  
92.         }catch (DaoException e) {  
93.             tx.rollbackAndClose();  
94.         }  
95.         return pm;  
96.     }  
97.       
98.     /** 
99.      * 删除指定ID的部门 
100.      * @param id 部门ID 
101.      */  
102.     public void deleteDept(int id){  
103.           
104.         TransactionManager tx = DbUtils.getTranManager();  
105.         try{  
106.             tx.beginTransaction();  
107.               
108.             empDao.deleteByDeptId(id); //先删除指定ID部门下的所有员工  
109.             deptDao.delete(id);  //再删除该部门  
110.               
111.             tx.commitAndClose();  
112.         }catch (DaoException e) {  
113.             tx.rollbackAndClose();  
114.         }  
115.     }  
116. }  

 

 

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

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

标签：