2020-03-02 20:17 同济大学 Java

关注

4 Spring中的事务管理

1 Spring中的事务管理

事务就是一系列的动作，它们被当做一个单独的工作单元，这些动作要么全部完成，要么全部不起作用。
Spring在不同的事物管理API之上定义了一个抽象层。应用程序开发人员不必了解底层的事物管理API，就可以使用Spring的事物管理机制。
Spring既支持编程式事务管理，也支持声明式事务管理。
编程式事务管理：将事务管理代码嵌入到业务中来控制事务的提交和回滚。
声明式事务管理：将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。
事务管理作为一种横切关注点，可以通过AOP方法模块化。
Spring通过Spring AOP框架支持声明式事务管理。
事务管理器以普通的Bean形式声明在Spring IOC容器中。

2 使用案例

数据库表：

create table book (
    isbn varchar(50) primary key,
    book_name varchar(100),
    price int
);

create table book_stock(
    isbn varchar(50) primary key,
    stock int,
    check(stock>0)
);

create table account(
    username varchar(50) primary key,
    balance int,
    check(balance > 0)
);

INSERT INTO `spring_test`.`book_stock` (`isbn`, `stock`) VALUES ('1001', '10');
INSERT INTO `spring_test`.`book_stock` (`isbn`, `stock`) VALUES ('1002', '10');
INSERT INTO `spring_test`.`book` (`isbn`, `book_name`, `price`) VALUES ('1001', '《Java从入门到放弃》', '100');
INSERT INTO `spring_test`.`book` (`isbn`, `book_name`, `price`) VALUES ('1002', '《活着》', '70');
INSERT INTO `spring_test`.`account` (`username`, `balance`) VALUES ('Tom', '300');

图片说明

db.properties：

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_test?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
jdbc.username=root
jdbc.password=root

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
                           https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!-- 注解扫描 -->
    <context:component-scan base-package="com.xianhuii"></context:component-scan>

    <!-- 引入外部化的配置文件 -->
    <context:property-placeholder location="classpath:db.properties"/>
    <!-- 配置数据源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
        <property name="user" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>

    <!-- 配置jdbcTemplate -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!-- 注入数据源 -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

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

    <!-- 基于注解使用事务，需要开启事务注解 -->
    <tx:annotation-driven transaction-manager="dataSourceTransactionManager"/>

</beans>

BookShopDao：

package com.xianhuii.dao;

public interface BookShopDao {
    // 1、根据书号获取对应的价格
    public int findBookPriceByIsbn(String isbn);

    // 2、根据书号更新库存
    public void updateBookStock(String isbn);

    // 3、根据书的价格更新用户的余额
    public void updateUserAccount(String username, int price);

}

BookShopDaoImpl：

package com.xianhuii.dao;

import com.xianhuii.exception.BookStockException;
import com.xianhuii.exception.UserAccountException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository
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 sql = "select stock from book_stock where isbn = ?";
        int stock = jdbcTemplate.queryForObject(sql, Integer.class, isbn);
        if (stock <= 0) {
            // 抛出库存不足的异常
            throw new BookStockException("库存不足！");
        }
        sql = "update book_stock set stock = stock -1 where isbn = ?";
        jdbcTemplate.update(sql, isbn);
    }

    @Override
    public void updateUserAccount(String username, int price) {
        // 判断余额是否足够
        String sql = "select balance from account where username = ?";
        int balance = jdbcTemplate.queryForObject(sql, Integer.class, username);
        if (balance < price) {
            // 抛出余额不足的异常
            throw new UserAccountException("余额不足！");
        }
        sql = "update account set balance = balance - ? where username = ?";
        jdbcTemplate.update(sql, price, username);
    }

}

BookStockException：

package com.xianhuii.exception;

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：

package com.xianhuii.exception;

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);
    }

}

BookShopService：

package com.xianhuii.service;

public interface BookShopService {
    public void buyBook(String username, String isbn);
}

BookShopServiceImpl：

package com.xianhuii.service;

import com.xianhuii.dao.BookShopDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
//@Transactional  // 对该类中所有的方法都起作用
public class BookShopServiceImpl implements BookShopService {
    @Autowired
    private BookShopDao bookShopDao;

    @Transactional  // 对指定方法起作用
    @Override
    public void buyBook(String username, String isbn) {
        // 1、查询书的价格
        int price = bookShopDao.findBookPriceByIsbn(isbn);
        // 2、更新数的库存
        bookShopDao.updateBookStock(isbn);
        // 3、更新用户的余额
        bookShopDao.updateUserAccount(username, price);
    }

}

TransactionTest：

package com.xianhuii.test;

import com.xianhuii.service.BookShopService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TransactionTest {
    private ApplicationContext context;
    private BookShopService bookShopService;

    {
        context = new ClassPathXmlApplicationContext("applicationContext.xml");
        bookShopService = (BookShopService) context.getBean("bookShopServiceImpl");
    }

    @Test
    public void buyBookTest() {
        bookShopService.buyBook("Tom", "1001");
    }

}

3 总结

①在applicationContext.xml配置：
tx:annotation-driven中，transaction-manager的默认值是transactionManager。
如果当前事务管理器的id值就是transactionManager，那么transaction-manager的配置可以省略。
如果当前事务管理器的id值不是transactionManager，那么就必须在transaction-manager中指定当前的事务管理器的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"
         xsi:schemaLocation="http://www.springframework.org/schema/beans
                             http://www.springframework.org/schema/beans/spring-beans.xsd
                             http://www.springframework.org/schema/context
                             https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

      <!-- 注解扫描 -->
      <context:component-scan base-package="com.xianhuii"></context:component-scan>

      <!-- 引入外部化的配置文件 -->
      <context:property-placeholder location="classpath:db.properties"/>
      <!-- 配置数据源 -->
      <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
          <property name="driverClass" value="${jdbc.driver}"></property>
          <property name="jdbcUrl" value="${jdbc.url}"></property>
          <property name="user" value="${jdbc.username}"></property>
          <property name="password" value="${jdbc.password}"></property>
      </bean>

      <!-- 配置jdbcTemplate -->
      <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
          <!-- 注入数据源 -->
          <property name="dataSource" ref="dataSource"></property>
      </bean>

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

      <!-- 基于注解使用事务，需要开启事务注解 -->
      <tx:annotation-driven transaction-manager="dataSourceTransactionManager"/>

  </beans>

②使用注解方式开启事务：

package com.xianhuii.service;

import com.xianhuii.dao.BookShopDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
//@Transactional  // 对该类中所有的方法都起作用
public class BookShopServiceImpl implements BookShopService {
    @Autowired
    private BookShopDao bookShopDao;

    @Transactional  // 对指定方法起作用
    @Override
    public void buyBook(String username, String isbn) {
        // 1、查询书的价格
        int price = bookShopDao.findBookPriceByIsbn(isbn);
        // 2、更新数的库存
        bookShopDao.updateBookStock(isbn);
        // 3、更新用户的余额
        bookShopDao.updateUserAccount(username, price);
    }

}

4 事务的属性

1、propagation

propagation：事务的传播行为。
- Propagation.REQUIRED：使用调用者的事务，默认值。
- Propagation.REQUIRES_NEW：将调用者的事务挂起，使用自己的新事务。

2、isolation

事务的隔离级别，最常用的是：READ_COMMITTED。

3、readOnly

指定事务是否为只读。如果是只读事务，代表这个事务只读取数据库，而不进行修改操作。
若一个事务真的是只读取数据，就有必要设置readOnly=true，可以帮助数据库引擎进行优化。

4、（不）回滚条件

rollbackFor、rollbackForClassName、noRollbackFor、noRollbackForClassName。

5、timeout

指定强制回滚前事务可以占用的时间。为了避免一个事务占用过长时间。

6、案例

Cashier：

package com.xianhuii.service;

import java.util.List;

public interface Cashier {
    /**
     * 模拟用户结账行为，同时买多本书
     */
    public void checkOut(String username, List<String> isbns);
}

CashierImpl：

package com.xianhuii.service;

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;

import java.util.List;

@Service
public class CashierImpl implements Cashier {
    @Autowired
    private BookShopService bookShopService;

    /**
     * 事务的属性：
     * propagation：事务的传播行为。
     *      Propagation.REQUIRED：使用调用者的事务，默认值。
     *      Propagation.REQUIRES_NEW：将调用者的事务挂起，使用自己的新事务。
     * isolation：事务的隔离级别，最常用的是：READ_COMMITTED。
     * readOnly：指定事务是否为只读。如果是只读事务，代表这个事务只读取数据库，而不进行修改操作。
     *           若一个事务真的是只读取数据，就有必要设置readOnly=true，可以帮助数据库引擎进行优化。
     * rollbackFor
     * rollbackForClassName
     * noRollbackFor
     * noRollbackForClassName
     * timeout：指定强制回滚前事务可以占用的时间。为了避免一个事务占用过长时间。
     */
    @Transactional(propagation = Propagation.REQUIRES_NEW, isolation = Isolation.READ_COMMITTED)
    public void checkOut(String username, List<String> isbns) {
        for (String isbn : isbns) {
            bookShopService.buyBook(username, isbn);
        }
    }

}

测试：

@Test
    public void checkOutTest () {
        List<String> isbns = new ArrayList<>();
        isbns.add("1001");
        isbns.add("1002");
        cashier.checkOut("Tom", isbns);
    }

5 基于XML配置事务

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

        <!-- 配置事务属性 -->
        <tx:advice id="txAdvice" transaction-manager="transactionManager">
            <tx:attributes>
                <tx:method name="byBook" propagation="REQUIRES_NEW" isolation="READ_COMMITTED" read-only="false"/>
                <tx:method name="checkOut"/>
                <tx:method name="update*" propagation="REQUIRES_NEW"/>
                <tx:method name="insert*" propagation="REQUIRED"/>
                <tx:method name="delete*" propagation="REQUIRED"/>
                <tx:method name="get*" read-only="true"/>
                <!-- *代表除了上述指定的方法之外的方法 -->
                <tx:method name="*"/>
            </tx:attributes>
        </tx:advice>

        <!-- 配置事务切入点，以及事务切入点和事务属性关联起来 -->
        <aop:config>
            <aop:pointcut id="txPointCut" expression="execution(* com.xianhuii.service.*.*(..))"></aop:pointcut>
            <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
        </aop:config>

全部评论

推荐最新楼层

04-30 14:34

重庆大学测试工程师

如何停止与他人的比较

我是985研究生，最近学校在组织开题，大家都在非常紧张地准备，但我一直进入不了状态，很想做但是心又很浮躁。但我的室友们感觉都非常认真，每天醒来就开始看论文，睡着前最后一件事还是在看论文，我非常焦虑。我感觉自己甚至有点把大家当做假想敌了。这种比较心态还存在于生活的各种方面：看到有钱的同学会非常羡慕，看到朋友圈里面环游世界的留学生同学也会羡慕，看到那些工作后有自己的钱而过上较为阔绰的生活的时候还是羡慕，就仿佛只有自己一个人在阴暗爬行。而且这些比较是每时每刻的，为了不比较，我已经关闭了朋友圈，但是每次偶尔刷一下还是会难受很久。我知道比较是偷走幸福的小偷，但我好像控制不了，感觉自己是一个偷窥别人生活的...

若怜君欢：担心开题搞砸了，幻想拥有别人的生活，本质上是因为自卑，楼主小时候大概率是留守儿童或者父母关系很紧张，导致楼主没有安全感、焦虑、内耗。这样的情况最好的办法就是建立自信和降低期待，建立自信不是一蹴而就，而是循序渐进，比如告诉自己允许自己第一次没把事情做好，失败了能搞清楚其中缘由而不是全盘否定自己，失败不是终点，放弃才是；降低期待只要记住一句话即可，能伴随你一生的，只有经验和学识，所以你对事情的态度应该更多地去思考它是否能带来学识和经验的增长，而不是仅仅用短期的利益作为唯一期待。人生不是一成不变的，它是可以迭代更新的，去归纳总结自身的不足并结合实际去改进，去尝试一些新的思路和方法，不要固执钻牛角尖，也不要反复横跳，为自己设立一个高度聚集的精神内核，内核之上可以去尝试一切有利于自己更好的方式以上就是我个人对生活的理解，共勉