`

Spring JdbcTemplate 与 事务管理 学习

 
阅读更多

Spring的JDBC框架能够承担资源管理和异常处理的工作,从而简化我们的JDBC代码,
让我们只需编写从数据库读写数据所必需的代码。Spring把数据访问的样板代码隐藏到模板类之下,
结合Spring的事务管理,可以大大简化我们的代码.

Spring提供了3个模板类：

JdbcTemplate：Spring里最基本的JDBC模板，利用JDBC和简单的索引参数查询提供对数据库的简单访问。
NamedParameterJdbcTemplate：能够在执行查询时把值绑定到SQL里的命名参数，而不是使用索引参数。
SimpleJdbcTemplate：利用Java 5的特性，比如自动装箱、通用（generic）和可变参数列表来简化JDBC模板的使用。
具体使用哪个模板基本上取决于个人喜好。


使用Spring的JdbcTemplate来实现简单的增删改查,首先建立测试数据表person
create table person(
id int not null primary key auto_increment,
name varchar(20) not null
)

导入依赖的jar包,由于测试中数据源使用的是dbcp数据源,需要以下jar包支持:
commons-logging.jar
commons-pool.jar
commons-dbcp.jar
同时还必须导入数据库驱动jar包:mysql-connector-java-3.1.8-bin.jar

建立实体bean
Person.java

Java代码 复制代码 收藏代码
  1. package com.royzhou.jdbc;
  3. public class PersonBean {
  4. private int id;
  5. private String name;
  7. public PersonBean() {
  8. }
  10. public PersonBean(String name) {
  11. this.name = name;
  12. }
  14. public PersonBean(int id, String name) {
  15. this.id = id;
  16. this.name = name;
  17. }
  19. public int getId() {
  20. return id;
  21. }
  23. public void setId(int id) {
  24. this.id = id;
  25. }
  27. public String getName() {
  28. return name;
  29. }
  31. public void setName(String name) {
  32. this.name = name;
  33. }
  35. public String toString() {
  36. return this.id + ":" + this.name;
  37. }
  38. } 
package com.royzhou.jdbc;

public class PersonBean {
	private int id;
	private String name;

	public PersonBean() {
	}
	
	public PersonBean(String name) {
		this.name = name;
	}
	
	public PersonBean(int id, String name) {
		this.id = id;
		this.name = name;
	}
	 
	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	public String toString() {
		return this.id + ":" + this.name;
	}
}



接口类:
PersonService.java

Java代码 复制代码 收藏代码
  1. package com.royzhou.jdbc;
  3. import java.util.List;
  5. public interface PersonService {
  7. public void addPerson(PersonBean person);
  9. public void updatePerson(PersonBean person);
  11. public void deletePerson(int id);
  13. public PersonBean queryPerson(int id);
  15. public List<PersonBean> queryPersons();
  16. } 
package com.royzhou.jdbc;

import java.util.List;

public interface PersonService {
	
	public void addPerson(PersonBean person);
	
	public void updatePerson(PersonBean person);
	
	public void deletePerson(int id);
	
	public PersonBean queryPerson(int id);
	
	public List<PersonBean> queryPersons();
}



实现类:
PersonServiceImpl.java

Java代码 复制代码 收藏代码
  1. package com.royzhou.jdbc;
  3. import java.util.List;
  5. import javax.sql.DataSource;
  6. import java.sql.Types;
  8. import org.springframework.jdbc.core.JdbcTemplate;
  10. public class PersonServiceImpl implements PersonService {
  12. private JdbcTemplate jdbcTemplate;
  14. /**
  15. * 通过Spring容器注入datasource
  16. * 实例化JdbcTemplate,该类为主要操作数据库的类
  17. * @param ds
  18. */
  19. public void setDataSource(DataSource ds) {
  20. this.jdbcTemplate = new JdbcTemplate(ds);
  21. }
  23. public void addPerson(PersonBean person) {
  24. /**
  25. * 第一个参数为执行sql
  26. * 第二个参数为参数数据
  27. * 第三个参数为参数类型
  28. */
  29. jdbcTemplate.update("insert into person values(null,?)", new Object[]{person.getName()}, new int[]{Types.VARCHAR});
  30. }
  32. public void deletePerson(int id) {
  33. jdbcTemplate.update("delete from person where id = ?", new Object[]{id}, new int[]{Types.INTEGER});
  34. }
  36. public PersonBean queryPerson(int id) {
  37. /**
  38. * new PersonRowMapper()是一个实现RowMapper接口的类,
  39. * 执行回调,实现mapRow()方法将rs对象转换成PersonBean对象返回
  40. */
  41. PersonBean pb = (PersonBean) jdbcTemplate.queryForObject("select id,name from person where id = ?", new Object[]{id}, new PersonRowMapper());
  42. return pb;
  43. }
  45. @SuppressWarnings("unchecked")
  46. public List<PersonBean> queryPersons() {
  47. List<PersonBean> pbs = (List<PersonBean>) jdbcTemplate.query("select id,name from person", new PersonRowMapper());
  48. return pbs;
  49. }
  51. public void updatePerson(PersonBean person) {
  52. jdbcTemplate.update("update person set name = ? where id = ?", new Object[]{person.getName(), person.getId()}, new int[]{Types.VARCHAR, Types.INTEGER});
  53. }
  54. } 
package com.royzhou.jdbc;

import java.util.List;

import javax.sql.DataSource;
import java.sql.Types;

import org.springframework.jdbc.core.JdbcTemplate;

public class PersonServiceImpl implements PersonService {

	private JdbcTemplate jdbcTemplate;
	
	/**
	 * 通过Spring容器注入datasource
	 * 实例化JdbcTemplate,该类为主要操作数据库的类
	 * @param ds
	 */
	public void setDataSource(DataSource ds) {
		this.jdbcTemplate = new JdbcTemplate(ds);
	}
	
	public void addPerson(PersonBean person) {
		/**
		 * 第一个参数为执行sql
		 * 第二个参数为参数数据
		 * 第三个参数为参数类型
		 */
		jdbcTemplate.update("insert into person values(null,?)", new Object[]{person.getName()}, new int[]{Types.VARCHAR});
	}

	public void deletePerson(int id) {
		jdbcTemplate.update("delete from person where id = ?", new Object[]{id}, new int[]{Types.INTEGER});
	}

	public PersonBean queryPerson(int id) {
		/**
		 * new PersonRowMapper()是一个实现RowMapper接口的类,
		 * 执行回调,实现mapRow()方法将rs对象转换成PersonBean对象返回
		 */
		PersonBean pb = (PersonBean) jdbcTemplate.queryForObject("select id,name from person where id = ?", new Object[]{id}, new PersonRowMapper());
		return pb;
	}

	@SuppressWarnings("unchecked")
	public List<PersonBean> queryPersons() {
		List<PersonBean> pbs = (List<PersonBean>) jdbcTemplate.query("select id,name from person", new PersonRowMapper());
		return pbs;
	}

	public void updatePerson(PersonBean person) {
		jdbcTemplate.update("update person set name = ? where id = ?", new Object[]{person.getName(), person.getId()}, new int[]{Types.VARCHAR, Types.INTEGER});
	}
}



PersonRowMapper.java

Java代码 复制代码 收藏代码
  1. package com.royzhou.jdbc;
  3. import java.sql.ResultSet;
  4. import java.sql.SQLException;
  6. import org.springframework.jdbc.core.RowMapper;
  8. public class PersonRowMapper implements RowMapper {
  9. //默认已经执行rs.next(),可以直接取数据
  10. public Object mapRow(ResultSet rs, int index) throws SQLException {
  11. PersonBean pb = new PersonBean(rs.getInt("id"),rs.getString("name"));
  12. return pb;
  13. }
  14. } 
package com.royzhou.jdbc;

import java.sql.ResultSet;
import java.sql.SQLException;

import org.springframework.jdbc.core.RowMapper;

public class PersonRowMapper implements RowMapper {
	//默认已经执行rs.next(),可以直接取数据
	public Object mapRow(ResultSet rs, int index) throws SQLException {
		PersonBean pb = new PersonBean(rs.getInt("id"),rs.getString("name"));
		return pb;
	}
}



我们需要在bean.xml中配置DataSource,并且将datasource注入到我们的业务类中

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:aop="http://www.springframework.org/schema/aop"
  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 http://www.springframework.org/schema/context/spring-context-2.5.xsd
  9. http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
  11. <context:property-placeholder location="classpath:jdbc.properties"/>
  12. <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
  13. <property name="driverClassName" value="${driverClassName}"/>
  14. <property name="url" value="${url}"/>
  15. <property name="username" value="${username}"/>
  16. <property name="password" value="${password}"/>
  17. <!-- 连接池启动时的初始值 -->
  18. <property name="initialSize" value="${initialSize}"/>
  19. <!-- 连接池的最大值 -->
  20. <property name="maxActive" value="${maxActive}"/>
  21. <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->
  22. <property name="maxIdle" value="${maxIdle}"/>
  23. <!-- 最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->
  24. <property name="minIdle" value="${minIdle}"/>
  25. </bean>
  27. </beans> 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context" 
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

	 <context:property-placeholder location="classpath:jdbc.properties"/>
	 <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
	    <property name="driverClassName" value="${driverClassName}"/>
	    <property name="url" value="${url}"/>
	    <property name="username" value="${username}"/>
	    <property name="password" value="${password}"/>
	     <!-- 连接池启动时的初始值 -->
		 <property name="initialSize" value="${initialSize}"/>
		 <!-- 连接池的最大值 -->
		 <property name="maxActive" value="${maxActive}"/>
		 <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->
		 <property name="maxIdle" value="${maxIdle}"/>
		 <!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->
		 <property name="minIdle" value="${minIdle}"/>
	 </bean>
	
</beans>



jdbc.properties

Java代码 复制代码 收藏代码
  1. driverClassName=org.gjt.mm.mysql.Driver
  2. url=jdbc:mysql://localhost:3306/royzhou?useUnicode=true&characterEncoding=UTF-8
  3. username=root
  4. password=123456
  5. initialSize=1
  6. maxActive=500
  7. maxIdle=2
  8. minIdle=1 
driverClassName=org.gjt.mm.mysql.Driver
url=jdbc:mysql://localhost:3306/royzhou?useUnicode=true&characterEncoding=UTF-8
username=root
password=123456
initialSize=1
maxActive=500
maxIdle=2
minIdle=1



编写我们的测试类:TestJdbcTemplate.java

Java代码 复制代码 收藏代码
  1. package com.royzhou.jdbc;
  3. import org.springframework.context.ApplicationContext;
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;
  6. public class TestJdbcTemplate {
  7. public static void main(String[] args) {
  8. ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml");
  9. PersonService ps = (PersonService)ctx.getBean("personService");
  10. ps.addPerson(new PersonBean("royzhou"));
  11. PersonBean pb = ps.queryPerson(1);
  12. System.out.println(pb);
  13. pb.setName("haha");
  14. ps.updatePerson(pb);
  15. pb = ps.queryPerson(1);
  16. System.out.println(pb);
  17. ps.deletePerson(1);
  18. pb = ps.queryPerson(1);
  19. System.out.println(pb);
  20. }
  21. } 
package com.royzhou.jdbc;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestJdbcTemplate {
	public static void main(String[] args) {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml");
		PersonService ps = (PersonService)ctx.getBean("personService");
		ps.addPerson(new PersonBean("royzhou"));
		PersonBean pb = ps.queryPerson(1);
		System.out.println(pb);
		pb.setName("haha");
		ps.updatePerson(pb);
		pb = ps.queryPerson(1);
		System.out.println(pb);
		ps.deletePerson(1);
		pb = ps.queryPerson(1);
		System.out.println(pb);
	}
}



上面代码先插入一条记录,然后修改,之后删除,运行之后出现异常,异常信息:
EmptyResultDataAccessException: Incorrect result size: expected 1, actual 0

难道Spring的queryForObject在查找不到记录的时候会抛出异常,看了一下Spring的源代码 发现确实如此:

Java代码 复制代码 收藏代码
  1. public Object queryForObject(String sql, Object[] args, int[] argTypes, RowMapper rowMapper) throws DataAccessException {
  2. List results = (List) query(sql, args, argTypes, new RowMapperResultSetExtractor(rowMapper, 1));
  3. return DataAccessUtils.requiredUniqueResult(results);
  4. }
  6. public Object queryForObject(String sql, Object[] args, RowMapper rowMapper) throws DataAccessException {
  7. List results = (List) query(sql, args, new RowMapperResultSetExtractor(rowMapper, 1));
  8. return DataAccessUtils.requiredUniqueResult(results);
  9. }
  11. public Object queryForObject(String sql, RowMapper rowMapper) throws DataAccessException {
  12. List results = query(sql, rowMapper);
  13. return DataAccessUtils.requiredUniqueResult(results);
  14. }
  16. public static Object requiredUniqueResult(Collection results) throws IncorrectResultSizeDataAccessException {
  17. int size = (results != null ? results.size() : 0);
  18. if (size == 0) {
  19. throw new EmptyResultDataAccessException(1); // 问题在这里
  20. }
  21. if (!CollectionUtils.hasUniqueObject(results)) {
  22. throw new IncorrectResultSizeDataAccessException(1, size);
  23. }
  24. return results.iterator().next();
  25. } 
public Object queryForObject(String sql, Object[] args, int[] argTypes, RowMapper rowMapper) throws DataAccessException {
		List results = (List) query(sql, args, argTypes, new RowMapperResultSetExtractor(rowMapper, 1));
		return DataAccessUtils.requiredUniqueResult(results);
	}

	public Object queryForObject(String sql, Object[] args, RowMapper rowMapper) throws DataAccessException {
		List results = (List) query(sql, args, new RowMapperResultSetExtractor(rowMapper, 1));
		return DataAccessUtils.requiredUniqueResult(results);
	}

	public Object queryForObject(String sql, RowMapper rowMapper) throws DataAccessException {
		List results = query(sql, rowMapper);
		return DataAccessUtils.requiredUniqueResult(results);
	}

	public static Object requiredUniqueResult(Collection results) throws IncorrectResultSizeDataAccessException {
		int size = (results != null ? results.size() : 0);
		if (size == 0) {
			throw new EmptyResultDataAccessException(1); // 问题在这里
		}
		if (!CollectionUtils.hasUniqueObject(results)) {
		    throw new IncorrectResultSizeDataAccessException(1, size);
		}
		return results.iterator().next();
	}



发现当查找不到记录是,requiredUniqueResult方法做了判断,抛出异常, 想不明白为什么Spring要在这里做这样的判断,为啥不返回null????

重新修改PersonServiceImple类,把queryPerson方法改为使用列表查询的方式再去根据index取
PersonServiceImpl.java

Java代码 复制代码 收藏代码
  1. package com.royzhou.jdbc;
  3. import java.util.List;
  5. import javax.sql.DataSource;
  6. import java.sql.Types;
  8. import org.springframework.jdbc.core.JdbcTemplate;
  10. public class PersonServiceImpl implements PersonService {
  12. private JdbcTemplate jdbcTemplate;
  14. /**
  15. * 通过Spring容器注入datasource
  16. * 实例化JdbcTemplate,该类为主要操作数据库的类
  17. * @param ds
  18. */
  19. public void setDataSource(DataSource ds) {
  20. this.jdbcTemplate = new JdbcTemplate(ds);
  21. }
  23. public void addPerson(PersonBean person) {
  24. /**
  25. * 第一个参数为执行sql
  26. * 第二个参数为参数数据
  27. * 第三个参数为参数类型
  28. */
  29. jdbcTemplate.update("insert into person values(null,?)", new Object[]{person.getName()}, new int[]{Types.VARCHAR});
  30. }
  32. public void deletePerson(int id) {
  33. jdbcTemplate.update("delete from person where id = ?", new Object[]{id}, new int[]{Types.INTEGER});
  34. }
  36. @SuppressWarnings("unchecked")
  37. public PersonBean queryPerson(int id) {
  38. /**
  39. * new PersonRowMapper()是一个实现RowMapper接口的类,
  40. * 执行回调,实现mapRow()方法将rs对象转换成PersonBean对象返回
  41. */
  42. List<PersonBean> pbs = (List<PersonBean>)jdbcTemplate.query("select id,name from person where id = ?", new Object[]{id}, new PersonRowMapper());
  43. PersonBean pb = null;
  44. if(pbs.size()>0) {
  45. pb = pbs.get(0);
  46. }
  47. return pb;
  48. }
  50. @SuppressWarnings("unchecked")
  51. public List<PersonBean> queryPersons() {
  52. List<PersonBean> pbs = (List<PersonBean>) jdbcTemplate.query("select id,name from person", new PersonRowMapper());
  53. return pbs;
  54. }
  56. public void updatePerson(PersonBean person) {
  57. jdbcTemplate.update("update person set name = ? where id = ?", new Object[]{person.getName(), person.getId()}, new int[]{Types.VARCHAR, Types.INTEGER});
  58. }
  59. } 
package com.royzhou.jdbc;

import java.util.List;

import javax.sql.DataSource;
import java.sql.Types;

import org.springframework.jdbc.core.JdbcTemplate;

public class PersonServiceImpl implements PersonService {

	private JdbcTemplate jdbcTemplate;
	
	/**
	 * 通过Spring容器注入datasource
	 * 实例化JdbcTemplate,该类为主要操作数据库的类
	 * @param ds
	 */
	public void setDataSource(DataSource ds) {
		this.jdbcTemplate = new JdbcTemplate(ds);
	}
	
	public void addPerson(PersonBean person) {
		/**
		 * 第一个参数为执行sql
		 * 第二个参数为参数数据
		 * 第三个参数为参数类型
		 */
		jdbcTemplate.update("insert into person values(null,?)", new Object[]{person.getName()}, new int[]{Types.VARCHAR});
	}

	public void deletePerson(int id) {
		jdbcTemplate.update("delete from person where id = ?", new Object[]{id}, new int[]{Types.INTEGER});
	}

	@SuppressWarnings("unchecked")
	public PersonBean queryPerson(int id) {
		/**
		 * new PersonRowMapper()是一个实现RowMapper接口的类,
		 * 执行回调,实现mapRow()方法将rs对象转换成PersonBean对象返回
		 */
		List<PersonBean> pbs = (List<PersonBean>)jdbcTemplate.query("select id,name from person where id = ?", new Object[]{id}, new PersonRowMapper());
		PersonBean pb = null;
		if(pbs.size()>0) {
			pb = pbs.get(0);
		}
		return pb;
	}

	@SuppressWarnings("unchecked")
	public List<PersonBean> queryPersons() {
		List<PersonBean> pbs = (List<PersonBean>) jdbcTemplate.query("select id,name from person", new PersonRowMapper());
		return pbs;
	}

	public void updatePerson(PersonBean person) {
		jdbcTemplate.update("update person set name = ? where id = ?", new Object[]{person.getName(), person.getId()}, new int[]{Types.VARCHAR, Types.INTEGER});
	}
}



再次运行测试类,输出:
1:royzhou
1:haha
null

得到预期的结果.

从上面代码可以看出,使用Spring提供的JDBCTemplate类很大程度减少了我们的代码量,
比起以前我们写JDBC操作,需要先获取Connection,然后是PreparedStatement,再到Result,
使用Spring JDBCTemplate写出来的代码看起来更加简洁,开发效率也比较快.

在数据库的操作中,事务是一个重要的概念,举个例子:

大概每个人都有转账的经历。当我们从A帐户向B帐户转100元后，银行的系统会从A帐户上扣除100而在B帐户上加100，这是一般的正常现象。
但是一旦系统出错了怎么办呢，这里我们假设可能会发生两种情况：
（1）A帐户上少了100元，但是B帐户却没有多100元。
（2）B帐户多了100元钱，但是A帐户上却没有被扣钱。
这种错误一旦发生就等于出了大事，那么再假如一下，你要转账的是1亿呢？
所以上面的两种情况分别是你和银行不愿意看到的，因为谁都不希望出错。那么有没有什么方法保证一旦A帐户上没有被扣钱而B帐户上也没有被加钱；
或者A帐户扣了100元而B帐户准确无误的加上100元呢。也就是说要么转账顺利的成功进行，要么不转账呢？可以，这就是数据库事务机制所要起到的作用和做的事情。

Spring对事务的管理有丰富的支持,Spring提供了编程式配置事务和声明式配置事务:

声明式事务有以下两种方式
一种是使用Annotation注解的方式(官方推荐)
一种是基于Xml的方式

采用任何一种方式我们都需要在我们的bean.xml中添加事务支持:

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:aop="http://www.springframework.org/schema/aop"
  6. xmlns:tx="http://www.springframework.org/schema/tx"
  7. xsi:schemaLocation="http://www.springframework.org/schema/beans
  8. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
  9. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
  10. http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
  11. http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
  13. <context:property-placeholder location="classpath:jdbc.properties" />
  14. <bean id="dataSource"
  15. class="org.apache.commons.dbcp.BasicDataSource"
  16. destroy-method="close">
  17. <property name="driverClassName" value="${driverClassName}" />
  18. <property name="url" value="${url}" />
  19. <property name="username" value="${username}" />
  20. <property name="password" value="${password}" />
  21. <!-- 连接池启动时的初始值 -->
  22. <property name="initialSize" value="${initialSize}" />
  23. <!-- 连接池的最大值 -->
  24. <property name="maxActive" value="${maxActive}" />
  25. <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->
  26. <property name="maxIdle" value="${maxIdle}" />
  27. <!-- 最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->
  28. <property name="minIdle" value="${minIdle}" />
  29. </bean>
  31. <bean id="personService"
  32. class="com.royzhou.jdbc.PersonServiceImpl">
  33. <property name="dataSource" ref="dataSource"></property>
  34. </bean>
  36. <bean id="txManager"
  37. class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  38. <property name="dataSource" ref="dataSource" />
  39. </bean>
  41. <tx:annotation-driven transaction-manager="txManager" />
  42. </beans> 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

	<context:property-placeholder location="classpath:jdbc.properties" />
	<bean id="dataSource"
		class="org.apache.commons.dbcp.BasicDataSource"
		destroy-method="close">
		<property name="driverClassName" value="${driverClassName}" />
		<property name="url" value="${url}" />
		<property name="username" value="${username}" />
		<property name="password" value="${password}" />
		<!-- 连接池启动时的初始值 -->
		<property name="initialSize" value="${initialSize}" />
		<!-- 连接池的最大值 -->
		<property name="maxActive" value="${maxActive}" />
		<!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->
		<property name="maxIdle" value="${maxIdle}" />
		<!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->
		<property name="minIdle" value="${minIdle}" />
	</bean>

	<bean id="personService"
		class="com.royzhou.jdbc.PersonServiceImpl">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
	<bean id="txManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>
	
	<tx:annotation-driven transaction-manager="txManager" /> 
</beans>



<tx:annotation-driven transaction-manager="txManager" /> 这句话的作用是注册事务注解处理器
定义好配置文件后我们只需要在我们的类上加上注解@Transactional,就可以指定这个类需要受Spring的事务管理
默认Spring为每个方法开启一个事务,如果方法发生运行期错误unchecked(RuntimeException),事务会进行回滚
如果发生checked Exception,事务不进行回滚.

例如在下面的例子中,我们为PersonServiceImpl添加事务支持.

Java代码 复制代码 收藏代码
  1. package com.royzhou.jdbc;
  3. import java.util.List;
  5. import javax.sql.DataSource;
  6. import java.sql.Types;
  8. import org.springframework.jdbc.core.JdbcTemplate;
  9. import org.springframework.transaction.annotation.Transactional;
  11. @Transactional
  12. public class PersonServiceImpl implements PersonService {
  14. private JdbcTemplate jdbcTemplate;
  16. /**
  17. * 通过Spring容器注入datasource
  18. * 实例化JdbcTemplate,该类为主要操作数据库的类
  19. * @param ds
  20. */
  21. public void setDataSource(DataSource ds) {
  22. this.jdbcTemplate = new JdbcTemplate(ds);
  23. }
  25. public void addPerson(PersonBean person) {
  26. /**
  27. * 第一个参数为执行sql
  28. * 第二个参数为参数数据
  29. * 第三个参数为参数类型
  30. */
  31. jdbcTemplate.update("insert into person values(null,?)", new Object[]{person.getName()}, new int[]{Types.VARCHAR});
  32. throw new RuntimeException("运行期例外");
  33. }
  35. public void deletePerson(int id) {
  36. jdbcTemplate.update("delete from person where id = ?", new Object[]{id}, new int[]{Types.INTEGER});
  37. }
  39. @SuppressWarnings("unchecked")
  40. public PersonBean queryPerson(int id) {
  41. /**
  42. * new PersonRowMapper()是一个实现RowMapper接口的类,
  43. * 执行回调,实现mapRow()方法将rs对象转换成PersonBean对象返回
  44. */
  45. List<PersonBean> pbs = (List<PersonBean>)jdbcTemplate.query("select id,name from person where id = ?", new Object[]{id}, new PersonRowMapper());
  46. PersonBean pb = null;
  47. if(pbs.size()>0) {
  48. pb = pbs.get(0);
  49. }
  50. return pb;
  51. }
  53. @SuppressWarnings("unchecked")
  54. public List<PersonBean> queryPersons() {
  55. List<PersonBean> pbs = (List<PersonBean>) jdbcTemplate.query("select id,name from person", new PersonRowMapper());
  56. return pbs;
  57. }
  59. public void updatePerson(PersonBean person) {
  60. jdbcTemplate.update("update person set name = ? where id = ?", new Object[]{person.getName(), person.getId()}, new int[]{Types.VARCHAR, Types.INTEGER});
  61. }
  62. } 
package com.royzhou.jdbc;

import java.util.List;

import javax.sql.DataSource;
import java.sql.Types;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.transaction.annotation.Transactional;

@Transactional
public class PersonServiceImpl implements PersonService {

	private JdbcTemplate jdbcTemplate;
	
	/**
	 * 通过Spring容器注入datasource
	 * 实例化JdbcTemplate,该类为主要操作数据库的类
	 * @param ds
	 */
	public void setDataSource(DataSource ds) {
		this.jdbcTemplate = new JdbcTemplate(ds);
	}
	
	public void addPerson(PersonBean person) {
		/**
		 * 第一个参数为执行sql
		 * 第二个参数为参数数据
		 * 第三个参数为参数类型
		 */
		jdbcTemplate.update("insert into person values(null,?)", new Object[]{person.getName()}, new int[]{Types.VARCHAR});
		throw new RuntimeException("运行期例外");
	}

	public void deletePerson(int id) {
		jdbcTemplate.update("delete from person where id = ?", new Object[]{id}, new int[]{Types.INTEGER});
	}

	@SuppressWarnings("unchecked")
	public PersonBean queryPerson(int id) {
		/**
		 * new PersonRowMapper()是一个实现RowMapper接口的类,
		 * 执行回调,实现mapRow()方法将rs对象转换成PersonBean对象返回
		 */
		List<PersonBean> pbs = (List<PersonBean>)jdbcTemplate.query("select id,name from person where id = ?", new Object[]{id}, new PersonRowMapper());
		PersonBean pb = null;
		if(pbs.size()>0) {
			pb = pbs.get(0);
		}
		return pb;
	}

	@SuppressWarnings("unchecked")
	public List<PersonBean> queryPersons() {
		List<PersonBean> pbs = (List<PersonBean>) jdbcTemplate.query("select id,name from person", new PersonRowMapper());
		return pbs;
	}

	public void updatePerson(PersonBean person) {
		jdbcTemplate.update("update person set name = ? where id = ?", new Object[]{person.getName(), person.getId()}, new int[]{Types.VARCHAR, Types.INTEGER});
	}
}



在addPerson方法中我们抛出了一个运行期例外,以此来检查Spring的事务管理.

编写测试类运行:

Java代码 复制代码 收藏代码
  1. package com.royzhou.jdbc;
  3. import org.springframework.context.ApplicationContext;
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;
  6. public class TestJdbcTemplate {
  7. public static void main(String[] args) {
  8. ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml");
  9. PersonService ps = (PersonService)ctx.getBean("personService");
  10. ps.addPerson(new PersonBean("royzhou"));
  11. }
  12. } 
package com.royzhou.jdbc;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestJdbcTemplate {
	public static void main(String[] args) {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml");
		PersonService ps = (PersonService)ctx.getBean("personService");
		ps.addPerson(new PersonBean("royzhou"));
	}
}


运行测试类,后台输出异常:java.lang.RuntimeException: 运行期例外
查看数据库发现数据没有插入,说明事务进行了回滚.

再次测试修改为抛出checked Exception

Java代码 复制代码 收藏代码
  1. package com.royzhou.jdbc;
  3. import java.util.List;
  5. import javax.sql.DataSource;
  6. import java.sql.Types;
  8. import org.springframework.jdbc.core.JdbcTemplate;
  9. import org.springframework.transaction.annotation.Transactional;
  11. @Transactional
  12. public class PersonServiceImpl implements PersonService {
  14. private JdbcTemplate jdbcTemplate;
  16. /**
  17. * 通过Spring容器注入datasource
  18. * 实例化JdbcTemplate,该类为主要操作数据库的类
  19. * @param ds
  20. */
  21. public void setDataSource(DataSource ds) {
  22. this.jdbcTemplate = new JdbcTemplate(ds);
  23. }
  25. public void addPerson(PersonBean person) throws Exception {
  26. /**
  27. * 第一个参数为执行sql
  28. * 第二个参数为参数数据
  29. * 第三个参数为参数类型
  30. */
  31. jdbcTemplate.update("insert into person values(null,?)", new Object[]{person.getName()}, new int[]{Types.VARCHAR});
  32. throw new Exception("checked 例外");
  33. }
  35. public void deletePerson(int id) {
  36. jdbcTemplate.update("delete from person where id = ?", new Object[]{id}, new int[]{Types.INTEGER});
  37. }
  39. @SuppressWarnings("unchecked")
  40. public PersonBean queryPerson(int id) {
  41. /**
  42. * new PersonRowMapper()是一个实现RowMapper接口的类,
  43. * 执行回调,实现mapRow()方法将rs对象转换成PersonBean对象返回
  44. */
  45. List<PersonBean> pbs = (List<PersonBean>)jdbcTemplate.query("select id,name from person where id = ?", new Object[]{id}, new PersonRowMapper());
  46. PersonBean pb = null;
  47. if(pbs.size()>0) {
  48. pb = pbs.get(0);
  49. }
  50. return pb;
  51. }
  53. @SuppressWarnings("unchecked")
  54. public List<PersonBean> queryPersons() {
  55. List<PersonBean> pbs = (List<PersonBean>) jdbcTemplate.query("select id,name from person", new PersonRowMapper());
  56. return pbs;
  57. }
  59. public void updatePerson(PersonBean person) {
  60. jdbcTemplate.update("update person set name = ? where id = ?", new Object[]{person.getName(), person.getId()}, new int[]{Types.VARCHAR, Types.INTEGER});
  61. }
  62. } 
package com.royzhou.jdbc;

import java.util.List;

import javax.sql.DataSource;
import java.sql.Types;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.transaction.annotation.Transactional;

@Transactional
public class PersonServiceImpl implements PersonService {

	private JdbcTemplate jdbcTemplate;
	
	/**
	 * 通过Spring容器注入datasource
	 * 实例化JdbcTemplate,该类为主要操作数据库的类
	 * @param ds
	 */
	public void setDataSource(DataSource ds) {
		this.jdbcTemplate = new JdbcTemplate(ds);
	}
	
	public void addPerson(PersonBean person) throws Exception {
		/**
		 * 第一个参数为执行sql
		 * 第二个参数为参数数据
		 * 第三个参数为参数类型
		 */
		jdbcTemplate.update("insert into person values(null,?)", new Object[]{person.getName()}, new int[]{Types.VARCHAR});
		throw new Exception("checked 例外");
	}

	public void deletePerson(int id) {
		jdbcTemplate.update("delete from person where id = ?", new Object[]{id}, new int[]{Types.INTEGER});
	}

	@SuppressWarnings("unchecked")
	public PersonBean queryPerson(int id) {
		/**
		 * new PersonRowMapper()是一个实现RowMapper接口的类,
		 * 执行回调,实现mapRow()方法将rs对象转换成PersonBean对象返回
		 */
		List<PersonBean> pbs = (List<PersonBean>)jdbcTemplate.query("select id,name from person where id = ?", new Object[]{id}, new PersonRowMapper());
		PersonBean pb = null;
		if(pbs.size()>0) {
			pb = pbs.get(0);
		}
		return pb;
	}

	@SuppressWarnings("unchecked")
	public List<PersonBean> queryPersons() {
		List<PersonBean> pbs = (List<PersonBean>) jdbcTemplate.query("select id,name from person", new PersonRowMapper());
		return pbs;
	}

	public void updatePerson(PersonBean person) {
		jdbcTemplate.update("update person set name = ? where id = ?", new Object[]{person.getName(), person.getId()}, new int[]{Types.VARCHAR, Types.INTEGER});
	}
}


后台输出异常:java.lang.Exception: checked 例外
查看数据库发现数据插入,说明事务没有进行了回滚.

说明了Spring的事务支持默认只对运行期异常(RuntimeException)进行回滚,这里可能有个疑问,我们执行sql操作的时候会发生sql异常,不属于运行期异常,那Spring是怎么进行事务回滚的呢 ????
查看了一下JdbcTemplate的源代码发现,JdbcTemplate的处理方法如下:

Java代码 复制代码 收藏代码
  1. public int[] batchUpdate(String sql, final BatchPreparedStatementSetter pss) throws DataAccessException {
  2. if (logger.isDebugEnabled()) {
  3. logger.debug("Executing SQL batch update [" + sql + "]");
  4. }
  5. return (int[]) execute(sql, new PreparedStatementCallback() {
  6. public Object doInPreparedStatement(PreparedStatement ps) throws SQLException {
  7. try {
  8. int batchSize = pss.getBatchSize();
  9. if (JdbcUtils.supportsBatchUpdates(ps.getConnection())) {
  10. for (int i = 0; i < batchSize; i++) {
  11. pss.setValues(ps, i);
  12. ps.addBatch();
  13. }
  14. return ps.executeBatch();
  15. }
  16. else {
  17. int[] rowsAffected = new int[batchSize];
  18. for (int i = 0; i < batchSize; i++) {
  19. pss.setValues(ps, i);
  20. rowsAffected[i] = ps.executeUpdate();
  21. }
  22. return rowsAffected;
  23. }
  24. }
  25. finally {
  26. if (pss instanceof ParameterDisposer) {
  27. ((ParameterDisposer) pss).cleanupParameters();
  28. }
  29. }
  30. }
  31. });
  32. } 
	public int[] batchUpdate(String sql, final BatchPreparedStatementSetter pss) throws DataAccessException {
		if (logger.isDebugEnabled()) {
			logger.debug("Executing SQL batch update [" + sql + "]");
		}
		return (int[]) execute(sql, new PreparedStatementCallback() {
			public Object doInPreparedStatement(PreparedStatement ps) throws SQLException {
				try {
					int batchSize = pss.getBatchSize();
					if (JdbcUtils.supportsBatchUpdates(ps.getConnection())) {
						for (int i = 0; i < batchSize; i++) {
							pss.setValues(ps, i);
							ps.addBatch();
						}
						return ps.executeBatch();
					}
					else {
						int[] rowsAffected = new int[batchSize];
						for (int i = 0; i < batchSize; i++) {
							pss.setValues(ps, i);
							rowsAffected[i] = ps.executeUpdate();
						}
						return rowsAffected;
					}
				}
				finally {
					if (pss instanceof ParameterDisposer) {
						((ParameterDisposer) pss).cleanupParameters();
					}
				}
			}
		});
	}



在代码中捕获了SQLException然后抛出一个org.springframework.dao.DataAcceddException,该异常继承自org.springframework.core.NestedRuntimeException,NestedRuntimeException
是一个继承自RuntimeException的抽象类,Spring jdbcTemplate处理发生异常处理后抛出来得异常基本上都会继承NestedRuntimeException,看完之后才确信了Spring默认只对RuntimeException进行回滚

当然我们可可以修改Spring的默认配置,当发生RuntimeException我们也可以不让他进行事务回滚
只需要加上一个@Transactional(noRollbackFor=RuntimeException.class)
注意@Transactional只能针对public属性范围内的方法添加

Java代码 复制代码 收藏代码
  1. package com.royzhou.jdbc;
  3. import java.util.List;
  5. import javax.sql.DataSource;
  6. import java.sql.Types;
  8. import org.springframework.jdbc.core.JdbcTemplate;
  9. import org.springframework.transaction.annotation.Transactional;
  11. @Transactional
  12. public class PersonServiceImpl implements PersonService {
  14. private JdbcTemplate jdbcTemplate;
  16. /**
  17. * 通过Spring容器注入datasource
  18. * 实例化JdbcTemplate,该类为主要操作数据库的类
  19. * @param ds
  20. */
  21. public void setDataSource(DataSource ds) {
  22. this.jdbcTemplate = new JdbcTemplate(ds);
  23. }
  25. @Transactional(noRollbackFor=RuntimeException.class)
  26. public void addPerson(PersonBean person) {
  27. /**
  28. * 第一个参数为执行sql
  29. * 第二个参数为参数数据
  30. * 第三个参数为参数类型
  31. */
  32. jdbcTemplate.update("insert into person values(null,?)", new Object[]{person.getName()}, new int[]{Types.VARCHAR});
  33. throw new RuntimeException("运行期例外");
  34. }
  36. public void deletePerson(int id) {
  37. jdbcTemplate.update("delete from person where id = ?", new Object[]{id}, new int[]{Types.INTEGER});
  38. }
  40. @SuppressWarnings("unchecked")
  41. public PersonBean queryPerson(int id) {
  42. /**
  43. * new PersonRowMapper()是一个实现RowMapper接口的类,
  44. * 执行回调,实现mapRow()方法将rs对象转换成PersonBean对象返回
  45. */
  46. List<PersonBean> pbs = (List<PersonBean>)jdbcTemplate.query("select id,name from person where id = ?", new Object[]{id}, new PersonRowMapper());
  47. PersonBean pb = null;
  48. if(pbs.size()>0) {
  49. pb = pbs.get(0);
  50. }
  51. return pb;
  52. }
  54. @SuppressWarnings("unchecked")
  55. public List<PersonBean> queryPersons() {
  56. List<PersonBean> pbs = (List<PersonBean>) jdbcTemplate.query("select id,name from person", new PersonRowMapper());
  57. return pbs;
  58. }
  60. public void updatePerson(PersonBean person) {
  61. jdbcTemplate.update("update person set name = ? where id = ?", new Object[]{person.getName(), person.getId()}, new int[]{Types.VARCHAR, Types.INTEGER});
  62. }
  63. } 
package com.royzhou.jdbc;

import java.util.List;

import javax.sql.DataSource;
import java.sql.Types;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.transaction.annotation.Transactional;

@Transactional
public class PersonServiceImpl implements PersonService {

	private JdbcTemplate jdbcTemplate;
	
	/**
	 * 通过Spring容器注入datasource
	 * 实例化JdbcTemplate,该类为主要操作数据库的类
	 * @param ds
	 */
	public void setDataSource(DataSource ds) {
		this.jdbcTemplate = new JdbcTemplate(ds);
	}
	
	@Transactional(noRollbackFor=RuntimeException.class)
	public void addPerson(PersonBean person) {
		/**
		 * 第一个参数为执行sql
		 * 第二个参数为参数数据
		 * 第三个参数为参数类型
		 */
		jdbcTemplate.update("insert into person values(null,?)", new Object[]{person.getName()}, new int[]{Types.VARCHAR});
		throw new RuntimeException("运行期例外");
	}

	public void deletePerson(int id) {
		jdbcTemplate.update("delete from person where id = ?", new Object[]{id}, new int[]{Types.INTEGER});
	}

	@SuppressWarnings("unchecked")
	public PersonBean queryPerson(int id) {
		/**
		 * new PersonRowMapper()是一个实现RowMapper接口的类,
		 * 执行回调,实现mapRow()方法将rs对象转换成PersonBean对象返回
		 */
		List<PersonBean> pbs = (List<PersonBean>)jdbcTemplate.query("select id,name from person where id = ?", new Object[]{id}, new PersonRowMapper());
		PersonBean pb = null;
		if(pbs.size()>0) {
			pb = pbs.get(0);
		}
		return pb;
	}

	@SuppressWarnings("unchecked")
	public List<PersonBean> queryPersons() {
		List<PersonBean> pbs = (List<PersonBean>) jdbcTemplate.query("select id,name from person", new PersonRowMapper());
		return pbs;
	}

	public void updatePerson(PersonBean person) {
		jdbcTemplate.update("update person set name = ? where id = ?", new Object[]{person.getName(), person.getId()}, new int[]{Types.VARCHAR, Types.INTEGER});
	}
}



运行测试类:

Java代码 复制代码 收藏代码
  1. package com.royzhou.jdbc;
  3. import org.springframework.context.ApplicationContext;
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;
  6. public class TestJdbcTemplate {
  7. public static void main(String[] args) {
  8. ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml");
  9. PersonService ps = (PersonService)ctx.getBean("personService");
  10. ps.addPerson(new PersonBean("royzhou"));
  11. }
  12. } 
package com.royzhou.jdbc;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestJdbcTemplate {
	public static void main(String[] args) {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml");
		PersonService ps = (PersonService)ctx.getBean("personService");
		ps.addPerson(new PersonBean("royzhou"));
	}
}



后台抛出异常,查看数据库,记录插入进去了,说明我们配置事务不对RuntimeException回滚生效了.
既然可以配置不对RuntimeException回滚,那我们也可以配置对Exception进行回滚,主要用到的是
@Transactional(rollbackFor=Exception.class)

对于一些查询工作,因为不需要配置事务支持,我们配置事务的传播属性:
@Transactional(propagation=Propagation.NOT_SUPPORTED,readOnly=true)

readOnly=true表示事务中不允许存在更新操作.

关于事务的传播属性有下面几种配置:
REQUIRED：业务方法需要在一个事务中运行,如果方法运行时,已经处于一个事务中,那么加入到该事务中,否则自己创建一个新的事务.(Spring默认的事务传播属性)
NOT_SUPPORTED：声明方法不需要事务,如果方法没有关联到一个事务,容器不会为它开启事务,如果方法在一个事务中被调用,该事务被挂起,在方法调用结束后,原先的事务便会恢复执行
REQUIRESNEW：不管是否存在事务,业务方法总会为自己发起一个新的事务,如果方法运行时已经存在一个事务,则该事务会被挂起,新的事务被创建,知道方法执行结束,新事务才结束,原先的事务才恢复执行.
MANDATORY：指定业务方法只能在一个已经存在的事务中执行,业务方法不能自己发起事务,如果业务方法没有在事务的环境下调用,则容器会抛出异常
SUPPORTS:如果业务方法在事务中被调用,则成为事务中的一部分,如果没有在事务中调用,则在没有事务的环境下执行
NEVER：指定业务方法绝对不能在事务范围内运行,否则会抛出异常.
NESTED：如果业务方法运行时已经存在一个事务,则新建一个嵌套的事务,该事务可以有多个回滚点,如果没有事务,则按REQUIRED属性执行. 注意:业务方法内部事务的回滚不会对外部事务造成影响,但是外部事务的回滚会影响内部事务


关于使用注解的方式来配置事务就到这里,
我们还可以使用另外一种方式实现事务的管理,通过xml文件的配置,主要通过AOP技术实现:

首先把我们的业务类的注解去掉:

Java代码 复制代码 收藏代码
  1. package com.royzhou.jdbc;
  3. import java.util.List;
  5. import javax.sql.DataSource;
  6. import java.sql.Types;
  8. import org.springframework.jdbc.core.JdbcTemplate;
  10. public class PersonServiceImpl implements PersonService {
  12. private JdbcTemplate jdbcTemplate;
  14. /**
  15. * 通过Spring容器注入datasource
  16. * 实例化JdbcTemplate,该类为主要操作数据库的类
  17. * @param ds
  18. */
  19. public void setDataSource(DataSource ds) {
  20. this.jdbcTemplate = new JdbcTemplate(ds);
  21. }
  23. public void addPerson(PersonBean person) {
  24. /**
  25. * 第一个参数为执行sql
  26. * 第二个参数为参数数据
  27. * 第三个参数为参数类型
  28. */
  29. jdbcTemplate.update("insert into person values(null,?)", new Object[]{person.getName()}, new int[]{Types.VARCHAR});
  30. throw new RuntimeException("运行期例外");
  31. }
  33. public void deletePerson(int id) {
  34. jdbcTemplate.update("delete from person where id = ?", new Object[]{id}, new int[]{Types.INTEGER});
  35. }
  37. @SuppressWarnings("unchecked")
  38. public PersonBean queryPerson(int id) {
  39. /**
  40. * new PersonRowMapper()是一个实现RowMapper接口的类,
  41. * 执行回调,实现mapRow()方法将rs对象转换成PersonBean对象返回
  42. */
  43. List<PersonBean> pbs = (List<PersonBean>)jdbcTemplate.query("select id,name from person where id = ?", new Object[]{id}, new PersonRowMapper());
  44. PersonBean pb = null;
  45. if(pbs.size()>0) {
  46. pb = pbs.get(0);
  47. }
  48. return pb;
  49. }
  51. @SuppressWarnings("unchecked")
  52. public List<PersonBean> queryPersons() {
  53. List<PersonBean> pbs = (List<PersonBean>) jdbcTemplate.query("select id,name from person", new PersonRowMapper());
  54. return pbs;
  55. }
  57. public void updatePerson(PersonBean person) {
  58. jdbcTemplate.update("update person set name = ? where id = ?", new Object[]{person.getName(), person.getId()}, new int[]{Types.VARCHAR, Types.INTEGER});
  59. }
  60. } 
package com.royzhou.jdbc;

import java.util.List;

import javax.sql.DataSource;
import java.sql.Types;

import org.springframework.jdbc.core.JdbcTemplate;

public class PersonServiceImpl implements PersonService {

	private JdbcTemplate jdbcTemplate;
	
	/**
	 * 通过Spring容器注入datasource
	 * 实例化JdbcTemplate,该类为主要操作数据库的类
	 * @param ds
	 */
	public void setDataSource(DataSource ds) {
		this.jdbcTemplate = new JdbcTemplate(ds);
	}
	
	public void addPerson(PersonBean person) {
		/**
		 * 第一个参数为执行sql
		 * 第二个参数为参数数据
		 * 第三个参数为参数类型
		 */
		jdbcTemplate.update("insert into person values(null,?)", new Object[]{person.getName()}, new int[]{Types.VARCHAR});
		throw new RuntimeException("运行期例外");
	}

	public void deletePerson(int id) {
		jdbcTemplate.update("delete from person where id = ?", new Object[]{id}, new int[]{Types.INTEGER});
	}
	
	@SuppressWarnings("unchecked")
	public PersonBean queryPerson(int id) {
		/**
		 * new PersonRowMapper()是一个实现RowMapper接口的类,
		 * 执行回调,实现mapRow()方法将rs对象转换成PersonBean对象返回
		 */
		List<PersonBean> pbs = (List<PersonBean>)jdbcTemplate.query("select id,name from person where id = ?", new Object[]{id}, new PersonRowMapper());
		PersonBean pb = null;
		if(pbs.size()>0) {
			pb = pbs.get(0);
		}
		return pb;
	}

	@SuppressWarnings("unchecked")
	public List<PersonBean> queryPersons() {
		List<PersonBean> pbs = (List<PersonBean>) jdbcTemplate.query("select id,name from person", new PersonRowMapper());
		return pbs;
	}

	public void updatePerson(PersonBean person) {
		jdbcTemplate.update("update person set name = ? where id = ?", new Object[]{person.getName(), person.getId()}, new int[]{Types.VARCHAR, Types.INTEGER});
	}
}



然后我们需要在bean.xml文件中配置:

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:aop="http://www.springframework.org/schema/aop"
  6. xmlns:tx="http://www.springframework.org/schema/tx"
  7. xsi:schemaLocation="http://www.springframework.org/schema/beans
  8. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
  9. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
  10. http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
  11. http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
  13. <context:property-placeholder location="classpath:jdbc.properties" />
  14. <bean id="dataSource"
  15. class="org.apache.commons.dbcp.BasicDataSource"
  16. destroy-method="close">
  17. <property name="driverClassName" value="${driverClassName}" />
  18. <property name="url" value="${url}" />
  19. <property name="username" value="${username}" />
  20. <property name="password" value="${password}" />
  21. <!-- 连接池启动时的初始值 -->
  22. <property name="initialSize" value="${initialSize}" />
  23. <!-- 连接池的最大值 -->
  24. <property name="maxActive" value="${maxActive}" />
  25. <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->
  26. <property name="maxIdle" value="${maxIdle}" />
  27. <!-- 最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->
  28. <property name="minIdle" value="${minIdle}" />
  29. </bean>
  31. <bean id="personService"
  32. class="com.royzhou.jdbc.PersonServiceImpl">
  33. <property name="dataSource" ref="dataSource"></property>
  34. </bean>
  36. <bean id="txManager"
  37. class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  38. <property name="dataSource" ref="dataSource" />
  39. </bean>
  41. <!-- 定义事务传播属性 -->
  42. <tx:advice id="txAdvice" transaction-manager="txManager">
  43. <tx:attributes>
  44. <tx:method name="query*" propagation="NOT_SUPPORTED" read-only="true"/>
  45. <tx:method name="*" propagation="REQUIRED"/>
  46. </tx:attributes>
  47. </tx:advice>
  49. <aop:config>
  50. <aop:pointcut id="transactionPointCut" expression="execution(* com.royzhou.jdbc..*.*(..))"/>
  51. <aop:advisor pointcut-ref="transactionPointCut" advice-ref="txAdvice"/>
  52. </aop:config>
  53. </beans> 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

	<context:property-placeholder location="classpath:jdbc.properties" />
	<bean id="dataSource"
		class="org.apache.commons.dbcp.BasicDataSource"
		destroy-method="close">
		<property name="driverClassName" value="${driverClassName}" />
		<property name="url" value="${url}" />
		<property name="username" value="${username}" />
		<property name="password" value="${password}" />
		<!-- 连接池启动时的初始值 -->
		<property name="initialSize" value="${initialSize}" />
		<!-- 连接池的最大值 -->
		<property name="maxActive" value="${maxActive}" />
		<!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->
		<property name="maxIdle" value="${maxIdle}" />
		<!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->
		<property name="minIdle" value="${minIdle}" />
	</bean>

	<bean id="personService"
		class="com.royzhou.jdbc.PersonServiceImpl">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
	<bean id="txManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>
	
	<!-- 定义事务传播属性 -->
	<tx:advice id="txAdvice" transaction-manager="txManager">
		<tx:attributes>
			<tx:method name="query*" propagation="NOT_SUPPORTED" read-only="true"/>
			<tx:method name="*" propagation="REQUIRED"/>
		</tx:attributes>
	</tx:advice>
	
	<aop:config>
		<aop:pointcut id="transactionPointCut" expression="execution(* com.royzhou.jdbc..*.*(..))"/>
		<aop:advisor pointcut-ref="transactionPointCut" advice-ref="txAdvice"/>
	</aop:config>
</beans>



从新运行测试类
后台抛出RuntimeException异常,查看数据库,没有插入数据,说明事务进行回滚,XML方式的配置也生效了.


另外还有一个编程式的事务处理,但是它有些侵入性。通常我们的事务需求并没有要求在事务的边界上进行如此精确的控制。
我们一般采用"声明式事务"。

总结一下:
事务是企业应用开发的重要组成部分，他使软件更加可靠。它们确保一种要么全有要么全无的行为，防止数据不一致而导致的不可预测的错误发生。
它们同时也支持并发，防止并发应用线程在操作同一数据时互相影响。以前我们写Jdbc代码的时候,可能需要自己手动去开启事务,然后方法执行结束之后
再去提交事务,全部都嵌套在我们的业务代码之中,具有很强的侵入性....
使用Spring提供事务管理机制,我们只需要配置XML或使用Annotion进行注解就可以实现事务的管理和配置,减少了代码之间的耦合,配置也很方便,很大程度上提升了我们的开发效率.
该文章转载自http://www.iteye.com/topic/480432

分享到：
| Spring JDBC Framework详解——批量JDBC操 ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    4.Spring中的JdbcTemplate,Spring中的的事务，

    通过本章节的学习，您应该能够掌握如何使用JdbcTemplate进行基本的数据库操作，以及如何在Spring中配置和使用声明式事务来管理复杂的业务流程。这些技能对于开发基于Spring框架的应用程序至关重要。

    JdbcTemplate的事务控制.docx

    当使用`JdbcTemplate`结合Spring框架时，可以采用与原生JDBC事务控制类似的方法，但在Spring环境中进行管理。以下是一个使用Druid数据库连接池的示例代码： ```java @RequestMapping("/druidData1") public String ...

    基于注解的Spring JdbcTemplate

    本教程将深入探讨如何使用基于注解的Spring JdbcTemplate进行数据库操作，特别适合初学者入门学习。 ### 1. Spring JdbcTemplate简介 Spring JdbcTemplate提供了一个面向对象的接口，用于执行SQL查询、更新和存储...

    spring-jdbcTemplate实例工程

    Spring JdbcTemplate支持自动和手动的事务管理。在AOP（面向切面编程）的帮助下，可以在方法级别控制事务的开始、提交和回滚。例如，通过@Transactional注解开启事务，当发生异常时，事务会自动回滚。 五、优势与...

    配制Spring事务和JdbcTemplate使用

    配制Spring事务和JdbcTemplate使用 配制Spring事务和JdbcTemplate使用

    SpringJdbcTemplate封装工具类

    SpringJdbcTemplate继承自`JdbcAccessor`，包含了事务管理的支持。它可以自动将数据库操作封装在事务中，当出现异常时，会回滚事务，确保数据的一致性。 6. **异常处理** SpringJdbcTemplate将底层JDBC抛出的异常...

    Spring4--3.jdbcTemplate事务

    文件`spring_3_1`、`spring_3`和`spring_3_2`可能包含了Spring框架关于JdbcTemplate和事务管理的更多示例代码和配置信息，学习这些资源有助于深入理解Spring4中如何有效地利用JdbcTemplate进行事务控制。通过实践，...

    Spring JDBCTemplate连接池jar包

    3. `spring-jdbc-5.0.0.RELEASE.jar`：包含Spring对JDBC的支持，包括JDBCTemplate和DataSourceTransactionManager，它们是与数据库交互和管理事务的关键。 4. `spring-tx-5.0.0.RELEASE.jar`：提供了事务管理功能，...

    Spring JdbcTemplate例子

    首先，JdbcTemplate的核心理念是通过预编译的SQL语句和参数绑定来防止SQL注入攻击，同时提供事务管理的支持。它提供了大量方法来执行各种数据库操作，如查询、更新、插入和删除等。 使用Spring JdbcTemplate的第一...

    Spring JdbcTemplate

    它抽象了数据库连接管理、事务控制等复杂过程，使代码更加简洁、易于测试。例如，`queryForList(String sql, Class&lt;T&gt; elementType)`方法用于执行SQL查询并返回一个对象列表，`update(String sql, Object... args)`...

    strut2+spring+springjdbctemplate做的简易登录系统

    Spring则是一个全面的后端框架，提供依赖注入、AOP（面向切面编程）、事务管理等功能；Spring JDBC Template是Spring提供的一个简化数据库操作的工具，它封装了JDBC的繁琐部分，让开发者可以更专注于业务逻辑。 在...

    Spring JdbcTemplate 常用方法整理

    Spring的JdbcTemplate是Spring框架中用于简化数据库操作的工具类，它是基于JDBC但又抽象出了一层，避免了直接与数据库驱动API交互，从而提高了代码的可读性和可维护性。本文将深入探讨Spring JdbcTemplate的常用方法...

    Spring JdbcTemplate查询实例

    Spring JdbcTemplate还提供了事务管理的支持。你可以使用`update`方法执行增删改操作，如果出现异常，Spring会自动回滚事务，保证数据的一致性。 5. **与MyBatis的对比** MyBatis是一个更全面的ORM框架，允许编写...

    注入JdbcTemplate启用事务管理.docx

    在Spring框架中，事务管理是实现业务逻辑时不可或缺的一部分，特别是在复杂的系统中，确保数据的一致性和完整性至关重要。本文将详细讲解如何通过JdbcTemplate启用事务管理，并探讨事务的传播机制。 首先，我们要...

    spring jdbcTemplate 源码

    Spring JDBCTemplate还提供了事务管理支持。当开启事务时，它会捕获并处理数据库异常，根据异常类型决定回滚还是提交事务。这样，开发者无需手动处理这些细节，提高了代码的可读性和可靠性。 此外，JdbcTemplate对...

    spring的jdbcTemplate小案例

    它还支持事务管理，可以方便地与Spring的其他组件集成，如DataSource和TransactionManager。 在创建一个Spring的JdbcTemplate小案例时，我们需要完成以下几个步骤： 1. **配置DataSource**：首先，我们需要一个...

    Spring 学习 JdbcTemplate，模板模式，回调

    JdbcTemplate支持各种数据库操作，包括查询、更新、插入和删除，同时提供事务管理功能。 **2. 模板模式** 模板模式是一种设计模式，它定义了算法的骨架，允许子类在不改变算法结构的情况下重写特定步骤。在Spring中...

    使用Spring JDBCTemplate进行增删改查curd操作

    通过使用JdbcTemplate，开发者可以避免编写大量的重复代码，如手动管理连接、处理结果集等，从而专注于业务逻辑。本文将深入探讨如何利用Spring JdbcTemplate进行CURD（Create、Read、Update、Delete）操作。 1. ...

    Spring事务管理Demo

    2. **声明式事务管理**：这是Spring最常用的方式，通过在配置文件或者使用`@Transactional`注解来定义事务边界，使得事务管理与业务逻辑分离，降低了代码的耦合度。`@Transactional`注解可以应用于方法级别，表示该...

    Spring JdbcTemplate.batchUpdate 例子

    总之，`Spring JdbcTemplate.batchUpdate`是处理批量数据库操作的强大工具，它可以提高效率，减少与数据库的交互次数。然而，正确地使用它需要对事务管理、异常处理和性能优化有深入的理解。通过合理的配置和良好的...

Magicbox
Global site tag (gtag.js) - Google Analytics