Spring 学习（二十三）——声明式事务

事务简介

•事务管理是企业级应用程序开发中必不可少的技术, 用来确保数据的完整性和一致性.

•事务就是一系列的动作, 它们被当做一个单独的工作单元. 这些动作要么全部完成, 要么全部不起作用

•事务的四个关键属性(ACID)

–原子性(atomicity): 事务是一个原子操作, 由一系列动作组成. 事务的原子性确保动作要么全部完成要么完全不起作用.

–一致性(consistency): 一旦所有事务动作完成, 事务就被提交. 数据和资源就处于一种满足业务规则的一致性状态中.

–隔离性(isolation): 可能有许多事务会同时处理相同的数据, 因此每个事物都应该与其他事务隔离开来, 防止数据损坏.

–持久性(durability): 一旦事务完成, 无论发生什么系统错误, 它的结果都不应该受到影响. 通常情况下, 事务的结果被写到持久化存储器中.

事务管理的问题

•问题:

–必须为不同的方法重写类似的样板代码

–这段代码是特定于 JDBC 的, 一旦选择类其它数据库存取技术, 代码需要作出相应的修改

Spring 中的事务管理

•作为企业级应用程序框架, Spring 在不同的事务管理 API 之上定义了一个抽象层. 而应用程序开发人员不必了解底层的事务管理 API, 就可以使用 Spring 的事务管理机制.

•Spring 既支持编程式事务管理, 也支持声明式的事务管理.

•编程式事务管理: 将事务管理代码嵌入到业务方法中来控制事务的提交和回滚. 在编程式管理事务时, 必须在每个事务操作中包含额外的事务管理代码.

•声明式事务管理: 大多数情况下比编程式事务管理更好用. 它将事务管理代码从业务方法中分离出来, 以声明的方式来实现事务管理. 事务管理作为一种横切关注点, 可以通过 AOP 方法模块化. Spring 通过 Spring AOP 框架支持声明式事务管理.

•Spring 从不同的事务管理 API 中抽象了一整套的事务机制. 开发人员不必了解底层的事务 API, 就可以利用这些事务机制. 有了这些事务机制, 事务管理代码就能独立于特定的事务技术了.

•Spring 的核心事务管理抽象是它为事务管理封装了一组独立于技术的方法. 无论使用 Spring 的哪种事务管理策略(编程式或声明式), 事务管理器都是必须的.

Spring 中的事务管理器的不同实现

需求

数据表中的数据

用事务通知声明式地管理事务

•事务管理是一种横切关注点

•为了在 Spring 2.x 中启用声明式事务管理, 可以通过 tx Schema 中定义的 <tx:advice> 元素声明事务通知, 为此必须事先将这个 Schema 定义添加到 <beans> 根元素中去.

•声明了事务通知后, 就需要将它与切入点关联起来. 由于事务通知是在 <aop:config> 元素外部声明的, 所以它无法直接与切入点产生关联. 所以必须在 <aop:config> 元素中声明一个增强器通知与切入点关联起来.

•由于 Spring AOP 是基于代理的方法, 所以只能增强公共方法. 因此, 只有公有方法才能通过 Spring AOP 进行事务管理.

用事务通知声明式地管理事务示例代码

用 @Transactional 注解声明式地管理事务

•除了在带有切入点, 通知和增强器的 Bean 配置文件中声明事务外, Spring 还允许简单地用 @Transactional 注解来标注事务方法.

•为了将方法定义为支持事务处理的, 可以为方法添加 @Transactional 注解. 根据 Spring AOP 基于代理机制, 只能标注公有方法.

•可以在方法或者类级别上添加 @Transactional 注解. 当把这个注解应用到类上时, 这个类中的所有公共方法都会被定义成支持事务处理的.

•在 Bean 配置文件中只需要启用 <tx:annotation-driven> 元素, 并为之指定事务管理器就可以了.

•如果事务处理器的名称是 transactionManager, 就可以在<tx:annotation-driven> 元素中省略 transaction-manager 属性. 这个元素会自动检测该名称的事务处理器.

用 @Transactional 注解声明式地管理事务配置文件示例代码

代码示例：

1、数据库表的建立如下：

employee表

department表

2、目录结构

Spring
|——src
|——|——com.hzyc.spring.jdbc
|——|——|——employee.java
|——|——|——JdbcTest.java
|——|——application-context.xml
|——|——db.properties

2、db.properties

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

jdbc.initPoolSize=5
jdbc.maxPoolSize=10

3、application-context.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
	   http://www.springframework.org/schema/context
	   http://www.springframework.org/schema/context/spring-context-4.0.xsd
	   http://www.springframework.org/schema/tx
	   http://www.springframework.org/schema/tx/spring-tx.xsd">

    <context:component-scan base-package="com.hzyc.spring"/>

    <!--导入资源文件-->
    <context:property-placeholder location="classpath:db.properties"/>

    <!--配置 c3p0 数据源-->
    <bean id="dataSource"
          class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driverClass}"/>
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}"/>
        <property name="user" value="${jdbc.user}"/>
        <property name="password" value="${jdbc.password}"/>

        <property name="initialPoolSize" value="${jdbc.initPoolSize}"/>
        <property name="maxPoolSize" value="${jdbc.maxPoolSize}"/>
    </bean>

    <!--配置 Spring 的 Jdbc Template-->
    <bean id="jdbcTemplate"
          class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--
        配置 NamedParameterJdbcTemplate, 该对象可以使用具名参数（具有名字）
        其没有无参的构造器，必须为其构造器指定参数
    -->
    <bean id="namedParameterJdbcTemplate"
          class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
        <constructor-arg ref="dataSource"/>
    </bean>

    <!--配置事务管理器-->
    <bean id="transactionManager"
          class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--事务注解-->
    <tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

bookShopDao.java

package com.hzyc.spring.jdbc.transaction;

/**
 * @author xuehj2016
 * @Title: BookShopDao
 * @ProjectName Spring
 * @Description: TODO
 * @date 2018/12/21 20:32
 */
public interface BookShopDao {
    /**
     * 根据书号获取书的单价
     */
    public int getBookPriceById(String id);

    /**
     * 更新书的库存，使书号对应的库存 - 1
     */
    public void updateBookStock(String id);

    /**
     * 更新用户的账户余额 : 使 username 的 balance - price
     */
    public void updateUserAccount(String username, int price);
}

BookShopDaoImpl.java

package com.hzyc.spring.jdbc.transaction;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

/**
 * @author xuehj2016
 * @Title: BookShopDaoImpl
 * @ProjectName Spring
 * @Description: TODO
 * @date 2018/12/21 20:39
 */
@Repository("bookShopDao")
public class BookShopDaoImpl implements BookShopDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    /**
     * 根据书号获取书的单价
     *
     * @param id
     */
    @Override
    public int getBookPriceById(String id) {
        String sql = "select price from book where id = ?";
        return jdbcTemplate.queryForObject(sql, Integer.class, id);
    }

    /**
     * 更新书的库存，使书号对应的库存 - 1
     *
     * @param id
     */
    @Override
    public void updateBookStock(String id) {
        //检查书的库存是否足够，若不够，则抛出异常
        String stockSql = "select stock from book_stock where id =?";
        int stock = jdbcTemplate.queryForObject(stockSql, Integer.class, id);
        if (stock == 0) {
            throw new BookStockException("库存不足！");
        }

        String sql = "update book_stock set stock = stock - 1 where id =?";
        jdbcTemplate.update(sql, id);
    }

    /**
     * 更新用户的账户余额 : 使 username 的 balance - price
     *
     * @param username
     * @param price
     */
    @Override
    public void updateUserAccount(String username, int price) {
        //因为 MySQL 不支持检查约束
        //验证用户的余额是否足够，若不够，则抛出异常
        String balanceSql = "select balance from account where username =?";
        int balance = jdbcTemplate.queryForObject(balanceSql, Integer.class, username);
        if (balance < price) {
            throw new UserAccountException("余额不足！");
        }

        String sql = "update account set balance = balance - ? where username =?";
        jdbcTemplate.update(sql, price, username);
    }
}

bookshopservice.java

package com.hzyc.spring.jdbc.transaction;

/**
 * @author xuehj2016
 * @Title: BookShopService
 * @ProjectName Spring
 * @Description: TODO
 * @date 2018/12/21 21:22
 */
public interface BookShopService {

    public void purchase(String username, String id);

}

BookShopServiceImpl.java

package com.hzyc.spring.jdbc.transaction;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
 * @author xuehj2016
 * @Title: BookShopServiceImpl
 * @ProjectName Spring-3
 * @Description: TODO
 * @date 2018/12/21 21:24
 */
@Service("bookShopService")
public class BookShopServiceImpl implements BookShopService {

    @Autowired
    private BookShopDao bookShopDao;

    /**
     * 添加事务注解
     *
     * @param username
     * @param id
     */
    @Transactional
    @Override
    public void purchase(String username, String id) {

        //1.获取书的单价
        int price = bookShopDao.getBookPriceById(id);

        //2.更新书的库存
        bookShopDao.updateBookStock(id);

        //3.更新用户余额
        bookShopDao.updateUserAccount(username, price);
    }
}

BookStockException.java

package com.hzyc.spring.jdbc.transaction;

/**
 * @author xuehj2016
 * @Title: BookStockException
 * @ProjectName Spring
 * @Description: TODO
 * @date 2018/12/21 21:10
 */
public class BookStockException extends RuntimeException {

    public BookStockException() {
    }

    public BookStockException(String message) {
        super(message);
    }

    public BookStockException(String message, Throwable cause) {
        super(message, cause);
    }

    public BookStockException(Throwable cause) {
        super(cause);
    }

    public BookStockException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}

useraccountException.java

package com.hzyc.spring.jdbc.transaction;

/**
 * @author xuehj2016
 * @Title: UserAccountException
 * @ProjectName Spring
 * @Description: TODO
 * @date 2018/12/21 21:16
 */
public class UserAccountException extends RuntimeException {

    public UserAccountException() {
    }

    public UserAccountException(String message) {
        super(message);
    }

    public UserAccountException(String message, Throwable cause) {
        super(message, cause);
    }

    public UserAccountException(Throwable cause) {
        super(cause);
    }

    public UserAccountException(String message, Throwable cause, boolean enableSuppression, boolean
            writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}

springTransactionTest.java

package com.hzyc.spring.jdbc.transaction;

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

/**
 * @author xuehj2016
 * @Title: SpringTransactionTest
 * @ProjectName Spring
 * @Description: TODO
 * @date 2018/12/21 20:52
 */
public class SpringTransactionTest {
    private BookShopDao bookShopDao;
    private BookShopService bookShopService;

    {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application-context.xml");
        bookShopDao = (BookShopDao) applicationContext.getBean("bookShopDao");
        bookShopService = (BookShopService) applicationContext.getBean("bookShopService");
    }

    @Test
    public void testBookShopGetBookPriceById() {
        System.out.println(bookShopDao.getBookPriceById("1001"));
    }

    @Test
    public void testBookShopUpdateBookStock() {
        bookShopDao.updateBookStock("1001");
    }

    @Test
    public void testBookShopUpdateUserAccount() {
        bookShopDao.updateUserAccount("xuehj", 50);
    }

    @Test
    public void testBookShopService() {
        bookShopService.purchase("xuehj","1001");
    }

}

Spring 学习（二十三）——声明式事务

猜你喜欢