当前位置：Gxlcms > 数据库问题 > 分层架构下的纯JDBC事务控制简单解决方案【转】

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

时间：2021-07-01 10:21:17 帮助过：3人阅读

  • 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事务控制简单解决方案【转】

    标签：

    人气教程排行

    本站所有资源全部来源于网络，若本站发布的内容侵害到您的隐私或者利益，请联系我们删除！