MyBatis 实现乐观锁

原创 于 2025-09-03 11:47:13 发布 · 532 阅读 · 10 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#mybatis #java

使用 MyBatis 实现乐观锁需要手动处理版本号的检查和更新。

一、数据表设计

CREATE TABLE products (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(100) NOT NULL,
    price DECIMAL(10, 2) NOT NULL,
    stock INT NOT NULL,
    version INT DEFAULT 0 COMMENT '版本号，用于乐观锁'
);

CREATE TABLE orders (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    user_id BIGINT NOT NULL,
    product_id BIGINT NOT NULL,
    quantity INT NOT NULL,
    status VARCHAR(20) DEFAULT 'PENDING',
    create_time DATETIME DEFAULT CURRENT_TIMESTAMP
);

二、实体类设计

// 产品实体类
@Data
public class Product {
    private Long id;
    private String name;
    private BigDecimal price;
    private Integer stock;
    private Integer version; // 乐观锁版本号
}

// 订单实体类
@Data
public class Order {
    private Long id;
    private Long userId;
    private Long productId;
    private Integer quantity;
    private String status;
    private Date createTime;
}

三、MyBatis Mapper 接口

@Mapper
public interface ProductMapper {
    
    /**
     * 根据ID查询产品
     */
    Product selectById(Long id);
    
    /**
     * 乐观锁更新库存
     * 返回受影响的行数：1表示成功，0表示版本冲突或库存不足
     */
    int updateStockWithVersion(@Param("id") Long id, 
                              @Param("quantity") Integer quantity,
                              @Param("version") Integer version);
    
    /**
     * 查询产品信息（包含版本号）
     */
    Product selectForUpdate(Long id);
    
    /**
     * 批量更新产品信息（带乐观锁）
     */
    int batchUpdate(@Param("list") List<Product> products);
}

@Mapper
public interface OrderMapper {
    
    /**
     * 插入订单
     */
    int insert(Order order);
    
    /**
     * 更新订单状态
     */
    int updateStatus(@Param("id") Long id, @Param("status") String status);
}

四、MyBatis XML 映射文件

ProductMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.mapper.ProductMapper">

    <resultMap id="ProductResultMap" type="Product">
        <id property="id" column="id" />
        <result property="name" column="name" />
        <result property="price" column="price" />
        <result property="stock" column="stock" />
        <result property="version" column="version" />
    </resultMap>

    <select id="selectById" resultMap="ProductResultMap">
        SELECT id, name, price, stock, version 
        FROM products 
        WHERE id = #{id}
    </select>

    <select id="selectForUpdate" resultMap="ProductResultMap">
        SELECT id, name, price, stock, version 
        FROM products 
        WHERE id = #{id}
    </select>

    <!-- 乐观锁更新：版本号+1，同时检查旧版本号和库存 -->
    <update id="updateStockWithVersion">
        UPDATE products 
        SET stock = stock - #{quantity},
            version = version + 1
        WHERE id = #{id} 
          AND version = #{version}
          AND stock >= #{quantity}
    </update>

    <!-- 批量更新（带乐观锁） -->
    <update id="batchUpdate">
        <foreach collection="list" item="product" separator=";">
            UPDATE products 
            SET name = #{product.name},
                price = #{product.price},
                stock = #{product.stock},
                version = version + 1
            WHERE id = #{product.id} 
              AND version = #{product.version}
        </foreach>
    </update>

</mapper>

OrderMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.mapper.OrderMapper">

    <resultMap id="OrderResultMap" type="Order">
        <id property="id" column="id" />
        <result property="userId" column="user_id" />
        <result property="productId" column="product_id" />
        <result property="quantity" column="quantity" />
        <result property="status" column="status" />
        <result property="createTime" column="create_time" />
    </resultMap>

    <insert id="insert" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO orders (user_id, product_id, quantity, status)
        VALUES (#{userId}, #{productId}, #{quantity}, #{status})
    </insert>

    <update id="updateStatus">
        UPDATE orders SET status = #{status} WHERE id = #{id}
    </update>

</mapper>

五、Service 层实现

基础版本服务

@Service
@Transactional
public class ProductService {
    
    @Autowired
    private ProductMapper productMapper;
    
    @Autowired
    private OrderMapper orderMapper;
    
    /**
     * 基础乐观锁实现 - 扣减库存
     */
    public boolean deductStock(Long productId, Integer quantity) {
        // 1. 查询当前产品信息（包含版本号）
        Product product = productMapper.selectById(productId);
        if (product == null) {
            throw new RuntimeException("产品不存在");
        }
        
        if (product.getStock() < quantity) {
            throw new RuntimeException("库存不足");
        }
        
        // 2. 尝试乐观锁更新
        int affectedRows = productMapper.updateStockWithVersion(
            productId, quantity, product.getVersion());
        
        return affectedRows > 0;
    }
}

带重试机制的服务

@Service
public class OrderServiceWithRetry {
    
    @Autowired
    private ProductMapper productMapper;
    
    @Autowired
    private OrderMapper orderMapper;
    
    private static final int MAX_RETRIES = 3;
    private static final long BASE_DELAY = 100; // 基础延迟100ms
    
    /**
     * 创建订单 - 带重试的乐观锁实现
     */
    public OrderResult createOrder(OrderRequest request) {
        int retryCount = 0;
        
        while (retryCount < MAX_RETRIES) {
            try {
                return tryCreateOrder(request);
            } catch (OptimisticLockException e) {
                retryCount++;
                log.warn("乐观锁冲突，重试第{}次，产品ID: {}", retryCount, request.getProductId());
                
                if (retryCount >= MAX_RETRIES) {
                    break;
                }
                
                // 指数退避策略
                long delay = (long) (BASE_DELAY * Math.pow(2, retryCount - 1));
                try {
                    Thread.sleep(delay);
                } catch (InterruptedException ie) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        }
        
        return OrderResult.fail("系统繁忙，请稍后重试");
    }
    
    /**
     * 单次尝试创建订单
     */
    @Transactional(rollbackFor = Exception.class)
    private OrderResult tryCreateOrder(OrderRequest request) {
        // 1. 查询产品信息（包含版本号）
        Product product = productMapper.selectById(request.getProductId());
        if (product == null) {
            return OrderResult.fail("产品不存在");
        }
        
        if (product.getStock() < request.getQuantity()) {
            return OrderResult.fail("库存不足");
        }
        
        // 2. 乐观锁更新库存
        int affectedRows = productMapper.updateStockWithVersion(
            request.getProductId(), 
            request.getQuantity(), 
            product.getVersion()
        );
        
        if (affectedRows == 0) {
            // 抛出异常触发重试
            throw new OptimisticLockException("版本冲突");
        }
        
        // 3. 创建订单
        Order order = new Order();
        order.setUserId(request.getUserId());
        order.setProductId(request.getProductId());
        order.setQuantity(request.getQuantity());
        order.setStatus("PAID");
        
        orderMapper.insert(order);
        
        return OrderResult.success(order.getId());
    }
}

自定义异常类

public class OptimisticLockException extends RuntimeException {
    public OptimisticLockException(String message) {
        super(message);
    }
    
    public OptimisticLockException(String message, Throwable cause) {
        super(message, cause);
    }
}

六、批量操作实现

@Service
public class BatchProductService {
    
    @Autowired
    private ProductMapper productMapper;
    
    /**
     * 批量更新产品信息（带乐观锁）
     */
    @Transactional
    public BatchUpdateResult batchUpdateProducts(List<Product> products) {
        try {
            int totalCount = products.size();
            int successCount = productMapper.batchUpdate(products);
            
            return new BatchUpdateResult(totalCount, successCount);
            
        } catch (Exception e) {
            log.error("批量更新失败", e);
            throw new RuntimeException("批量更新失败", e);
        }
    }
    
    /**
     * 批量扣减库存
     */
    @Transactional
    public boolean batchDeductStock(Map<Long, Integer> productQuantities) {
        // 1. 查询所有产品信息
        List<Long> productIds = new ArrayList<>(productQuantities.keySet());
        List<Product> products = productMapper.selectByIds(productIds);
        
        // 2. 验证库存
        for (Product product : products) {
            Integer quantity = productQuantities.get(product.getId());
            if (product.getStock() < quantity) {
                throw new RuntimeException("产品ID: " + product.getId() + " 库存不足");
            }
        }
        
        // 3. 批量更新（在XML中实现乐观锁）
        int affectedRows = productMapper.batchUpdateStock(productQuantities);
        
        return affectedRows == productQuantities.size();
    }
}

批量操作的XML配置

<!-- 添加到 ProductMapper.xml -->
<update id="batchUpdateStock">
    <foreach collection="productQuantities" item="quantity" index="id" separator=";">
        UPDATE products 
        SET stock = stock - #{quantity},
            version = version + 1
        WHERE id = #{id} 
          AND version = (SELECT version FROM products WHERE id = #{id})
          AND stock >= #{quantity}
    </foreach>
</update>

<select id="selectByIds" resultMap="ProductResultMap">
    SELECT id, name, price, stock, version 
    FROM products 
    WHERE id IN 
    <foreach collection="list" item="id" open="(" separator="," close=")">
        #{id}
    </foreach>
</select>

七、工具类和配置

重试工具类

@Component
public class RetryTemplate {
    
    public <T> T executeWithRetry(Callable<T> task, int maxRetries, 
                                 long initialDelay, String operationName) {
        int retryCount = 0;
        
        while (retryCount < maxRetries) {
            try {
                return task.call();
            } catch (Exception e) {
                retryCount++;
                log.warn("{}操作失败，重试第{}次", operationName, retryCount, e);
                
                if (retryCount >= maxRetries) {
                    throw new RuntimeException(operationName + "失败，已达最大重试次数", e);
                }
                
                long delay = initialDelay * (long) Math.pow(2, retryCount - 1);
                try {
                    Thread.sleep(delay);
                } catch (InterruptedException ie) {
                    Thread.currentThread().interrupt();
                    throw new RuntimeException(operationName + "被中断", ie);
                }
            }
        }
        
        throw new RuntimeException(operationName + "失败");
    }
}

使用重试工具类

@Service
public class ProductServiceWithRetryTemplate {
    
    @Autowired
    private ProductMapper productMapper;
    
    @Autowired
    private RetryTemplate retryTemplate;
    
    public boolean deductStockWithRetry(Long productId, Integer quantity) {
        return retryTemplate.executeWithRetry(() -> {
            Product product = productMapper.selectById(productId);
            if (product.getStock() < quantity) {
                throw new RuntimeException("库存不足");
            }
            
            int affectedRows = productMapper.updateStockWithVersion(
                productId, quantity, product.getVersion());
            
            if (affectedRows == 0) {
                throw new OptimisticLockException("版本冲突");
            }
            
            return true;
        }, 3, 100L, "扣减库存");
    }
}

八、测试用例

@SpringBootTest
public class ProductServiceTest {
    
    @Autowired
    private ProductService productService;
    
    @Test
    public void testOptimisticLock() {
        // 模拟并发场景
        int threadCount = 10;
        CountDownLatch latch = new CountDownLatch(threadCount);
        AtomicInteger successCount = new AtomicInteger(0);
        
        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                try {
                    if (productService.deductStock(1L, 1)) {
                        successCount.incrementAndGet();
                    }
                } finally {
                    latch.countDown();
                }
            }).start();
        }
        
        latch.await();
        
        // 验证：成功次数应该等于库存量
        assert successCount.get() <= initialStock;
    }
}

九、监控和日志

@Aspect
@Component
@Slf4j
public class OptimisticLockMonitorAspect {
    
    @Around("execution(* com.example.service..*.*(..)) && @annotation(Retryable)")
    public Object monitorOptimisticLock(ProceedingJoinPoint joinPoint) throws Throwable {
        String methodName = joinPoint.getSignature().getName();
        long startTime = System.currentTimeMillis();
        int retryCount = 0;
        
        while (true) {
            try {
                return joinPoint.proceed();
            } catch (OptimisticLockException e) {
                retryCount++;
                log.info("方法 {} 乐观锁冲突，第{}次重试", methodName, retryCount);
                
                if (retryCount >= 3) {
                    log.warn("方法 {} 乐观锁冲突达到最大重试次数", methodName);
                    throw e;
                }
                
                Thread.sleep(100 * retryCount);
            }
        }
    }
}

// 自定义注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Retryable {
    int maxAttempts() default 3;
    long backoff() default 100;
}

总结

MyBatis 实现乐观锁的关键点：

  1. 版本号字段：在表中添加 version 字段
  2. UPDATE语句：在更新时检查版本号 WHERE id = #{id} AND version = #{version}
  3. 返回值判断：根据 affectedRows 判断是否更新成功
  4. 重试机制：使用循环或工具类实现自动重试
  5. 异常处理：自定义异常类处理乐观锁冲突

这种实现方式比 JPA 的 @Version 注解更灵活，可以精确控制乐观锁的逻辑。

springboot+mybatis实现乐观锁
猪大肠的博客
09-02 4040
最近公司接了个商城系统的项目，在秒杀商品这块的设计上，因为我们需要考虑到秒杀时，在线的人数可能会非常多，所以需要考虑高并发的情况； 一、在线下单代码 1.1、数据库设计 这里我们简单建立两个表 goods和order表 /*货物表*/ CREATE TABLE `goods` ( `id` int NOT NULL AUTO_INCREMENT COMMENT '商品id', `goods_name` varchar(255) DEFAULT NULL COMMENT '商品名称', `stoc
Mybatis Plus乐观锁实现
D_J_Dragon的博客
08-27 1619
乐观锁的主要作用在于提高系统的并发性能和减少锁冲突，同时保证数据的一致性。‌其原理简单来说就是，在修改数据的时候，判断数据是否被其他人改过，如果已被其他人改过，则修改失败。
MyBatis-Plus实现乐观锁
西瓜游侠的博客
09-25 3729
MyBatis-Plus是通过version机制实现乐观锁的。 大致思路： 取出记录，携带记录的当前version； 更新记录的时候，比较记录当前的version是否有改变； 如果version未改变，则更新记录，并更新version，一般值+1； 如果version改变了，则不更新记录。 version机制的核心思想就是，假设发生并发冲突的几率很低，只有当更新数据的时候采取检查是否有冲突，而判断是否有冲突的依据就是version的值是否被改变了。 配置 MyBatis-Plus中配置乐观锁分两步：
浅谈Mybatis乐观锁插件
08-28
主要介绍了浅谈Mybatis乐观锁插件，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Mybatis乐观锁插件
若鱼的专栏
06-24 1万+
背景：对于数据库的同一条记录，假如有两个人同时对数据进行了修改，然后最终同步到数据库的时候，因为存在着并发，产生的结果是不可预料的。最简单的解决方式就是通过给表的记录加一个version字段，记录在修改的时候需要比较一下version是否匹配，如果匹配就更新，不匹配就直接失败。更新成功则把version+1，也就是所谓的乐观锁。当然这样的逻辑最好能做到对开发人员透明，本插件就是来做这件事情的。
mysql乐观锁总结和实践
chenzhou123520的专栏
05-08 2064
上一篇文章《MySQL悲观锁总结和实践》谈到了MySQL悲观锁，但是悲观锁并不是适用于任何场景，它也有它存在的一些不足，因为悲观锁大多数情况下依靠数据库的锁机制实现，以保证操作最大程度的独占性。如果加锁的时间过长，其他用户长时间无法访问，影响了程序的并发访问性，同时这样对数据库性能开销影响也很大，特别是对长事务而言，这样的开销往往无法承受。所以与悲观锁相对的，我们有了乐观锁，具体参见下面介绍： ...
mybatis 乐观锁实现
进行中
06-17 2556
mybatis乐观锁 加一个注解就行@Version @Version @Target({ElementType.FIELD, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) public @interface Version { Class<? extends NextVersion> nextVersion() default DefaultNextVersion.class; } 说明：可被注...
MybatisPlus 实现乐观锁
weixin_73735141的博客
01-17 2890
乐观锁就是持比较乐观态度的锁。在操作数据时非常乐观，认为别的线程不会同时修改数据，所以不会上锁，但是在更新的时候会判断在此期间别的线程有没有更新过这个数据。
SpringBoot整合MyBatis实现乐观锁和悲观锁的示例
08-25
SpringBoot整合MyBatis实现乐观锁和悲观锁的示例 在本文中，我们将学习如何使用SpringBoot和MyBatis来实现乐观锁和悲观锁。我们将通过示例代码来介绍这两种锁的实现方式，帮助读者更好地理解和使用它们。 一、悲观...
浅谈mybatis 乐观锁实现,解决并发问题
08-24
浅谈MyBatis乐观锁实现，解决并发问题 MyBatis乐观锁是一种解决并发问题的机制，在高并发的业务场景中，乐观锁可以避免数据的并发修改。...同时，通过示例代码，可以看到如何使用MyBatis实现乐观锁机制。
locker:mybatis乐观锁插件，MyBatis乐观锁插件
03-15
MyBatis乐观锁插件3.0，全面升级，更加复杂，更加强大 旧版本MyBatis乐观锁插件1.x请移步至wiki文档： MyBatis乐观储物柜插件 文档： 开始... <dependency> <groupId>com.github.dreamroute</groupId> <artifactId>locker-spring-boot-starter</artifactId> <version>latest version</version> </dependency> 最新版本： 描述：本插件主要是为了解决MyBatis Generator自动生成的update标签不带乐观锁的问题，为开发带来比较简单优雅的实现方式。 1.使用方式：在mybatis配置文件中加入如下配置，就完成了。 1.Spring Boot方式：日期locker-spring-boot-s
SpringBoot mybatis 乐观锁重试机制代码实现
03-05
SpringBoot mybatis 乐观锁重试机制代码实现 顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。...
mybatis实现乐观锁
最新发布
11-11
</think>### MyBatis实现乐观锁的具体方法 在MyBatis中实现乐观锁（特别是使用MyBatis-Plus框架时），主要通过以下步骤完成： --- #### **1. 实体类添加版本号字段** 在数据库表中添加`version`字段（建议类型为`...
干翻Mybatis源码系列之第十二篇：基于Mybatis Plugins做一个乐观锁
热门推荐
七叔的博客
06-26 1万+
不从恶人的计谋，不站罪人的道路，不坐亵慢人的座位，惟喜爱耶和华的律法，昼夜思想，这人便为有福！他要像一棵树栽在溪水旁，按时候结果子，叶子也不枯干。凡他所做的尽都顺利。
[Mybatis-Plus笔记] MybatisPlus-06-乐观锁
Cey_Tao的博客
09-18 915
user1 进行更新后，version 值也自动被改变，所以 user1 可以继续进行更新操作，但 user2 想要更新就必须再进行一次查询来读取新的数据。可见更新时的 WHERE 语句中自动加入了对 version 的判断，如果数据库中的 version 值与当前 version 不相等，则不会更新。乐观锁指，对于同一个数据，某一个事务正在进行时，不会阻止其它事务的操作，但在更新操作时会判断此前是否有其它事务进行了更新。换句话讲，如果当前事务读取的数据是过时的，那么此事务不被允许进行更新操作。
MyBatis-Plus 乐观锁
Flying_Fish_roe的博客
09-23 3128
乐观锁是乐观并发控制的一种实现方式，它假设多个事务并发操作数据时不会产生冲突，或者认为冲突的概率较低，因此在每次操作时不会直接锁定资源。它的基本思路是在数据的每条记录中添加一个版本号字段，表示该数据的版本。当用户更新数据时，会检查该版本号是否发生变化。在读取数据时，同时读取该记录的版本号。在更新数据时，检查当前数据的版本号是否与读取时一致。如果版本号一致，则说明数据没有被其他事务修改，可以执行更新操作，并将版本号加 1。
保姆级教程手把手学会使用mybatisplus实现乐观锁
weixin_64537269的博客
05-23 1830
MybatisPlus实现乐观锁机制主要是通过在数据表中添加一个版本号字段（如version），然后在更新数据时，将当前版本号与数据库中的版本号进行比较，如果一致则执行更新操作，并更新版本号。MybatisPlus提供了@Version注解，可以直接在实体类的字段上使用，以实现乐观锁功能。具体步骤如下：在实体类中添加一个整数类型的字段，用于表示版本号，使用@Version注解标注。在需要更新的SQL语句中，使用MybatisPlus提供的内置方法setSqlSet()和setSqlWhere()来设置字段
mybatis插件-乐观锁
weixin_34364071的博客
04-03 372
一、业务背景 我司使用mysql数据库的InnoDB引擎，在执行数据库更新操作时使用了select ...... for update语句，在一定情况下可能导致行级锁转表级锁，在高并发的场景下导致性能低下，故而打算使用乐观锁解决部分性能问题。 系统已经上线，修改所有更新代码改动量大，故决定通过插件方式。 二、乐观锁简介 乐观锁通过在数据库中增加锁字段，例如version，更新语句如下 u...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

思静鱼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值