Spring学习笔记----事务管理

时间：2021-02-19 18:00:54

Spring声明事务

了解spring使用事务之前，首先让我们看看如何手动写一个事务

需求：一个book shop的管理实现

dataSource.properties (数据源信息)

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

jdbc.initPoolSize=5
jdbc.maxPoolSize=10

applicationContext.xml (Spring的配置文件) 

<?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"
       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.xsd">
    <!--自动扫描-->
    <context:component-scan base-package="cn.limbo.spring"></context:component-scan>
    <!--导入资源文件-->
    <context:property-placeholder location="dataSource.properties"></context:property-placeholder>
    <!--配置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>
    <!--配置Spring的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>
</beans>
BookShopDao.java  (书店数据库操作接口) 

package cn.limbo.spring.tx;

/**
 * Created by Limbo on 16/7/15.
 */
public interface BookShopDao {
    //根据书号获取书的单价
    public int findBookPriceByIsbn(int isbn);

    //更新书的库存,是书号对应的库存 - 1
    public void updateBookStock(int isbn);

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

BookShopDaoImpl.java (书店数据库操作实现) 

package cn.limbo.spring.tx;

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

/**
 * Created by Limbo on 16/7/15.
 */
@Repository("bookShopDao")
public class BookShopDaoImpl implements BookShopDao{

    @Autowired
    private JdbcTemplate jdbcTemplate;


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

    }

    @Override
    public void updateBookStock(int 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);
    }
}

BookShopService.java (书店服务接口) 

package cn.limbo.spring.tx;

/**
 * Created by Limbo on 16/7/15.
 */
public interface BookShopService {
    public void purchase(String userName,int price);
}
BookShopServiceImpl.java (书店服务实现) 

package cn.limbo.spring.tx;

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

/**
 * Created by Limbo on 16/7/15.
 */
@Service("bookShopService")
public class BookShopServiceImpl implements BookShopService{

    @Autowired
    private BookShopDao bookShopDao;

    @Override
    public void purchase(String userName, int isbn) {
        //1.获取书的单价
        int price = bookShopDao.findBookPriceByIsbn(isbn);
        //2.更新库存
        bookShopDao.updateBookStock(isbn);
        //3.更新用户余额
        bookShopDao.updateUserAccount(userName,price);
    }
}

BookStockException.java  (书库存异常) 

package cn.limbo.spring.tx;

/**
 * Created by Limbo on 16/7/15.
 */
public class BookStockException extends RuntimeException {
    public BookStockException() {
        super();
    }

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

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

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

    protected BookStockException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}
UserAccountException.java (用户余额异常) 

package cn.limbo.spring.tx;

/**
 * Created by Limbo on 16/7/15.
 */
public class UserAccountException extends RuntimeException {
    public UserAccountException() {
        super();
    }

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

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

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

    protected UserAccountException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}
SpringTransactionTest.java  (测试方法) 

package cn.limbo.spring.tx;

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

/**
 * Created by Limbo on 16/7/15.
 */
public class SpringTransactionTest {

    private static ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    private static BookShopDao bookShopDao = (BookShopDao) ctx.getBean("bookShopDao");
    private static BookShopService bookShopService = (BookShopService) ctx.getBean("bookShopService");
    public static void testBookShopDaoFindPriceByIsbn(int isbn)
    {
        System.out.println(bookShopDao.findBookPriceByIsbn(isbn));
    }

    public static void testBookShopDaoUpdateStock(int isbn)
    {
        bookShopDao.updateBookStock(isbn);
    }

    public static void testBookShopUpdateUserAccount(String name,int price)
    {
        bookShopDao.updateUserAccount(name,price);
    }

    public static void testBookShopService(String userName,int isbn)
    {
        bookShopService.purchase(userName,isbn);
    }

    public static void main(String[] args) {
        testBookShopService("AA",1001);
    }
}

上面的testBookShopService这个方法是我们执行事务的方法，但是我们可以发现，这个方法并不满足事务的ACID原则，如果余额不足的情况下，书的储藏数量还是会减少，这时候我们就该用上spring的事务管理器了

为applicationContext.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.xsd http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!--自动扫描-->
    <context:component-scan base-package="cn.limbo.spring"></context:component-scan>
    <!--导入资源文件-->
    <context:property-placeholder location="dataSource.properties"></context:property-placeholder>
    <!--配置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>
    <!--配置Spring的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>

注意，tx的命名空间不要导错了，刚开始我就是导错了然后没有出现transaction-manager这玩意，搞得我烦死了

然后在实现事务的方法上加上@Transactional注解就好了，重写后的BookShopServiceImpl.java如下

package cn.limbo.spring.tx;

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

/**
 * Created by Limbo on 16/7/15.
 */
@Service("bookShopService")
public class BookShopServiceImpl implements BookShopService{

    @Autowired
    private BookShopDao bookShopDao;

    @Transactional    //添加事务注解
    @Override
    public void purchase(String userName, int isbn) {
        //1.获取书的单价
        int price = bookShopDao.findBookPriceByIsbn(isbn);
        //2.更新库存
        bookShopDao.updateBookStock(isbn);
        //3.更新用户余额
        bookShopDao.updateUserAccount(userName,price);
    }
}
至此，我们就实现了Spring声明式事务的方法

事务的传播行为

       指事务方法调用另外一个事务方法时，表现出的属性。打个比方，你去饭店吃饭，遇到熟人，然后熟人招呼你吃饭，这个时候你有两个选择，你可以选择和熟人一起吃，也可以自己吃。在上述的表述中，新事务就是我，旧事务是熟人，和熟人一起吃饭就是沿用原先事务，自己吃饭就是创建新的事务，下面看代码        新建一个接口和一个类 Cashier.java 
package cn.limbo.spring.tx;

import java.util.List;

/**
 * Created by Limbo on 16/7/16.
 */
public interface Cashier {
    public void checkOut(String userName,List<Integer> isbns);
}
CashierImpl.java 
package cn.limbo.spring.tx;

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

import java.util.List;

/**
 * Created by Limbo on 16/7/16.
 */

@Service("cashier")
public class CashierImpl implements Cashier{

    @Autowired
    private BookShopService bookShopService;

    @Transactional
    @Override
    //现在,我们要买一堆书
    public void checkOut(String userName, List<Integer> isbns) {
        for(Integer isbn : isbns)
        {
            bookShopService.purchase(userName,isbn);
        }
    }
}
Test.java
public static void testTransactionalPropagation(String userName, List<Integer> isbns)
    {
        cashier.checkOut(userName,isbns);
    }

    public static void main(String[] args) {
        testTransactionalPropagation("AA", Arrays.asList(1001,1002));
    }


这时候，我们发现bookShopService.purchase是一个事务，但是checkOut也是一个事务，这时候执行会有什么样的结果呢（此时bookShopService.purchase()还是和上面一样）？ 此时，我们发现，在余额足够买1001但是无法买1002时，事务会自动回滚，回滚到两本书都不买的情况，因为这个时候checkOut使用的是原先的事务，没有任何变化，如果我们要实现在余额只够买1001但是不够买1002时仍然可以买1001的话，只要把bookShopService.purchase上的@Transactional改成@Transactional(propagation = Propagation.REQUIRES_NEW)即可，修改后的booShopService.java如下 
package cn.limbo.spring.tx;

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

/**
 * Created by Limbo on 16/7/15.
 */
@Service("bookShopService")
public class BookShopServiceImpl implements BookShopService{

    @Autowired
    private BookShopDao bookShopDao;

    //添加事务注解
    //使用propagation指定事务的传播行为,即当前的事务方法被另外一个事务方法调用的时候
    //如何使用事务,默认取值为REQUIRED,即使用调用方法的事务
    //还有一个取值是REQUIRES_NEW:新建一个自己的事务,调用的事务方法被挂起
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    @Override
    public void purchase(String userName, int isbn) {
        //1.获取书的单价
        int price = bookShopDao.findBookPriceByIsbn(isbn);
        //2.更新库存
        bookShopDao.updateBookStock(isbn);
        //3.更新用户余额
        bookShopDao.updateUserAccount(userName,price);
    }
}
附上propagation所有的属性： PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。  PROPAGATION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。 
PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。  
PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。 
PROPAGATION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。  前两个最为常用

事务的隔离，回滚，只读，过期

 一言不合，直接贴代码，要点写注释上咯 
package cn.limbo.spring.tx;

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

/**
 * Created by Limbo on 16/7/15.
 */
@Service("bookShopService")
public class BookShopServiceImpl implements BookShopService{

    @Autowired
    private BookShopDao bookShopDao;

    //添加事务注解
    //1.使用propagation指定事务的传播行为,即当前的事务方法被另外一个事务方法调用的时候
    //  如何使用事务,默认取值为REQUIRED,即使用调用方法的事务
    //  还有一个取值是REQUIRES_NEW:新建一个自己的事务,调用的事务方法被挂起
    //2.使用isolation指定事务的隔离级别,最常用的是Isolation.READ_COMMITTED
    //3.默认情况下,Spring的声明式事务对所有的运行时异常进行回滚,也可以通过对应的属性进行设置
    //  通常情况下,取默认值即可
    //  noRollbackFor = {UserAccountException.class}指的是对事务发生这一类的异常时,不要回滚了,继续执行
    //4.使用readOnly指定事务是否为只读,表示这个事务只读取数据但不更新数据,这样可以帮助数据库优化事务
    //  若真的是一个只读取数据库的值的方法,应该设置readOnly=true, 默认值为false,表示可读写
    //5.使用timeout指定强制回滚之前事务可以占用的时间,如果指定timeout=3,则事务执行3秒后强制回滚,不管是否执行成功
//    @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) //timeout的单位是秒
    @Override
    public void purchase(String userName, int isbn) {
        //1.获取书的单价
        int price = bookShopDao.findBookPriceByIsbn(isbn);
        //2.更新库存
        bookShopDao.updateBookStock(isbn);
        //3.更新用户余额
        bookShopDao.updateUserAccount(userName,price);
    }
}

事务的xml配置方法

1.配置普通的 controller,service ,dao 的bean.
<!-- 配置 dao ,service -->
    <bean id="bookShopDao" class="com.liujl.spring.tx.xml.BookShopDaoImpl">
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>
    </bean>

    <bean id="bookShopService" class="com.liujl.spring.tx.xml.serivice.impl.BookShopServiceImpl">
        <property name="bookShopDao" ref="bookShopDao"></property>
    </bean>

    <bean id="cashier" class="com.liujl.spring.tx.xml.serivice.impl.CashierImpl">
        <property name="bookShopService" ref="bookShopService"></property>
    </bean>
2.配置事务管理器bean
<!-- 配置事务管理器 hibernate、jpa都是类似的这样配 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
3.引入 tx 命名空间
xmlns:tx="http://www.springframework.org/schema/tx"
4.配置事务各个属性(方法名可以使用通配符*)
<!-- 配置事务属性 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="purchase" propagation="REQUIRED"/>
            <tx:method name="checkout" propagation="REQUIRED"/>
            <tx:method name="get*" read-only="true"/>            
            <tx:method name="find*" read-only="true"/>            
        </tx:attributes>
    </tx:advice>
5.引入aop命名空间
xmlns:aop="http://www.springframework.org/schema/aop"
<!-- 配置事务的切点,并把事务切点和事务属性不关联起来 -->    <aop:config>        <aop:pointcut expression="execution(* com.liujl.spring.tx.xml.serivice.*.*(..))" id="txPointCut"/>        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>    </aop:config>



标签：

相关文章