Spring：JDBCTemplate和声明式事务管理（事务的传播属性、隔离级别、回滚属性、超时和只读、两种声明方式）

最新推荐文章于 2023-12-26 22:30:46 发布
最新推荐文章于 2023-12-26 22:30:46 发布
阅读量983 收藏
点赞数
分类专栏： Spring JavaEE
JavaEE 同时被 2 个专栏收录
247 篇文章 1 订阅
订阅专栏
Spring
79 篇文章 1 订阅
订阅专栏

<!-- 配置 C3P0 数据源 -->
<bean id="dataSource"
class="com.mchange.v2.c3p0.ComboPooledDataSource">
<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@sina.com");
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@atguigu.com");
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@atguigu.com", 1});
batchArgs.add(new Object[]{"BB", "bb@atguigu.com", 2});
batchArgs.add(new Object[]{"CC", "cc@atguigu.com", 3});
batchArgs.add(new Object[]{"DD", "dd@atguigu.com", 3});
batchArgs.add(new Object[]{"EE", "ee@atguigu.com", 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="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:tx="http://www.springframework.org/schema/tx" 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/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/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.v2.c3p0.ComboPooledDataSource">
        <!-- 基本的连接信息 -->
        <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="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/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.v2.c3p0.ComboPooledDataSource">
		<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);
	
	//更新数的库存. 使书号对应的库存 - 1
	public void updateBookStock(String isbn);
	
	//更新用户的账户余额: 使 username 的 balance - price
	public void updateUserAccount(String username, int price);
}

@Repository("bookShopDao")
public class BookShopDaoImpl implements BookShopDao {

	@Autowired
	private JdbcTemplate jdbcTemplate;
	
	@Override
	public int findBookPriceByIsbn(String isbn) {
		String sql = "SELECT price FROM book WHERE isbn = ?";
		return jdbcTemplate.queryForObject(sql, Integer.class, isbn);
	}

	@Override
	public 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);
	}

	@Override
	public 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 {

	@Autowired
	private 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)
	@Override
	public 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 {

	@Autowired
	private BookShopService bookShopService;
	
	@Transactional
	@Override
	public 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);
	}
	
	@Test
	public void testTransactionlPropagation(){
		cashier.checkout("AA", Arrays.asList("1001", "1002"));
	}
	
	@Test
	public void testBookShopService(){
		bookShopService.purchase("AA", "1001");
	}
	
	@Test
	public void testBookShopDaoUpdateUserAccount(){
		bookShopDao.updateUserAccount("AA", 200);
	}
	
	@Test
	public void testBookShopDaoUpdateBookStock(){
		bookShopDao.updateBookStock("1001");
	}
	
	@Test
	public void testBookShopDaoFindPriceByIsbn() {
		System.out.println(bookShopDao.findBookPriceByIsbn("1001"));
	}

}


基于XML配置的方式的事务管理 

<?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:tx="http://www.springframework.org/schema/tx"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/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.v2.c3p0.ComboPooledDataSource">
		<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);
	
	//更新数的库存. 使书号对应的库存 - 1
	public void updateBookStock(String isbn);
	
	//更新用户的账户余额: 使 username 的 balance - price
	public void updateUserAccount(String username, int price);
}

public class BookShopDaoImpl implements BookShopDao {

	private JdbcTemplate jdbcTemplate;
	
	public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
		this.jdbcTemplate = jdbcTemplate;
	}
	
	@Override
	public int findBookPriceByIsbn(String isbn) {
		String sql = "SELECT price FROM book WHERE isbn = ?";
		return jdbcTemplate.queryForObject(sql, Integer.class, isbn);
	}

	@Override
	public 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);
	}

	@Override
	public 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;
	}
	
	@Override
	public 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;
	}
	
	@Override
	public 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);
	}
	
	@Test
	public void testTransactionlPropagation(){
		cashier.checkout("AA", Arrays.asList("1001", "1002"));
	}
	
	@Test
	public void testBookShopService(){
		bookShopService.purchase("AA", "1001");
	}
	
}


jdbc.user=root
jdbc.password=1230
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.jdbcUrl=jdbc:mysql:///spring

jdbc.initPoolSize=5
jdbc.maxPoolSize=10
恒奇恒毅
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 数据库操作，事务回滚
04-06
java 应用程序操作数据库实例，若出现sql异常则事务回滚。
深入理解Spring声明式事务：源码分析与应用实践
12-13
在类或方法上添加`@Transactional`注解，可以指定事务的传播行为、隔离级别、超时和回滚规则等属性。例如，`rollbackFor = Exception.class`表示只要发生异常，事务就应该回滚。Spring会创建一个代理对象来包裹被...
Spring练习：JDBC模板和事务回滚
fhx308050的博客
03-06 1138
SSH框架是每个学生毕业前都必须掌握的一门技术，所以这里就用Spring的JDBC模板和自定义异常让事务回滚来做一个练习。主要用到的是spring和struts2框架来操作，这里暂时没用Hibernate来对数据进行操作。 一、练习要求。 要求写一个用户购买股票的项目，用户先开户后登陆，可以在里面买股票和卖股票，当买股票金额超过用户金额时就报异常让事务回滚，用户卖出股票时超过持有数量报异常让事
Spring系列：基于Spring-Jdbc实现事务
最新发布
程序人生
12-26 252
数据库事务( transaction)是访问并可能操作各种数据项的一个数据库操作序列，这些操作要么全部执行,要么全部不执行，是一个不可分割的工作单位。事务由事务开始与事务结束之间执行的全部数据库操作组成。
mysql jdbc事务隔离级别_MySQL事务的四种隔离级别
weixin_31630667的博客
01-27 118
事务的基本要素:原子性(atomicity):事务开始后的全部操作, 要么全部执行成功,如果中间出现错误,事务回滚到事务开始前的状态.一致性(Consistency):事务开始后,数据库的完整性约束没有被破坏.例如:A向B转账,A扣除了金额,B却没收到隔离性(Isolation):同一时间,只允许一个事务请求同一数据,不同事务之间没有彼此没有干扰.持久性(Durability):事务完成后,事务对...
JdbcTemplate 手动开启/提交/回滚事务
热门推荐
【欢迎关注公众号：冬瓜白】
03-09 1万+
源码地址：https://github.com/dongguabai/thinkingTest/tree/master/jdbcTemplateDemo 配置类： package demo.dongguabai.tx.dongguabaidtx.config; import org.springframework.context.annotation.Bean; import org.sp...
spring 声明式事务实现过程解析
08-25
Spring 声明式事务实现过程解析 Spring 声明式事务实现过程解析是指使用Spring框架提供的声明式事务...Spring 声明式事务实现过程解析提供了一种灵活、可靠的方式来管理事务，使得开发者可以更方便地实现事务管理。
Spring注解 TX声明式事务实现过程解析
08-19
本文将详细介绍 Spring 注解 TX 声明式事务实现过程，通过示例代码和详细的分析，向读者展示如何使用 Spring 注解实现声明式事务。首先，让我们从环境搭建开始。 环境搭建 要使用 Spring 注解实现声明式事务，需要...
Spring JdbcTemplate&声明式事务1
08-04
在本篇中，我们将深入探讨JdbcTemplate的基本使用和声明式事务管理。 ### JdbcTemplate基本使用 **1. 引入依赖** 首先，我们需要在项目中引入Spring JDBC和Spring事务管理的相关依赖。在Maven项目中，这通常通过...
day4-Spring JdbcTemplate & 声明式事务.md
10-15
声明式事务管理是Spring框架中一种非常重要的特性，它允许开发者通过XML配置或注解的方式来管理事务。相比于编程式事务管理，这种方式更加简洁、易于维护。 - **使用XML配置**：在Spring配置文件中定义事务管理器，...
Spring(day04)jdbcTemplate的使用、spring的事务控制（事务特性、隔离级别）
Valentino112358的博客
08-14 263
一、今日目标 1、jdbcTemplate的使用 2、spring的事务控制 3、了解spring5的新特性 持久层中程序： package com.itheima.dao.impl; import com.itheima.dao.AccountDao; import com.itheima.domain.Account; import com.itheima.utils.Con...
spring框架:JdbcTemplate,声明式事务管理(传播行为,隔离级别,回滚,超时和只读属性)
入梦镜
04-28 882
JdbcTemplate
jdbc批量新增数据带事务回滚
on_the_stree的博客
04-06 495
jdbc批量新增数据 @Transactional(rollbackFor=RuntimeException.class) public int synDataSource() { //先删除数据源 String delSql = "delete from data_source"; jdbcTemplate.update(delSql); Map<String, Object> map = dbService
Day70.JDBCTemplate、声明式事务基于注解、隔离级别、传播行为、回滚类型、Spring5新特性
a111042555的博客
05-28 882
AOP - Transactional
学习JdbcTemplate中使用的回调机制
weixin_33829657的博客
09-09 173
2019独角兽企业重金招聘Python工程师标准>>> ...
JDBCTemplate和JDBC
Sterlingfox的博客
05-16 356
  JDBCTemplate和JDBC。 package com.ptteng; import java.sql.*; public class Jdbc {    public static void main(String[] args)    {        String driver="com.mysql.jdbc.Driver";        String url="jdb...
Spring jdbcTemplate之决不回滚解决方案
忧伤的可乐鸡
05-12 3513
最近在学习spring，用到这个jdbcTemplate时发现他怎么都不回滚，就算用spring最开始的侵入式回滚都不好使，我蒙蔽了，一会弄明白了一定要写出来和大家分享，这个人性的jdbcTemplate
JDBCTemplate 事务控制
qq_37962402的博客
11-03 963
**项目场景：**批量导入，前端解析Excel数据，然后批量传入到后端，后端根据数据进行解析，然后在表和关联表进行操作。当对一行数据操作时，如果有错误信息则捕获异常，则不插入该条信息，继续走下。Excel单行数据出错时，要进行回滚，不仅要在单表中回滚，还要在关联表中回滚。 问题： 如何控制事务？如果单表插入数据成功，关联表失败，如果把该单表的数据也回滚，还不能保证前面已经执行完的数据再回滚。 解决： 项目使用的是JDBCTemplate，因为不要抛异常，所以使用try-catch捕获异常 代码： try
【Spring】模板JdbcTemplate + 事务管理
qq_40265247的博客
05-20 745
文章目录配置常用方法事务管理1.自动注解方式配置Bean2 xml配置配置文件方式 之前我们也有接触Jdbc，进而让我们可以对数据库执行增删改查。而在Spring中，给我们提供了JdbcTemplate，从而使代码开销更小。 配置 1.Mavan的pom.xml中配置jar包 <!--Jdbc模板--> <dependency> <groupId>org.springframework</groupId> <artifactI
Spring事务管理：统一编程模型与声明式事务
Spring的事务管理分为编程式事务管理和声明式事务管理，这两种方式都基于其事务管理框架的设计理念，即分离事务管理的关注点与数据访问关注点。 1. 统一中原的过程：Spring事务框架通过提供统一的编程模型，使得...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值