乐观锁转账

已于 2023-08-09 13:59:11 修改
阅读量77 收藏
点赞数
分类专栏： SpringBoot 文章标签： spring boot
于 2023-08-09 11:57:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35292763/article/details/132180649
版权

在Spring Boot和MyBatis中，我们可以使用@Transactional注解和乐观锁或悲观锁来实现转账扣款操作。以下是一个使用乐观锁的示例：

首先，我们需要在账户表中添加一个version字段，用于实现乐观锁。

然后，我们创建一个Account实体类：``

public class Account {
    private int id;
    private int balance;
    private int version; // 用于乐观锁

    // getters and setters...
}

接着，我们创建一个AccountMapper接口：

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

@Mapper
public interface AccountMapper {
    @Select("SELECT * FROM accounts WHERE id = #{id}")
    Account findById(@Param("id") int id);

    @Update("UPDATE accounts SET balance = balance - #{amount}, version = version + 1 WHERE id = #{id} AND version = #{version}")
    int withdraw(@Param("id") int id, @Param("amount") int amount, @Param("version") int version);

    @Update("UPDATE accounts SET balance = balance + #{amount} WHERE id = #{id}")
    void deposit(@Param("id") int id, @Param("amount") int amount);
}

最后，我们创建一个BankService类，实现转账扣款操作：

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class BankService {
    private final AccountMapper accountMapper;

    public BankService(AccountMapper accountMapper) {
        this.accountMapper = accountMapper;
    }

    @Transactional
    public void transfer(int fromId, int toId, int amount) {
        Account fromAccount = accountMapper.findById(fromId);
        if (fromAccount.getBalance() < amount) {
            throw new RuntimeException("Insufficient balance");
        }

        int updatedRows = accountMapper.withdraw(fromId, amount, fromAccount.getVersion());
        if (updatedRows == 0) {
            throw new RuntimeException("Concurrent modification detected");
        }

        accountMapper.deposit(toId, amount);
    }
}

在这个例子中，我们使用@Transactional注解来开启事务。在transfer方法中，我们首先检查余额是否足够，然后尝试扣款。如果扣款失败（可能是因为并发修改），我们就抛出一个异常，然后Spring会自动回滚事务。否则，我们就存款，然后Spring会自动提交事务。

注意，这只是一个简单的例子，实际的生产环境可能会更复杂。例如，你可能需要处理更多的异常情况，或者使用悲观锁来处理高并发环境。

在实际的生产环境中，如果扣款失败（可能是因为并发修改），我们通常会尝试重新执行操作，而不是直接抛出异常。这就是所谓的重试机制。

以下是一个使用重试机制的转账扣款操作示例：

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class BankService {
    private final AccountMapper accountMapper;

    public BankService(AccountMapper accountMapper) {
        this.accountMapper = accountMapper;
    }

    @Transactional
    public void transfer(int fromId, int toId, int amount) {
        for (int i = 0; i < 3; i++) { // 尝试3次
            Account fromAccount = accountMapper.findById(fromId);
            if (fromAccount.getBalance() < amount) {
                throw new RuntimeException("Insufficient balance");
            }

            int updatedRows = accountMapper.withdraw(fromId, amount, fromAccount.getVersion());
            if (updatedRows > 0) {
                accountMapper.deposit(toId, amount);
                return;
            }
        }

        throw new RuntimeException("Concurrent modification detected");
    }
}

在上述的转账代码中，我们可以进行以下几点优化：

  1. 异常处理：在实际的生产环境中，我们需要处理更多的异常情况，例如数据库连接失败、SQL语句错误等。我们可以定义一个自定义的异常类，用于封装这些异常情况。

  2. 日志记录：我们可以添加日志记录，用于记录转账操作的详细信息，例如转账金额、转账时间、转账结果等。这对于问题排查和系统监控非常有用。

  3. 参数校验：我们需要校验输入参数的有效性，例如账户ID是否存在、转账金额是否大于0等。

以下是一个优化后的转账示例：

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Service
public class BankService {
    private final AccountMapper accountMapper;
    private static final Logger logger = LoggerFactory.getLogger(BankService.class);

    public BankService(AccountMapper accountMapper) {
        this.accountMapper = accountMapper;
    }

    @Transactional
    public void transfer(int fromId, int toId, int amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("Amount must be greater than zero");
        }

        for (int i = 0; i < 3; i++) { // 尝试3次
            Account fromAccount = accountMapper.findById(fromId);
            if (fromAccount == null) {
                throw new IllegalArgumentException("Account " + fromId + " does not exist");
            }

            if (fromAccount.getBalance() < amount) {
                throw new RuntimeException("Insufficient balance");
            }

            int updatedRows = accountMapper.withdraw(fromId, amount, fromAccount.getVersion());
            if (updatedRows > 0) {
                accountMapper.deposit(toId, amount);
                logger.info("Transfer successful: {} -> {}, amount: {}", fromId, toId, amount);
                return;
            }

            logger.warn("Concurrent modification detected, retrying...");
        }

        logger.error("Transfer failed after 3 attempts: {} -> {}, amount: {}", fromId, toId, amount);
        throw new RuntimeException("Concurrent modification detected");
    }
}

在这个例子中，我们添加了参数校验、日志记录，并且在发生并发修改时，我们会记录一个警告日志，然后重试操作。如果尝试了3次还是失败，我们就记录一个错误日志，然后抛出一个异常。

在Spring Boot和MyBatis中，我们可以使用@Transactional注解和悲观锁来实现转账扣款操作。以下是一个使用悲观锁的示例：

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

@Mapper
public interface AccountMapper {
    @Select("SELECT * FROM accounts WHERE id = #{id} FOR UPDATE")
    Account findByIdForUpdate(@Param("id") int id);

    @Update("UPDATE accounts SET balance = balance - ? WHERE id = ?")
    int withdraw(@Param("id") int id, @Param("amount") int amount);

    @Update("UPDATE accounts SET balance = balance + ? WHERE id = ?")
    void deposit(@Param("id") int id, @Param("amount") int amount);
}

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class BankService {
    private final AccountMapper accountMapper;

    public BankService(AccountMapper accountMapper) {
        this.accountMapper = accountMapper;
    }

    @Transactional
    public void transfer(int fromId, int toId, int amount) {
        Account fromAccount = accountMapper.findByIdForUpdate(fromId);
        if (fromAccount.getBalance() < amount) {
            throw new RuntimeException("Insufficient balance");
        }

        accountMapper.withdraw(fromId, amount);
        accountMapper.deposit(toId, amount);
    }
}

在这个例子中，我们使用@Transactional注解来开启事务。在transfer方法中，我们首先获取fromId账户的信息，并对该账户加锁（悲观锁）。然后，我们检查余额是否足够，如果足够，就执行扣款和存款操作。因为我们使用了悲观锁，所以在我们操作fromId账户的过程中，其他事务不能修改该账户，这就保证了转账操作的一致性。

注意，这只是一个简单的例子，实际的生产环境可能会更复杂。例如，你可能需要处理更多的异常情况，或者使用乐观锁来处理高并发环境。

为了避免死锁，一种常见的策略是总是按照相同的顺序锁定资源。例如，我们可以按照账户ID的顺序来锁定账户。这样，上述的情况就不会发生，因为两个事务会按照相同的顺序来锁定账户A和账户B，不会形成死锁。这句话能对上述代码优化实现下吗

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class BankService {
    private final AccountMapper accountMapper;

    public BankService(AccountMapper accountMapper) {
        this.accountMapper = accountMapper;
    }

    @Transactional
    public void transfer(int fromId, int toId, int amount) {
        // 按照账户ID的顺序来锁定账户
        int minId = Math.min(fromId, toId);
        int maxId = Math.max(fromId, toId);

        Account minAccount = accountMapper.findByIdForUpdate(minId);
        if (minId == fromId && minAccount.getBalance() < amount) {
            throw new RuntimeException("Insufficient balance");
        }

        Account maxAccount = accountMapper.findByIdForUpdate(maxId);
        if (maxId == fromId && maxAccount.getBalance() < amount) {
            throw new RuntimeException("Insufficient balance");
        }

        if (minId == fromId) {
            accountMapper.withdraw(fromId, amount);
            accountMapper.deposit(toId, amount);
        } else {
            accountMapper.withdraw(toId, amount);
            accountMapper.deposit(fromId, amount);
        }
    }
}

在实际的生产环境中，数据库通常会提供死锁检测和解决的机制。例如，如果数据库检测到死锁，它可能会自动终止其中一个事务，从而解除死锁。然后，应用程序可以捕获到这个异常，然后重新尝试事务。这句话代码实现下

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.dao.DeadlockLoserDataAccessException;

@Service
public class BankService {
    private final AccountMapper accountMapper;

    public BankService(AccountMapper accountMapper) {
        this.accountMapper = accountMapper;
    }

    public void transfer(int fromId, int toId, int amount) {
        while (true) {
            try {
                doTransfer(fromId, toId, amount);
                break; // 如果转账成功，跳出循环
            } catch (DeadlockLoserDataAccessException e) {
                // 如果发生死锁，重新尝试转账
            }
        }
    }

    @Transactional
    protected void doTransfer(int fromId, int toId, int amount) {
        // 按照账户ID的顺序来锁定账户
        int minId = Math.min(fromId, toId);
        int maxId = Math.max(fromId, toId);

        Account minAccount = accountMapper.findByIdForUpdate(minId);
        if (minId == fromId && minAccount.getBalance() < amount) {
            throw new RuntimeException("Insufficient balance");
        }

        Account maxAccount = accountMapper.findByIdForUpdate(maxId);
        if (maxId == fromId && maxAccount.getBalance() < amount) {
            throw new RuntimeException("Insufficient balance");
        }

        if (minId == fromId) {
            accountMapper.withdraw(fromId, amount);
            accountMapper.deposit(toId, amount);
        } else {
            accountMapper.withdraw(toId, amount);
            accountMapper.deposit(fromId, amount);
        }
    }
}

参考http://t.csdn.cn/PCBmA参考

qq_35292763
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot整合MyBatis实现乐观锁和悲观锁的示例
08-25
SpringBoot整合MyBatis实现乐观锁和悲观锁的示例 在本文中，我们将学习如何使用SpringBoot和MyBatis来实现乐观锁和悲观锁。我们将通过示例代码来介绍这两种锁的实现方式，帮助读者更好地理解和使用它们。 一、悲观...
【支付系统】加减余额/库存,防止负数和脏读
qq_39078783的博客
06-17 596
扣减余额时，检查当前余额数量和版本号是否一致，如果一致则进行扣减操作并更新版本号，否则说明有其他请求已经进行了余额扣减操作，此时需要重新查询当前余额数量和版本号，然后重新尝试扣减余额。如果获取锁成功，则进行余额扣减操作，扣减完成后释放锁。如果当前余额数量大于0，则进行余额扣减操作，并更新数据库中的余额数量。在使用进行余额扣减时，可能会遇到并发请求同时扣减同一余额的情况，这可能会导致脏读和负数余额的问题。总之，使用分布式锁和乐观锁等机制可以保证余额扣减操作的正确性和并发性，避免出现脏读和负数余额等问题。
JAVA架构面试专题_面试必备之乐观锁与悲观锁.pdf
03-03
Java 架构面试中，乐观锁与悲观锁是两个重要的并发控制概念，它们在多线程环境下用于确保数据的一致性。理解这两种锁对于开发者来说至关重要，特别是在高并发的系统设计中。 **悲观锁**是一种保守的并发控制策略，...
【面试资料】-（机构内训资料）面试必备之乐观锁与悲观锁.zip
09-06
乐观锁和悲观锁是数据库事务控制中的两种重要策略，它们主要用在多用户并发操作同一数据时，以防止数据的不一致性。理解这两种锁的概念、原理以及应用场景对于开发者来说至关重要，尤其是在高并发环境下保证数据的...
RESTful Web Service实现转账
06-13
例如，在转账业务中，我们可以使用乐观锁或版本号机制，确保同一时刻只有一个转账操作能够修改特定账户的余额。 综上所述，实现RESTful Web Service进行转账业务涉及到资源的定义、事务处理以保证数据一致性，以及...
java多线程、锁的教程跟案例
12-01
2. **乐观锁** - CAS（Compare and Swap）：无锁算法，基于硬件原子操作，检查并更新值，如果值未改变则更新，否则失败。 3. **锁接口** - Lock接口：定义了锁的行为，包括ReentrantLock、ReadWriteLock的父接口...
项目实战--Spring Boot + GraphQL实现实时数据推送
qq_40623672的博客
07-10 493
GraphQL是一种用于API的查询语言，核心思想是让客户端能够根据自身需求精确地获取所需的数据，而不是像传统的RESTful API那样只能获取整个资源对象。（1）灵活性：客户端可以精确指定所需的数据字段，而不是被限制于服务器端提供的固定数据结构。（2）效率：减少了不必要的数据传输和处理，提高了数据获取效率。（3）类型系统：GraphQL具有严格的类型系统，能够在编译阶段检测出潜在的错误，提高了开发效率。
Spring Boot集成pf4j实现插件开发功能
HBLOG
07-10 596
一个插件框架，用于实现插件的动态加载，支持的插件格式（zip、jar）。
Spring Boot中的多租户架构实现
微赚淘客开发者博客
07-06 1441
在多租户系统中，每个租户都能够安全且有效地使用相同的应用程序，同时确保数据隔离和性能独立性。通过合理的设计和实施，开发人员可以有效地管理和运行支持多个租户的应用程序，从而提升系统的灵活性和扩展性。每个租户是一个逻辑上独立的客户，拥有自己的数据、配置、用户界面等资源，而这些资源又可以在同一个应用程序实例中共享。在Spring Boot中配置多租户数据源，可以使用AbstractRoutingDataSource实现动态数据源切换，根据不同的租户标识动态选择数据源。
深入理解Spring Boot中的事件驱动架构
微赚淘客开发者博客
07-07 523
通常情况下，我们可以通过ApplicationEvent类来自定义事件，通过实现ApplicationListener接口或使用@EventListener注解来定义事件监听器。在Spring Framework中，事件驱动是通过事件（Event）和事件监听器（EventListener）来实现的。在这个示例中，Spring Boot程序使用@SpringBootApplication注解来标识应用，通过@EventListener注解来监听自定义事件MyEvent，并在事件发生时打印消息。
Spring Boot单体服务之间用feign调用
木槿
07-09 170
会定义路径和url等信息，用于指定服务调用服务调用启动feign配置调用url。
Spring Boot中的 6 种API请求参数读取方式
最新发布
恒安软件
07-13 177
使用Spring Boot开发API的时候，读取请求参数是服务端编码中最基本的一项操作，Spring Boot中也提供了多种机制来满足不同的API设计要求。接下来，就通过本文，为大家总结6种常用的请求参数读取方式。如果你发现自己知道的不到6种，那么赶紧来查漏补缺一下。如果你知道的不止6种，那么告诉大家，一起互相学习一下吧～
Memcached 介绍与详解及在Java Spring Boot项目中的使用与集成
招风的黑耳CSDN
07-09 674
Memcached 是一种高性能的分布式内存对象缓存系统，主要用于加速动态Web应用以减少数据库负载，从而提高访问速度和性能。作为一个开源项目，Memcached 被广泛应用于许多大型互联网公司，如Facebook、Twitter 和 YouTube 等。Memcached 通过将数据存储在内存中，并使用高效的哈希算法来进行数据存取，提供了极高的读写性能。
Spring boot 更改启动LOGO
qq_45523857的博客
07-02 740
在resources目录下创建banner.txt文件，然后编辑对应的图案即可。
Spring Boot实战：无缝对接OpenAI
德乐懿的博客
07-09 965
通过本文的介绍，你应该已经了解了如何使用Spring Boot无缝对接OpenAI，并在你的应用中实现AI功能。你可以通过探索OpenAI的官方文档来了解更多关于这些功能的信息，并按照类似的方式在你的Spring Boot应用中实现它们。要使用OpenAI的API，首先需要注册一个OpenAI账号，并在Dashboard中获取你的API密钥。这个密钥将用于后续的API调用中，以验证你的身份。此外，你还可以考虑使用Spring Boot的其他特性来增强你的应用，如异步处理、安全性、数据库集成等。
在Spring Boot项目中集成监控与报警
微赚淘客开发者博客
07-08 697
本文详细介绍了在Spring Boot项目中集成监控与报警的方法，包括使用Actuator端点进行基本的监控配置、集成Spring Boot Admin进行高级监控和报警配置，以及使用Micrometer进行度量。Spring Boot作为广泛使用的Java框架，提供了丰富的支持来集成监控和报警功能，本文将介绍如何在Spring Boot项目中实现这些功能。通过Spring Boot Admin的界面，可以配置报警规则和通知方式，如邮件、Slack等，来实现对应用程序异常和重要指标的实时监控和报警通知。
Gradle构建多模块spring boot项目
木槿
07-09 973
按创建springboot项目的创建方式创建就行，创建完的结构。然后删除src目录。
Spring Boot中@Async注解的使用及原理 + 常见问题及解决方案
傲泣龙腾的博客
07-12 1112
在现代Java应用程序中，异步处理是提高性能和响应速度的重要手段之一，比如博主之前分享的【Spring Boot 使用自定义注解和自定义线程池实现异步日志记录】，就是采用了异步处理来实现日志记录，而在中它提供了@Async注解来简化异步编程，今天博主就来和小伙伴们分享本@Async注解的基本使用、实现原理以及应用场景。使用@Async注解定义异步方法
spring boot 3.2.x 使用CDS加速启动
偶是一只小小鸟~
07-11 274
spring boot 启动加速，类共享模式
悲观锁与乐观锁的场景
09-02
悲观锁和乐观锁是在并发编程中用于保证数据一致性的两种常见策略。 悲观锁适用于并发写入操作较多的情况，它的核心思想是在操作数据之前先获取锁，以确保独占访问数据，避免并发冲突。在悲观锁的策略中，如果一个线程已经获取了锁，其他线程需要等待锁的释放。一种具体实现是通过数据库中的行锁或表锁来实现，以防止并发修改。 乐观锁适用于并发读取操作较多、写入操作较少的场景。它的核心思想是假设在数据的整个读写过程中不会发生冲突，因此不进行加锁操作，而是在更新数据时检查数据版本或者使用一种类似于原子操作的方式来保证数据的一致性。如果判断出数据被其他线程修改过，则放弃当前操作，重新尝试或者报错。 场景选择上，可以根据具体需求来选择使用悲观锁还是乐观锁。悲观锁适用于对数据一致性要求较高、并发写入操作较多的场景，例如银行转账、库存管理等；而乐观锁适用于并发读取操作较多、写入操作较少的场景，例如商品浏览、缓存更新等。 需要注意的是，悲观锁会引入锁的开销和等待时间，而乐观锁需要处理冲突和重试的逻辑。因此，在选择锁策略时，需要权衡并发性能和数据一致性的需求。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值