基于Spring的转账事务管理

最新推荐文章于 2022-11-14 17:43:25 发布
最新推荐文章于 2022-11-14 17:43:25 发布
阅读量741 收藏 1
点赞数 1
CC 4.0 BY-SA版权
分类专栏： Spring5.X spring从入门到精通 文章标签： Spring  事务控制 转账
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_44580977/article/details/97397596
1.转账业务逻辑类

/**
 * 账户的业务层实现类
 *
 * 事务控制应该都是在业务层
 */
@Component("accountService")
public class AccountServiceImpl implements 
IAccountService{

    @Autowired
    private IAccountDao accountDao;

    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }
    
//省略了其他服务

@Override
 public void transfer(String sourceName, String targetName, Float money) {
        System.out.println("transfer....");
            //2.1根据名称查询转出账户
            Account source = accountDao.findAccountByName(sourceName);
            //2.2根据名称查询转入账户
            Account target = accountDao.findAccountByName(targetName);
            //2.3转出账户减钱
            source.setMoney(source.getMoney()-money);
            //2.4转入账户加钱
            target.setMoney(target.getMoney()+money);
            //2.5更新转出账户
            accountDao.updateAccount(source);

            //模拟转账过程中可能出现的错误
//            int i=1/0;

            //2.6更新转入账户
            accountDao.updateAccount(target);
    }
}

存在问题：很显然，上面没有进行事务控制，每次accountDao方法调用都会从数据库连接池中拿出一个connection 连接，然后执行方法，自动commit提交，中间如果出从，可能会导致转入账户加钱，而转出账户却没有减钱，事务无法回滚的错误。

解决方法：每次accountDao方法都是用同一个connection连接，并且连接设置为手动提交，当转账成功时，提交数据库用户数据的修改，出错异常则不提交。

2.线程绑定connection

因为要让事务控制多个accountDao方法共同提交或则共同回滚，因此只能使用同一个connection。当前线程是唯一的，因此可以绑定在线程上。

/**
 * 连接的工具类，它用于从数据源中获取一个连接，并且实现和线程的绑定
 */
@Component("connectionUtils")
public class ConnectionUtils {

	//一个线程拥有一个固定的变量，即绑定
    private ThreadLocal<Connection> tl = new ThreadLocal<Connection>();

    @Autowired
    private DataSource dataSource;

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    /**
     * 获取当前线程上的连接
     * @return
     */
    public Connection getThreadConnection() {
        try{
            //1.先从ThreadLocal上获取
            Connection conn = tl.get();
            //2.判断当前线程上是否有连接
            if (conn == null) {
                //3.从数据源中获取一个连接，并且存入ThreadLocal中
                conn = dataSource.getConnection();
                tl.set(conn);
            }
            //4.返回当前线程上的连接
            return conn;
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }

    /**
     * 把连接和线程解绑
     */
    public void removeConnection(){
        tl.remove();
    }
}

以上就完成了线程和连接的绑定工具类了

3.事务管理的工具类

为了便于service层代码业务逻辑的清晰，将会单独写一个事务管理的工具类

/**
 * 和事务管理相关的工具类，它包含了，开启事务，提交事务，回滚事务和释放连接
 */
@Component("txManager")
public class TransactionManager {

    @Autowired
    private ConnectionUtils connectionUtils;

    public void setConnectionUtils(ConnectionUtils connectionUtils) {
        this.connectionUtils = connectionUtils;
    }

    /**
     * 开启事务
     */
    public  void beginTransaction(){
        try {
            connectionUtils.getThreadConnection().setAutoCommit(false);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    /**
     * 提交事务
     */
    public  void commit(){
        try {
            connectionUtils.getThreadConnection().commit();
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    /**
     * 回滚事务
     */
    public  void rollback(){
        try {
            connectionUtils.getThreadConnection().rollback();
        }catch (Exception e){
            e.printStackTrace();
        }
    }


    /**
     * 释放连接
     */
    public  void release(){
        try {
            connectionUtils.getThreadConnection().close();//还回连接池中
            connectionUtils.removeConnection();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}


账户持久层实现类

/**
 * 账户的持久层实现类
 */
@Repository("accountDao")
public class AccountDaoImpl implements IAccountDao {

    @Autowired
    private QueryRunner runner;

    @Autowired
    private ConnectionUtils connectionUtils;

    public void setRunner(QueryRunner runner) {
        this.runner = runner;
    }

    public void setConnectionUtils(ConnectionUtils connectionUtils) {
        this.connectionUtils = connectionUtils;
    }

    @Override
    public List<Account> findAllAccount() {
        try{
            return runner.query(connectionUtils.getThreadConnection(),"select * from account",new BeanListHandler<Account>(Account.class));
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public Account findAccountById(Integer accountId) {
        try{
            return runner.query(connectionUtils.getThreadConnection(),"select * from account where id = ? ",new BeanHandler<Account>(Account.class),accountId);
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void saveAccount(Account account) {
        try{
            runner.update(connectionUtils.getThreadConnection(),"insert into account(name,money)values(?,?)",account.getName(),account.getMoney());
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void updateAccount(Account account) {
        try{
            runner.update(connectionUtils.getThreadConnection(),"update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void deleteAccount(Integer accountId) {
        try{
            runner.update(connectionUtils.getThreadConnection(),"delete from account where id=?",accountId);
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public Account findAccountByName(String accountName) {
        try{
            List<Account> accounts = runner.query(connectionUtils.getThreadConnection(),"select * from account where name = ? ",new BeanListHandler<Account>(Account.class),accountName);
            if(accounts == null || accounts.size() == 0){
                return null;
            }
            if(accounts.size() > 1){
                throw new RuntimeException("结果集不唯一，数据有问题");
            }
            return accounts.get(0);
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}
4.动态创建代理accountService
/**
 * 用于创建Service的代理对象的工厂
 */
@Component("proxyAccountService")
public class BeanFactory {

    @Autowired
    private IAccountService accountService;

    @Autowired
    private TransactionManager txManager;

    public void setTxManager(TransactionManager txManager) {
        this.txManager = txManager;
    }


    public final void setAccountService(IAccountService accountService) {
        this.accountService = accountService;
    }

    /**
     * 获取Service代理对象
     * @return
     */
    @Bean("as")
    public IAccountService getAccountService() {
        return (IAccountService)Proxy.newProxyInstance(accountService.getClass().getClassLoader(),
                accountService.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     * 添加事务的支持
                     *
                     * @param proxy
                     * @param method
                     * @param args
                     * @return
                     * @throws Throwable
                     */
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        if("test".equals(method.getName())){
                            return method.invoke(accountService,args);
                        }

                        Object rtValue = null;
                        try {
                            //1.开启事务
                            txManager.beginTransaction();
                            //2.执行操作
                            rtValue = method.invoke(accountService, args);
                            //3.提交事务
                            txManager.commit();
                            //4.返回结果
                            return rtValue;
                        } catch (Exception e) {
                            //5.回滚操作
                            txManager.rollback();
                            throw new RuntimeException(e);
                        } finally {
                            //6.释放连接
                            txManager.release();
                        }
                    }
                });

    }
}

动态创建代理accountService类，完成事务控制就ok了

5.测试类
/**
 * 使用Junit单元测试：测试我们的配置
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")
public class AccountServiceTest {

    //    @Qualifier("proxyAccountService")
    @Autowired
    @Qualifier("as")
    private IAccountService as;

    @Test
    public void testTransfer() {
        as.transfer("aaa", "bbb", 100f);
    }

}
6.Bean.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"
       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="com.itheima"></context:component-scan>


    
    <!--配置QueryRunner scope="prototype" -->
    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" ></bean>

    <!-- 配置数据源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!--连接数据库的必备信息-->
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
    </bean>
</beans>

有一点不懂，runner 一般用单例好，还是多例好呢？

基于Spring的转账事务管理到此就完成了，如果有不懂的地方欢迎留言一起探讨

Spring框架之事务管理（附转账Demo）
hestyle的博客
12-04 456
事务是数据库中非常重要的概念，在编写博客的时候反复提到，但是由于博主能力有限，感谢自己事务的理解还比较浅，所以迟迟没有更新一篇关于数据库事务概念性相关的博客。为了写好此篇Spring的事务管理博客，特意写了一篇事务概念区分的博客 数据库事务概念理解（通俗易懂，东半球最详细~），有兴趣的可以去看看。 Spring框架的事务主要由spring-tx.RELEASE.jar提供，下面将由此展开介绍并结合...
【Spring全家桶系列】Spring中的事务管理（基于注解完成实现）
未见花闻的博客
05-16 1827
前面我们已经介绍了如何在Spring环境中整合mybatis完成数据库的增删查改操作，在正常情况下，操作数据库是没有问题的，但是一个业务需要多次操作数据库，并且需要完成修改，插入，删除操作可能会有问题，如转账，其实是有两个步骤，第一步从A账户扣钱，第二步在B账户中加钱。
一个spring中的事务管理的转账练习
weixin_41590998的博客
09-06 253
一个spring中的事务管理练习：转账 dao层中的代码： 接口：IUserDao import com.ujiuye.bean.User; import java.util.List; /** * Created by Administrator on 2019/9/5. */ public interface IuserDao { void save(User user); ...
Spring事务银行转账示例
weixin_34318272的博客
04-09 167
https://www.imooc.com/video/9331 声明式事务 @Transactiona() 编程式事务 非模板式（不使用TransactionTemplate） 　　　　http://cailangwei.blog.163.com/blog/static/1314585792014895755400/ 　　　　applicationContext.xm...
利用简单的转账来学习spring的事务控制
一千零二夜的博客
12-15 245
一.Spring封装了事务管理操作 1.事务管理的操作：1.打开事务 2.回滚事务（操作出现异常，把数据返回） 3.提交事务（进行数据更新） 2.Spring中的操作对象 （1）不同平台,操作事务的代码各不相同.spring给我们提供了一个接口 PlatformTransactionManager 我们使用的都是接口的实现类，整合jdbc使用的DatasourceTransactionManager，整合hibernate使用的则HibernateTransitionmanager 注意的是：在spring
spring注解方式实现转账事务操作
qq_26496077的博客
10-17 354
目录结构 JdbcConfig.java package com.itheima.config; import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation.Bean; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.jdbc.dataso..
Spring的事务管理以及转账案例
01-27
在本文中，我们将重点讨论Spring的事务管理机制，并通过一个转账案例来具体说明如何在Spring中使用事务管理。 首先，让我们回顾一下什么是事务。在计算机科学中，事务通常指的是对数据进行的一系列操作，这些操作...
Spring之银行转账案例(七)
12-20
总结，这个系列教程通过银行转账的实例，系统地介绍了Spring的事务管理机制，包括事务的四大特性（ACID），事务管理工具的实现，以及基于接口和子类的动态代理在事务控制中的应用。通过学习，读者能够掌握在实际开发...
spring事务管理
12-27
### Spring事务管理详解 #### 一、事务管理基础概念 在深入探讨Spring事务管理之前，我们需要先理解什么是事务。事务可以被定义为一系列的操作集合，这些操作作为一个整体被提交或回滚。简单来说，事务就是一个不...
spring事务管理之转账案例
qq_36594703的博客
01-08 400
AccountDao类： public interface AccountDao { //加钱 void increaseMoney(Integer id,Double money); //减钱 void decreaseMoney(Integer id,Double money); } AccountDaoImpl实现类： public class AccountDaoImpl exten
spring注解 事务转账案例
weixin_44753727的博客
06-05 280
spring注解 事务转账案例 ---domain层 创建Account对象 略； ---dao层 @Component("accountDao") public class AccountDaoImpl implements AccountDao { @Autowired private JdbcTemplate jdbcTemplate; //姓名 获取 ACCount...
SpringBoot2 综合案例（09）：基于转账案例，演示事务管理
GitChat
09-09 386
Spring Boot 2 基础案例篇 包含：入门、日志管理、定时器、事务、AOP、数据库、缓存、NoSQL、监控、打包。 Spring Boot 2 高级案例篇 包含：整合常用中间件：分库分表、权限管理、Redis 集群、Dubbo、消息队列、定时器、搜索引擎、文件管理、邮件等...
Spring事务简介（案例：银行账户转账）
阿博的博客
11-14 1704
Spring事务简介（案例：银行账户转账）
Spring 从入门到精通系列 09 —— 转账方法的事务问题与动态代理
秀岩的博客
06-02 719
本文由转账方法中存在的事务问题引出事务控制的方法，最后简述动态代理方法，实现统一维护。 文章目录一、转账方法的事务问题（了解）1.1 问题分析1.2 创建 ConnectionUtils类1.3 事务管理相关的工具类1.4 更新事务控制1.5 其他代码二、动态代理 一、转账方法的事务问题（了解） 1.1 问题分析 为了说明事务问题，我们创建一个新的项目，并添加转账方法。 账户的业务层接口及其实现类： /** * 账户的业务层实现类 */ public class AccountServiceImp
数据库事务学习总结
每天学习一点点
04-20 1137
在数据库中，事务（Transaction）指的是一组相关的SQL语句，它们在业务逻辑上组成一个原子单元。数据库管理系统必须保证一个事务中的所有操作全部提交或者全部撤销。 最常见的数据库事务就是银行账户之间的转账操作。例如，从账户A转出1000元到账户B。 上图是一个简化的转账流程，实际上银行转账还需要检查账户的状态、判断是否收取转账费用等。以上流程包括以下几个步骤： （1）开始转账流程。查询账户A的余额是否足够，如果其余额不足，则终止转账。 （2）从账户A扣除1000元。 （3）往账户B存入1
Spring通过事务实现模拟银行转账案例
hq.zheng的博客
01-24 3549
1.  案例结构 2. 所用数据库表 3. jdbc.properties配置文件 driver=com.mysql.jdbc.Driver url=jdbc\:mysql\://localhost\:3306/test?characterEncoding\=utf-8 username=root password=root initialSize=5 maxActive
SpringBoot2.0 基础案例(12)：基于转账案例，演示事务管理操作
weixin_30879833的博客
06-20 244
本文源码 GitHub地址：知了一笑 https://github.com/cicadasmile/spring-boot-base 一、事务管理简介 1、事务基本概念 一组业务操作ABCD，要么全部成功，要么全部不成功。 2、特性：ACID 原子性：整体 一致性：完成 隔离性：并发 持久性：结果 3、隔离问题 脏读：一个事务读到另一个事务没有提交的数据 不可重复读：一个事务读到另一个事务已提交的...
事物 银行转账业务
weixin_34248258的博客
03-11 280
//web层 package cn.jy.web; import java.io.IOException;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet....
Spring事务管理：原子性、隔离与转账案例解析
- **配置事务管理器**：Spring需要一个PlatformTransactionManager来管理事务，如DataSourceTransactionManager（基于JDBC）和HibernateTransactionManager（与Hibernate集成）。 - **TransactionDefinition**：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值