`

spring JDBC事务管理

阅读更多

 

一直想学习怎么使用spring 的事务,在网上查了很多资料,还是不知道怎么写,大都是基于注解方式的,要么就是基于hibernate的事务,而且没有完整的例子,都是代码片段,这里我自己写了一个简单的demo,供给大家学习

 

1、建立一个对象(跟数据库中的表对应)

 

Java代码  收藏代码
  1. package hb.bean;  
  2.   
  3. public class Book {  
  4.     private int id;  
  5.     private String name;  
  6.     private String author;  
  7.     private int num;  
  8.   
  9.     public int getNum() {  
  10.         return num;  
  11.     }  
  12.   
  13.     public void setNum(int num) {  
  14.         this.num = num;  
  15.     }  
  16.   
  17.     public int getId() {  
  18.         return id;  
  19.     }  
  20.   
  21.     public void setId(int id) {  
  22.         this.id = id;  
  23.     }  
  24.   
  25.     public String getName() {  
  26.         return name;  
  27.     }  
  28.   
  29.     public void setName(String name) {  
  30.         this.name = name;  
  31.     }  
  32.   
  33.     public String getAuthor() {  
  34.         return author;  
  35.     }  
  36.   
  37.     public void setAuthor(String author) {  
  38.         this.author = author;  
  39.     }  
  40. }  

 

 2、建立一个接口(实现对表的相关操作)

 

Java代码  收藏代码
  1. package hb.dao;  
  2.   
  3. import hb.bean.Book;  
  4. import java.util.List;  
  5. import org.springframework.transaction.annotation.Transactional;  
  6.   
  7. @Transactional  
  8. public interface BookDAO {  
  9.       
  10.     //查看book表中的所有数据  
  11.     public List listBook();  
  12.       
  13.     //向book表中插入一条数据  
  14.     public void insertBook(Book book);  
  15. }  

 

 3、实现接口的操作

 

Java代码  收藏代码
  1. package hb.dao.imp;  
  2.   
  3. import hb.bean.Book;  
  4. import hb.dao.BookDAO;  
  5. import hb.row.UserRowMapper;  
  6.   
  7. import java.sql.ResultSet;  
  8. import java.sql.SQLException;  
  9. import java.util.List;  
  10.   
  11. import org.springframework.jdbc.core.JdbcTemplate;  
  12. import org.springframework.jdbc.core.RowMapper;  
  13. import org.springframework.jdbc.core.support.JdbcDaoSupport;  
  14. import org.springframework.jdbc.datasource.DataSourceTransactionManager;  
  15. import org.springframework.transaction.TransactionStatus;  
  16. import org.springframework.transaction.annotation.Transactional;  
  17. import org.springframework.transaction.support.TransactionCallbackWithoutResult;  
  18. import org.springframework.transaction.support.TransactionTemplate;  
  19.   
  20. import sun.jdbc.odbc.ee.DataSource;  
  21.   
  22. @Transactional  
  23. public class BookDAOImpl extends JdbcDaoSupport implements BookDAO {  
  24.       
  25.     public DataSourceTransactionManager transactionManager;  
  26.   
  27.     public void setTransactionManager(DataSourceTransactionManager transactionManager) {  
  28.         this.transactionManager = transactionManager;  
  29.     }  
  30.   
  31.     @SuppressWarnings("unchecked")  
  32.     public List listBook() {  
  33.         String sql = "select * from book";  
  34.         //JdbcDaoSupport里面有jdbcTemplate这个对象的set方法.JdbcTemplate这个类需要配置数据源  
  35.         List list = this.getJdbcTemplate().query(sql, new UserRowMapper());  
  36.         return list;  
  37.     }  
  38.   
  39.     public void insertBook(final Book book) {  
  40.         final String sql = "insert into book(id,name,author,num)values(?,?,?,?)";  
  41.         TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);  
  42.         final JdbcTemplate jdbcTemplate = this.getJdbcTemplate();  
  43.         transactionTemplate.execute(new TransactionCallbackWithoutResult(){  
  44.             @Override  
  45.             protected void doInTransactionWithoutResult(TransactionStatus arg0) {  
  46.                 Object[] params = new Object[] {book.getId(), book.getName(), book.getAuthor(),book.getNum() };  
  47.                 //下面的语句是用来测试事务异常的情况  
  48. //                new Integer("huangbiao");  
  49.                 jdbcTemplate.update(sql, params);  
  50.             }  
  51.         });  
  52.           
  53.     }  
  54.   
  55. }  

 

 4、继承RowMapper 接口接受返回过来的结果集

 

Java代码  收藏代码
  1. package hb.row;  
  2.   
  3. import hb.bean.Book;  
  4.   
  5. import java.sql.ResultSet;  
  6. import java.sql.SQLException;  
  7.   
  8. import org.springframework.jdbc.core.RowMapper;  
  9.   
  10. public class UserRowMapper implements RowMapper {  
  11.   
  12.     public Object mapRow(ResultSet rs,int index) throws SQLException {  
  13.         Book book = new Book();  
  14.         System.out.println(rs.getString("name"));  
  15.         book.setName(rs.getString("name"));  
  16.         return book;  
  17.     }  
  18. }  

 

5、相关的配置信息

 

Xml代码  收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.        xmlns:context="http://www.springframework.org/schema/context"  
  5.        xmlns:tx="http://www.springframework.org/schema/tx"  
  6.        xsi:schemaLocation="http://www.springframework.org/schema/beans  
  7.            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
  8.            http://www.springframework.org/schema/context  
  9.            http://www.springframework.org/schema/context/spring-context2.5.xsd  
  10.            http://www.springframework.org/schema/tx   
  11.            http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">  
  12.           
  13.         <!--  配置数据源   -->  
  14.         <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">  
  15.           <property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/>  
  16.           <property name="url" value="jdbc:oracle:thin:@127.0.0.1:1521:orcl" />  
  17.           <property name="username" value="huangbiao"/>  
  18.           <property name="password" value="huangbiao"/>  
  19.             
  20.           <!-- 连接池启动时的初始值   -->  
  21.           <property name="initialSize" value="1" />  
  22.           <!-- 连接池的最大值  -->  
  23.           <property name="maxActive" value="500"/>  
  24.           <!-- 最大空闲值,当经过一个高峰时间后,连接池可以慢慢将已经用不到的连接释放,一直减少到msxIdle为止  -->  
  25.           <property name="maxIdle" value="2" />  
  26.           <!-- 最小空闲值,当空闲的连接数小于阀值时,连接池就会预申请一些连接,以免洪峰到来时来不及申请  -->  
  27.           <property name="minIdle" value="1" />  
  28.         </bean>  
  29.     
  30.         <!-- 配置事务管理器 -->  
  31.         <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
  32.           <property name="dataSource" ref="dataSource"/>  
  33.         </bean>  
  34.           
  35.         <!-- 采用@Transactional注解方式使用事务   -->  
  36.         <tx:annotation-driven transaction-manager="txManager"/>  
  37.           
  38.         <bean id="bookDao" class="hb.dao.imp.BookDAOImpl" >  
  39.         <!-- 因为继承了JdbcDaoSupport类,该类需要注入 JdbcTemplate类对象 -->  
  40.             <property name="jdbcTemplate" ref="jdbcTemplate"></property>  
  41.             <property name="transactionManager" ref="transactionManager"></property>  
  42.         </bean>  
  43.           
  44.           
  45.         <!-- jdbcTemplate需要配置dataSource,因为里面有一个set方法,所以注入给它 -->  
  46.         <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">  
  47.             <property name="dataSource" ref="dataSource"></property>  
  48.         </bean>  
  49.           
  50.         <!-- 事务处理类,该类用于管理事务,里面有set方法注入数据源 -->  
  51.         <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
  52.             <property name="dataSource" ref="dataSource" />  
  53.         </bean>  
  54.           
  55. </beans>   

 

6、写一个测试类(使用JUnint)

 

Java代码  收藏代码
  1. package hb.test;  
  2.   
  3. import hb.bean.Book;  
  4. import hb.dao.BookDAO;  
  5.   
  6. import java.util.Iterator;  
  7. import java.util.List;  
  8.   
  9.   
  10. import org.junit.BeforeClass;  
  11. import org.junit.Test;  
  12. import org.springframework.context.ApplicationContext;  
  13. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  14. import org.springframework.context.support.FileSystemXmlApplicationContext;  
  15. import org.springframework.jdbc.core.JdbcTemplate;  
  16.   
  17. public class SpringTest {  
  18.   
  19.     private BookDAO bookDao;  
  20.       
  21.     @BeforeClass  
  22.     public static void setUpBeforeClass() throws Exception {  
  23.           
  24.     }  
  25.       
  26.     @SuppressWarnings("unchecked")  
  27.     @Test  
  28.     //执行查询的方式  
  29.     public void doQueryTest(){  
  30.         try{  
  31.             ApplicationContext ctx = new FileSystemXmlApplicationContext("applicationContext.xml");  
  32.             bookDao = (BookDAO) ctx.getBean("bookDao");  
  33.             List list = bookDao.listBook();  
  34.             Iterator iter = list.iterator();  
  35.             while(iter.hasNext()){  
  36.                 Book book = (Book)iter.next();  
  37.                 System.out.println(book.getName());  
  38.             }  
  39.         }  
  40.         catch (Exception e) {  
  41.             e.printStackTrace();  
  42.         }  
  43.     }     
  44.       
  45.     @Test  
  46.     public void doInsertTest(){  
  47.         Book book = new Book();  
  48.         book.setAuthor("huangbiao");  
  49.         book.setId(90);  
  50.         book.setName("hb");  
  51.         book.setNum(44);  
  52.         try{  
  53.             ApplicationContext ctx = new FileSystemXmlApplicationContext("applicationContext.xml");  
  54.             bookDao = (BookDAO) ctx.getBean("bookDao");  
  55.             bookDao.insertBook(book);  
  56.         }  
  57.         catch (Exception e) {  
  58.             e.printStackTrace();  
  59.         }  
  60.           
  61.     }  
  62. }  
分享到:
评论

相关推荐

Global site tag (gtag.js) - Google Analytics