<!-- 配置 C3P0 数据源 -->
<bean id="dataSource"
class="com.mchange.boPooledDataSource">
<property name="user" value="${jdbc.user}"></property>
<property name="password" value="${jdbc.password}"></property>
<property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
<property name="driverClass" value="${jdbc.driverClass}"></property>
<property name="initialPoolSize" value="${jdbc.initPoolSize}"></property>
<property name="maxPoolSize" value="${jdbc.maxPoolSize}"></property>
</bean>
<!-- 配置 Spirng 的 JdbcTemplate -->
<bean id="jdbcTemplate"
class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 配置 NamedParameterJdbcTemplate, 该对象可以使用具名参数, 其没有无参数的构造器, 所以必须为其构造器指定参数 -->
<bean id="namedParameterJdbcTemplate"
class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
<constructor-arg ref="dataSource"></constructor-arg>
</bean>
public class JDBCTest {
private ApplicationContext ctx = null;
private JdbcTemplate jdbcTemplate;
private EmployeeDao employeeDao;
private DepartmentDao departmentDao;
private NamedParameterJdbcTemplate namedParameterJdbcTemplate;
{
ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
jdbcTemplate = (JdbcTemplate) ctx.getBean("jdbcTemplate");
employeeDao = ctx.getBean(EmployeeDao.class);
departmentDao = ctx.getBean(DepartmentDao.class);
namedParameterJdbcTemplate = ctx.getBean(NamedParameterJdbcTemplate.class);
}
/**
* 使用具名参数时, 可以使用 update(String sql, SqlParameterSource paramSource) 方法进行更新操作
* 1. SQL 语句中的参数名和类的属性一致!
* 2. 使用 SqlParameterSource 的 BeanPropertySqlParameterSource 实现类作为参数.
*/
@Test
public void testNamedParameterJdbcTemplate2(){
String sql = "INSERT INTO employees(last_name, email, dept_id) "
+ "VALUES(:lastName,:email,:dpetId)";
Employee employee = new Employee();
employee.setLastName("XYZ");
employee.setEmail("xyz@");
employee.setDpetId(3);
SqlParameterSource paramSource = new BeanPropertySqlParameterSource(employee);
namedParameterJdbcTemplate.update(sql, paramSource);
}
/**
* 可以为参数起名字.
* 1. 好处: 若有多个参数, 则不用再去对应位置, 直接对应参数名, 便于维护
* 2. 缺点: 较为麻烦.
*/
@Test
public void testNamedParameterJdbcTemplate(){
String sql = "INSERT INTO employees(last_name, email, dept_id) VALUES(:ln,:email,:deptid)";
Map<String, Object> paramMap = new HashMap<>();
paramMap.put("ln", "FF");
paramMap.put("email", "ff@");
paramMap.put("deptid", 2);
namedParameterJdbcTemplate.update(sql, paramMap);
}
@Test
public void testDepartmentDao(){
System.out.println(departmentDao.get(1));
}
@Test
public void testEmployeeDao(){
System.out.println(employeeDao.get(1));
}
/**
* 获取单个列的值, 或做统计查询
* 使用 queryForObject(String sql, Class<Long> requiredType)
*/
@Test
public void testQueryForObject2(){
String sql = "SELECT count(id) FROM employees";
long count = jdbcTemplate.queryForObject(sql, Long.class);
System.out.println(count);
}
/**
* 查到实体类的集合
* 注意调用的不是 queryForList 方法
*/
@Test
public void testQueryForList(){
String sql = "SELECT id, last_name lastName, email FROM employees WHERE id > ?";
RowMapper<Employee> rowMapper = new BeanPropertyRowMapper<>(Employee.class);
List<Employee> employees = jdbcTemplate.query(sql, rowMapper,5);
System.out.println(employees);
}
/**
* 从数据库中获取一条记录, 实际得到对应的一个对象
* 注意不是调用 queryForObject(String sql, Class<Employee> requiredType, Object... args) 方法!
* 而需要调用 queryForObject(String sql, RowMapper<Employee> rowMapper, Object... args)
* 1. 其中的 RowMapper 指定如何去映射结果集的行, 常用的实现类为 BeanPropertyRowMapper
* 2. 使用 SQL 中列的别名完成列名和类的属性名的映射. 例如 last_name lastName
* 3. 不支持级联属性. JdbcTemplate 到底是一个 JDBC 的小工具, 而不是 ORM 框架
*/
@Test
public void testQueryForObject(){
String sql = "SELECT id, last_name lastName, email, dept_id as \"department.id\" FROM employees WHERE id = ?";
RowMapper<Employee> rowMapper = new BeanPropertyRowMapper<>(Employee.class);
Employee employee = jdbcTemplate.queryForObject(sql, rowMapper, 1);
System.out.println(employee);
}
/**
* 执行批量更新: 批量的 INSERT, UPDATE, DELETE
* 最后一个参数是 Object[] 的 List 类型: 因为修改一条记录需要一个 Object 的数组, 那么多条不就需要多个 Object 的数组吗
*/
@Test
public void testBatchUpdate(){
String sql = "INSERT INTO employees(last_name, email, dept_id) VALUES(?,?,?)";
List<Object[]> batchArgs = new ArrayList<>();
batchArgs.add(new Object[]{"AA", "aa@", 1});
batchArgs.add(new Object[]{"BB", "bb@", 2});
batchArgs.add(new Object[]{"CC", "cc@", 3});
batchArgs.add(new Object[]{"DD", "dd@", 3});
batchArgs.add(new Object[]{"EE", "ee@", 2});
jdbcTemplate.batchUpdate(sql, batchArgs);
}
/**
* 执行 INSERT, UPDATE, DELETE
*/
@Test
public void testUpdate(){
String sql = "UPDATE employees SET last_name = ? WHERE id = ?";
jdbcTemplate.update(sql, "Jack", 5);
}
@Test
public void testDataSource() throws SQLException {
DataSource dataSource = ctx.getBean(DataSource.class);
System.out.println(dataSource.getConnection());
}
}
@Repository
public class EmployeeDao {
@Autowired
private JdbcTemplate jdbcTemplate;
public Employee get(Integer id){
String sql = "SELECT id, last_name lastName, email FROM employees WHERE id = ?";
RowMapper<Employee> rowMapper = new BeanPropertyRowMapper<>(Employee.class);
Employee employee = jdbcTemplate.queryForObject(sql, rowMapper, id);
return employee;
}
}
/**
* 不推荐使用 JdbcDaoSupport, 而推荐直接使用 JdbcTempate 作为 Dao 类的成员变量
*/
@Repository
public class DepartmentDao extends JdbcDaoSupport{
@Autowired
public void setDataSource2(DataSource dataSource){
setDataSource(dataSource);
}
public Department get(Integer id){
String sql = "SELECT id, dept_name name FROM departments WHERE id = ?";
RowMapper<Department> rowMapper = new BeanPropertyRowMapper<>(Department.class);
return getJdbcTemplate().queryForObject(sql, rowMapper, id);
}
}
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="/schema/beans"
xmlns:xsi="/2001/XMLSchema-instance" xmlns:context="/schema/context"
xmlns:tx="/schema/tx" xmlns:aop="/schema/aop"
xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-2.5.xsd
/schema/context /schema/context/spring-context-2.5.xsd
/schema/tx /schema/tx/spring-tx-2.5.xsd
/schema/aop /schema/aop/spring-aop-2.5.xsd ">
<!-- 自动扫描与装配bean -->
<context:component-scan base-package="cn.itcast.spring.p_jdbc"></context:component-scan>
<!-- 加载外部的配置文件 -->
<context:property-placeholder location="classpath:cn/itcast/spring/p_jdbc/jdbc.properties"/>
<!-- 一、配置数据库连接池 ComboPooledDataSource -->
<bean id="dataSource" class="com.mchange.boPooledDataSource">
<!-- 基本的连接信息 -->
<property name="jdbcUrl" value="${jdbcUrl}"></property>
<property name="driverClass" value="${driverClass}"></property>
<property name="user" value="${username}"></property>
<property name="password" value="${password}"></property>
<!-- 一些管理的配置 -->
<!--初始化时获取三个连接，取值应在minPoolSize与maxPoolSize之间。Default: 3 -->
<property name="initialPoolSize" value="3"></property>
<!--连接池中保留的最小连接数。Default: 3 -->
<property name="minPoolSize" value="3"></property>
<!--连接池中保留的最大连接数。Default: 15 -->
<property name="maxPoolSize" value="5"></property>
<!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3 -->
<property name="acquireIncrement" value="3"></property>
<!--最大空闲时间，1800秒内未使用则连接被丢弃，若为0则永不丢弃。Default: 0 -->
<property name="maxIdleTime" value="1800"></property>
</bean>
<!-- 二、配置JdbcTemplate -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 三、配置声明式事务管理 -->
<!-- 声明“事务管理器” -->
<bean id="dsTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- ==== 基于注解的方式配置事务 ==== --> <tx:annotation-driven transaction-manager="dsTransactionManager"/> <!-- ==== 基于XML的方式配置事务 ==== -->
<!-- 声明“通知”：
对于以save或update或delete开头的方法，使用正常的事务，其他的方法都使用只读的事务
read-only：表示事务是否是只读的，默认为false。
<tx:advice id="transactionManager" transaction-manager="dsTransactionManager">
<tx:attributes>
<tx:method name="save*" read-only="false"/>
<tx:method name="update*"/>
<tx:method name="delete*"/>
<tx:method name="*" read-only="true"/>
</tx:attributes>
</tx:advice>
-->
<!-- 声明“切面”
<aop:config>
<aop:advisor advice-ref="transactionManager" pointcut="execution(* cn.itcast.spring.p_jdbc.*Dao.*(..))"/>
</aop:config>
-->
</beans>
@Repository
@Transactional(readOnly = true)
public class UserDao {
@Resource
private JdbcTemplate jdbcTemplate;
/**
* 保存
*
* @param user
*/
@Transactional(readOnly = false)
public void save(final User user) {
// jdbcTemplate.execute(new ConnectionCallback() {
// public Object doInConnection(Connection conn) throws SQLException, DataAccessException {
// String sql = "insert into t_user(name, age) values (?, ?)";
// PreparedStatement ps = conn.prepareStatement(sql);
// ps.setString(1, user.getName()); // 第1个参数的索引是1
// ps.setInt(2, user.getAge());
// ps.execute();
// ps.close();
// return null;
// }
// });
String sql = "insert into t_user(name, age) values (?, ?)";
jdbcTemplate.update(sql, new Object[] { user.getName(), user.getAge() });
delete(1);
}
/**
* 删除
*
* @param id
*/
public void delete(Integer id) {
String sql = "delete from t_user where id=?";
jdbcTemplate.update(sql, new Object[] { id });
}
/**
* 更新
*
* @param user
*/
public void update(User user) {
String sql = "update t_user set name=?, age=? where id=?";
jdbcTemplate.update(sql, new Object[] { user.getName(), user.getAge(), user.getId() });
}
/**
* 根据id查询一个数据
*
* @param id
* @return
*/
public User getById(final Integer id) {
String sql = "select name,age from t_user where id=?";
return (User) jdbcTemplate.queryForObject(sql, new Object[] { id }, new RowMapper() {
public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
String name = rs.getString(1);
int age = rs.getInt(2);
return new User(id, name, age);
}
});
}
@Transactional(isolation = Isolation.READ_COMMITTED)
public void testGet(int id) {
User user = getById(id);
System.out.println(user);
user = getById(id);
System.out.println(user);
}
/**
* 查询总数量
*
* @return
*/
public int getCount() {
String sql = "select count(*) from t_user";
return jdbcTemplate.queryForInt(sql);
}
/**
* 查询所有
*
* @return
*/
@SuppressWarnings("unchecked")
public List<User> findAll() {
String sql = "select id,name,age from t_user";
return jdbcTemplate.query(sql, new RowMapper() {
public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
int id = rs.getInt(1);
String name = rs.getString(2);
int age = rs.getInt(3);
return new User(id, name, age);
}
});
}
/**
* 查询所有（分页）
*
* @param firstResult
* @param maxResult
* @return
*/
public QueryResult findAll(int firstResult, int maxResult) {
int count = jdbcTemplate.queryForInt("select count(*) from t_user");
List list = jdbcTemplate.query(//
"select id,name,age from t_user limit ?,?", //
new Object[] { firstResult, maxResult }, //
new RowMapper() {
public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
int id = rs.getInt(1);
String name = rs.getString(2);
int age = rs.getInt(3);
return new User(id, name, age);
}
});
return new QueryResult(count, list);
}
}
public class QueryResult {
private int count;
private List list;
public QueryResult(int count, List list) {
this.count = count;
this.list = list;
}
。。。
}
事务管理是企业级应用程序开发中必不可少的技术, 用来确保数据的完整性和一致性.
事务就是一系列的动作, 它们被当做一个单独的工作单元. 这些动作要么全部完成, 要么全部不起作用
事务的四个关键属性(ACID)
原子性(atomicity): 事务是一个原子操作, 由一系列动作组成. 事务的原子性确保动作要么全部完成要么完全不起作用.
一致性(consistency): 一旦所有事务动作完成, 事务就被提交. 数据和资源就处于一种满足业务规则的一致性状态中.
隔离性(isolation): 可能有许多事务会同时处理相同的数据, 因此每个事物都应该与其他事务隔离开来, 防止数据损坏.
持久性(durability): 一旦事务完成, 无论发生什么系统错误, 它的结果都不应该受到影响. 通常情况下, 事务的结果被写到持久化存储器中.
必须为不同的方法重写类似的样板代码
这段代码是特定于 JDBC 的, 一旦选择类其它数据库存取技术, 代码需要作出相应的修改
作为企业级应用程序框架, Spring 在不同的事务管理 API 之上定义了一个抽象层. 而应用程序开发人员不必了解底层的事务管理 API, 就可以使用 Spring 的事务管理机制.
Spring 既支持编程式事务管理, 也支持声明式的事务管理.
编程式事务管理: 将事务管理代码嵌入到业务方法中来控制事务的提交和回滚. 在编程式管理事务时, 必须在每个事务操作中包含额外的事务管理代码.
声明式事务管理: 大多数情况下比编程式事务管理更好用. 它将事务管理代码从业务方法中分离出来, 以声明的方式来实现事务管理. 事务管理作为一种横切关注点, 可以通过 AOP 方法模块化. Spring 通过 Spring AOP 框架支持声明式事务管理.
Spring 从不同的事务管理 API 中抽象了一整套的事务机制. 开发人员不必了解底层的事务 API, 就可以利用这些事务机制. 有了这些事务机制, 事务管理代码就能独立于特定的事务技术了.
Spring 的核心事务管理抽象是PlatformTransactionManager它为事务管理封装了一组独立于技术的方法. 无论使用 Spring 的哪种事务管理策略(编程式或声明式), 事务管理器都是必须的.
DataSourceTransactionManager:在应用程序中只需要处理一个数据源, 而且通过 JDBC 存取
JtaTransactionManager: 在 JavaEE 应用服务器上用 JTA(Java Transaction API) 进行事务管理
HibernateTransactionManager：用 Hibernate 框架存取数据库
……
事务管理器以普通的 Bean 形式声明在 Spring IOC 容器中
实际例子（来自尚硅谷）：
事务管理是一种横切关注点
为了在 Spring 2.x 中启用声明式事务管理, 可以通过 tx Schema 中定义的 <tx:advice> 元素声明事务通知, 为此必须事先将这个 Schema 定义添加到 <beans> 根元素中去.
声明了事务通知后, 就需要将它与切入点关联起来. 由于事务通知是在 <aop:config> 元素外部声明的, 所以它无法直接与切入点产生关联. 所以必须在 <aop:config> 元素中声明一个增强器通知与切入点关联起来.
由于 Spring AOP 是基于代理的方法, 所以只能增强公共方法. 因此, 只有公有方法才能通过 Spring AOP 进行事务管理.
除了在带有切入点, 通知和增强器的 Bean 配置文件中声明事务外, Spring 还允许简单地用 @Transactional 注解来标注事务方法.
为了将方法定义为支持事务处理的, 可以为方法添加 @Transactional 注解. 根据 Spring AOP 基于代理机制, 只能标注公有方法.
可以在方法或者类级别上添加 @Transactional 注解. 当把这个注解应用到类上时, 这个类中的所有公共方法都会被定义成支持事务处理的.
在 Bean 配置文件中只需要启用 <tx:annotation-driven> 元素, 并为之指定事务管理器就可以了.
如果事务处理器的名称是 transactionManager, 就可以在<tx:annotation-driven> 元素中省略 transaction-manager 属性. 这个元素会自动检测该名称的事务处理器.
当事务方法被另一个事务方法调用时, 必须指定事务应该如何传播. 例如: 方法可能继续在现有事务中运行, 也可能开启一个新事务, 并在自己的事务中运行.
事务的传播行为可以由传播属性指定. Spring 定义了 7 种类传播行为.
事务的隔离级别
当同一个应用程序或者不同应用程序中的多个事务在同一个数据集上并发执行时, 可能会出现许多意外的问题
并发事务所导致的问题可以分为下面三种类型:
脏读: 对于两个事物 T1, T2, T1 读取了已经被 T2 更新但 还没有被提交的字段. 之后, 若 T2 回滚, T1读取的内容就是临时且无效的.
不可重复读:对于两个事物 T1, T2, T1 读取了一个字段, 然后 T2 更新了该字段. 之后, T1再次读取同一个字段, 值就不同了.
幻读:对于两个事物 T1, T2, T1 从一个表中读取了一个字段, 然后 T2 在该表中插入了一些新的行. 之后, 如果 T1 再次读取同一个表, 就会多出几行.
从理论上来说, 事务应该彼此完全隔离, 以避免并发事务所导致的问题. 然而, 那样会对性能产生极大的影响, 因为事务必须按顺序运行.
在实际开发中, 为了提升性能, 事务会以较低的隔离级别运行.
事务的隔离级别可以通过隔离事务属性指定
用 @Transactional 注解声明式地管理事务时可以在 @Transactional 的 isolation 属性中设置隔离级别.
在 Spring 2.x 事务通知中, 可以在 <tx:method> 元素中指定隔离级别
默认情况下只有未检查异常(RuntimeException和Error类型的异常)会导致事务回滚. 而受检查异常不会.
事务的回滚规则可以通过 @Transactional 注解的 rollbackFor 和 noRollbackFor 属性来定义. 这两个属性被声明为 Class[] 类型的, 因此可以为这两个属性指定多个异常类.
rollbackFor: 遇到时必须进行回滚
noRollbackFor: 一组异常类，遇到时必须不回滚
在 Spring 2.x 事务通知中, 可以在 <tx:method> 元素中指定回滚规则. 如果有不止一种异常, 用逗号分隔.
由于事务可以在行和表上获得锁, 因此长事务会占用资源, 并对整体性能产生影响.
如果一个事物只读取数据但不做修改, 数据库引擎可以对这个事务进行优化.
超时事务属性: 事务在强制回滚之前可以保持多久. 这样可以防止长期运行的事务占用资源.
只读事务属性: 表示这个事务只读取数据但不更新数据, 这样可以帮助数据库引擎优化事务.
超时和只读属性可以在 @Transactional 注解中定义.超时属性以秒为单位来计算.
在 Spring 2.x 事务通知中, 超时和只读属性可以在 <tx:method> 元素中进行指定.
基于注解的事务管理
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans.xsd/schema/tx /schema/tx/spring-tx-4.0.xsd/schema/context /schema/context/spring-context-4.0.xsd"><context:component-scan base-package="com.atguigu.spring"></context:component-scan><!-- 导入资源文件 --><context:property-placeholder location="classpath:db.properties"/><!-- 配置 C3P0 数据源 --><bean id="dataSource"class="com.mchange.boPooledDataSource"><property name="user" value="${jdbc.user}"></property><property name="password" value="${jdbc.password}"></property><property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property><property name="driverClass" value="${jdbc.driverClass}"></property><property name="initialPoolSize" value="${jdbc.initPoolSize}"></property><property name="maxPoolSize" value="${jdbc.maxPoolSize}"></property></bean><!-- 配置 Spirng 的 JdbcTemplate --><bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"><property name="dataSource" ref="dataSource"></property></bean><!-- 配置 NamedParameterJdbcTemplate, 该对象可以使用具名参数, 其没有无参数的构造器, 所以必须为其构造器指定参数 --><bean id="namedParameterJdbcTemplate"class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate"><constructor-arg ref="dataSource"></constructor-arg></bean><!-- 配置事务管理器 --><bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource" ref="dataSource"></property></bean><!-- 启用事务注解 --><tx:annotation-driven transaction-manager="transactionManager"/></beans>
public interface BookShopDao {//根据书号获取书的单价public int findBookPriceByIsbn(String isbn);//更新数的库存. 使书号对应的库存 - 1public void updateBookStock(String isbn);//更新用户的账户余额: 使 username 的 balance - pricepublic void updateUserAccount(String username, int price);}
@Repository("bookShopDao")public class BookShopDaoImpl implements BookShopDao {@Autowiredprivate JdbcTemplate jdbcTemplate;@Overridepublic int findBookPriceByIsbn(String isbn) {String sql = "SELECT price FROM book WHERE isbn = ?";return jdbcTemplate.queryForObject(sql, Integer.class, isbn);}@Overridepublic void updateBookStock(String isbn) {//检查书的库存是否足够, 若不够, 则抛出异常String sql2 = "SELECT stock FROM book_stock WHERE isbn = ?";int stock = jdbcTemplate.queryForObject(sql2, Integer.class, isbn);if(stock == 0){throw new BookStockException("库存不足!");//数据库mysql本身不能检查}String sql = "UPDATE book_stock SET stock = stock -1 WHERE isbn = ?";jdbcTemplate.update(sql, isbn);}@Overridepublic void updateUserAccount(String username, int price) {//验证余额是否足够, 若不足, 则抛出异常String sql2 = "SELECT balance FROM account WHERE username = ?";int balance = jdbcTemplate.queryForObject(sql2, Integer.class, username);if(balance < price){throw new UserAccountException("余额不足!");}String sql = "UPDATE account SET balance = balance - ? WHERE username = ?";jdbcTemplate.update(sql, price, username);}}
public interface BookShopService {public void purchase(String username, String isbn);}
@Service("bookShopService")public class BookShopServiceImpl implements BookShopService {@Autowiredprivate BookShopDao bookShopDao;//添加事务注解//1.使用 propagation 指定事务的传播行为, 即当前的事务方法被另外一个事务方法调用时//如何使用事务, 默认取值为 REQUIRED, 即使用调用方法的事务//REQUIRES_NEW: 事务自己的事务, 调用的事务方法的事务被挂起. //2.使用 isolation 指定事务的隔离级别, 最常用的取值为 READ_COMMITTED//3.默认情况下 Spring 的声明式事务对所有的运行时异常进行回滚. 也可以通过对应的//属性进行设置. 通常情况下去默认值即可. //4.使用 readOnly 指定事务是否为只读. 表示这个事务只读取数据但不更新数据, //这样可以帮助数据库引擎优化事务. 若真的事一个只读取数据库值的方法, 应设置 readOnly=true//5.使用 timeout 指定强制回滚之前事务可以占用的时间. //@Transactional(propagation=Propagation.REQUIRES_NEW,//isolation=Isolation.READ_COMMITTED,//noRollbackFor={UserAccountException.class})@Transactional(propagation=Propagation.REQUIRES_NEW,isolation=Isolation.READ_COMMITTED,readOnly=false,timeout=3)@Overridepublic void purchase(String username, String isbn) {try {Thread.sleep(5000);} catch (InterruptedException e) {}//1. 获取书的单价int price = bookShopDao.findBookPriceByIsbn(isbn);//2. 更新数的库存bookShopDao.updateBookStock(isbn);//3. 更新用户余额bookShopDao.updateUserAccount(username, price);}}
public interface Cashier {public void checkout(String username, List<String> isbns);}
@Service("cashier")测试事务的传播属性public class CashierImpl implements Cashier {@Autowiredprivate BookShopService bookShopService;@Transactional@Overridepublic void checkout(String username, List<String> isbns) {for(String isbn: isbns){bookShopService.purchase(username, isbn);}}}
public class SpringTransactionTest {private ApplicationContext ctx = null;private BookShopDao bookShopDao = null;private BookShopService bookShopService = null;private Cashier cashier = null;{ctx = new ClassPathXmlApplicationContext("applicationContext.xml");bookShopDao = ctx.getBean(BookShopDao.class);bookShopService = ctx.getBean(BookShopService.class);cashier = ctx.getBean(Cashier.class);}@Testpublic void testTransactionlPropagation(){cashier.checkout("AA", Arrays.asList("1001", "1002"));}@Testpublic void testBookShopService(){bookShopService.purchase("AA", "1001");}@Testpublic void testBookShopDaoUpdateUserAccount(){bookShopDao.updateUserAccount("AA", 200);}@Testpublic void testBookShopDaoUpdateBookStock(){bookShopDao.updateBookStock("1001");}@Testpublic void testBookShopDaoFindPriceByIsbn() {System.out.println(bookShopDao.findBookPriceByIsbn("1001"));}}
基于XML配置的方式的事务管理
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:tx="/schema/tx"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/aop /schema/aop/spring-aop-4.0.xsd/schema/beans /schema/beans/spring-beans.xsd/schema/tx /schema/tx/spring-tx-4.0.xsd/schema/context /schema/context/spring-context-4.0.xsd"><context:component-scan base-package="com.atguigu.spring"></context:component-scan><!-- 导入资源文件 --><context:property-placeholder location="classpath:db.properties"/><!-- 配置 C3P0 数据源 --><bean id="dataSource"class="com.mchange.boPooledDataSource"><property name="user" value="${jdbc.user}"></property><property name="password" value="${jdbc.password}"></property><property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property><property name="driverClass" value="${jdbc.driverClass}"></property><property name="initialPoolSize" value="${jdbc.initPoolSize}"></property><property name="maxPoolSize" value="${jdbc.maxPoolSize}"></property></bean><!-- 配置 Spirng 的 JdbcTemplate --><bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"><property name="dataSource" ref="dataSource"></property></bean><!-- 配置 bean --><bean id="bookShopDao" class="com.atguigu.spring.tx.xml.BookShopDaoImpl"><property name="jdbcTemplate" ref="jdbcTemplate"></property></bean><bean id="bookShopService" class="com.atguigu.spring.tx.xml.service.impl.BookShopServiceImpl"><property name="bookShopDao" ref="bookShopDao"></property></bean><bean id="cashier" class="com.atguigu.spring.tx.xml.service.impl.CashierImpl"><property name="bookShopService" ref="bookShopService"></property></bean><!-- 1. 配置事务管理器 --><bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource" ref="dataSource"></property></bean><!-- 2. 配置事务属性 --><tx:advice id="txAdvice" transaction-manager="transactionManager"><tx:attributes><!-- 根据方法名指定事务的属性 --><tx:method name="purchase" propagation="REQUIRES_NEW"/><tx:method name="get*" read-only="true"/><tx:method name="find*" read-only="true"/><tx:method name="*"/></tx:attributes></tx:advice><!-- 3. 配置事务切入点, 以及把事务切入点和事务属性关联起来 --><aop:config><aop:pointcut expression="execution(* com.atguigu.spring.tx.xml.service.*.*(..))" id="txPointCut"/><aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/></aop:config></beans>
public interface BookShopDao {//根据书号获取书的单价public int findBookPriceByIsbn(String isbn);//更新数的库存. 使书号对应的库存 - 1public void updateBookStock(String isbn);//更新用户的账户余额: 使 username 的 balance - pricepublic void updateUserAccount(String username, int price);}
public class BookShopDaoImpl implements BookShopDao {private JdbcTemplate jdbcTemplate;public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {this.jdbcTemplate = jdbcTemplate;}@Overridepublic int findBookPriceByIsbn(String isbn) {String sql = "SELECT price FROM book WHERE isbn = ?";return jdbcTemplate.queryForObject(sql, Integer.class, isbn);}@Overridepublic void updateBookStock(String isbn) {//检查书的库存是否足够, 若不够, 则抛出异常String sql2 = "SELECT stock FROM book_stock WHERE isbn = ?";int stock = jdbcTemplate.queryForObject(sql2, Integer.class, isbn);if(stock == 0){throw new BookStockException("库存不足!");}String sql = "UPDATE book_stock SET stock = stock -1 WHERE isbn = ?";jdbcTemplate.update(sql, isbn);}@Overridepublic void updateUserAccount(String username, int price) {//验证余额是否足够, 若不足, 则抛出异常String sql2 = "SELECT balance FROM account WHERE username = ?";int balance = jdbcTemplate.queryForObject(sql2, Integer.class, username);if(balance < price){throw new UserAccountException("余额不足!");}String sql = "UPDATE account SET balance = balance - ? WHERE username = ?";jdbcTemplate.update(sql, price, username);}}
public interface BookShopService {public void purchase(String username, String isbn);}
public class BookShopServiceImpl implements BookShopService {private BookShopDao bookShopDao;public void setBookShopDao(BookShopDao bookShopDao) {this.bookShopDao = bookShopDao;}@Overridepublic void purchase(String username, String isbn) {try {Thread.sleep(1000);} catch (InterruptedException e) {}//1. 获取书的单价int price = bookShopDao.findBookPriceByIsbn(isbn);//2. 更新数的库存bookShopDao.updateBookStock(isbn);//3. 更新用户余额bookShopDao.updateUserAccount(username, price);}}
public interface Cashier {public void checkout(String username, List<String> isbns);}
public class CashierImpl implements Cashier {private BookShopService bookShopService;public void setBookShopService(BookShopService bookShopService) {this.bookShopService = bookShopService;}@Overridepublic void checkout(String username, List<String> isbns) {for(String isbn: isbns){bookShopService.purchase(username, isbn);}}}
public class SpringTransactionTest {private ApplicationContext ctx = null;private BookShopDao bookShopDao = null;private BookShopService bookShopService = null;private Cashier cashier = null;{ctx = new ClassPathXmlApplicationContext("applicationContext-tx-xml.xml");bookShopDao = ctx.getBean(BookShopDao.class);bookShopService = ctx.getBean(BookShopService.class);cashier = ctx.getBean(Cashier.class);}@Testpublic void testTransactionlPropagation(){cashier.checkout("AA", Arrays.asList("1001", "1002"));}@Testpublic void testBookShopService(){bookShopService.purchase("AA", "1001");}}
jdbc.user=rootjdbc.password=1230jdbc.driverClass=com.mysql.jdbc.Driverjdbc.jdbcUrl=jdbc:mysql:///springjdbc.initPoolSize=5jdbc.maxPoolSize=10
Spring：JDBCTemplate和声明式事务管理（事务的传播属性 隔离级别 回滚属性 超时和只读 两种声明方式）
