mybatis使用乐观锁和悲观锁

这篇具有很好参考价值的文章主要介绍了mybatis使用乐观锁和悲观锁。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

悲观锁和乐观锁的概念:

悲观锁:就是独占锁,不管读写都上锁了。传统的关系型数据库里边就用到了很多这种锁机制,比如行锁,表锁等,读锁,写锁等,都是在做操作之前先上锁。Java中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。

乐观锁:不上锁,读取的时候带版本号,写入的时候带着这个版本号,如果不一致就失败,乐观锁适用于多读的应用类型,因为写多的时候会经常失败。

2.1 Maven依赖
需要引入spring-boot-starter-data-jpa,这里要访问数据库,所以要依赖数据库相关jar包。

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-dbcp2</artifactId>
        </dependency>

2.2 配置文件
在application.properties 中需要添加下面的配置:

spring.datasource.type=org.apache.commons.dbcp2.BasicDataSource
spring.datasource.dbcp2.max-wait-millis=60000
spring.datasource.dbcp2.min-idle=20
spring.datasource.dbcp2.initial-size=2
spring.datasource.dbcp2.validation-query=SELECT 1
spring.datasource.dbcp2.connection-properties=characterEncoding=utf8
spring.datasource.dbcp2.validation-query=SELECT 1
spring.datasource.dbcp2.test-while-idle=true
spring.datasource.dbcp2.test-on-borrow=true
spring.datasource.dbcp2.test-on-return=false

spring.datasource.driverClassName = com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/boot?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC
spring.datasource.username=cff
spring.datasource.password=123456


mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

这里面,包含了数据库连接信息、数据源的连接池配置信息、mybatis配置信息。

spring.datasource.dbcp2是配置dbcp2的连接池信息;
spring.datasource.type指明数据源的类型;
最上面的spring.datasource.xxx指明数据库连接池信息;
mybatis.configuration.log-impl指明mybatis的日志打印方式
三、悲观锁
悲观锁在数据库的访问中使用,表现为:前一次请求没执行完,后面一个请求就一直在等待。

3.1 Dao层
数据库要实现悲观锁,就是将sql语句带上for update即可。 for update 是行锁

所在mybatis的查询sql加上for update,就实现了对当前记录的锁定,就实现了悲观锁。

UserInfoDao :

package com.cff.springbootwork.mybatislock.dao;

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

import cn.pomit.springwork.mybatislock.domain.UserInfo;

@Mapper
public interface UserInfoDao {

    @Select({
        "<script>",
            "SELECT ",
            "user_name as userName,passwd,name,mobile,valid, user_type as userType, version as version",
            "FROM user_info_test",
            "WHERE user_name = #{userName,jdbcType=VARCHAR} for update",
       "</script>"})
    UserInfo findByUserNameForUpdate(@Param("userName") String userName);

    @Update({
        "<script>",
        " update user_info_test set",
        " name = #{name, jdbcType=VARCHAR}, mobile = #{mobile, jdbcType=VARCHAR},version=version+1 ",
        " where user_name=#{userName}",
        "</script>"
    })
    int update(UserInfo userInfo);

    @Insert({
        "<script>",
        "INSERT INTO user_info_test",
        "( user_name,",
        "name ,",
        "mobile,",
        "passwd,",
        "version",
         ") ",
        " values ",
         "( #{userName},",
         "#{name},",
         "#{mobile},",
         "#{passwd},",
         "#{version}",
        " ) ",
        "</script>"
    })
    int save(UserInfo entity);
}

这里,findByUserNameForUpdate的sql中加上了for update。update就是普通的更新而已。

3.2 Service层
更新数据库前,先调用findByUserNameForUpdate方法,使上面的配置的悲观锁锁定表记录,然后再更新。

UserInfoService :

package com.cff.springbootwork.mybatislock.service;

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

import cn.pomit.springwork.mybatislock.domain.UserInfo;
import cn.pomit.springwork.mybatislock.mapper.UserInfoDao;

@Service
public class UserInfoService {
    @Autowired
    UserInfoDao userInfoDao;

    public void save(UserInfo entity) {
        entity.setVersion(0);
        userInfoDao.save(entity);
    }


    @Transactional
    public UserInfo getUserInfoByUserNamePessimistic(String userName) {
        return userInfoDao.findByUserNameForUpdate(userName);
    }

    @Transactional
    public void updateWithTimePessimistic(UserInfo entity, int time) throws InterruptedException {      
        UserInfo userInfo = userInfoDao.findByUserNameForUpdate(entity.getUserName());
        if (userInfo == null)
            return;

        if (!StringUtils.isEmpty(entity.getMobile())) {
            userInfo.setMobile(entity.getMobile());
        }
        if (!StringUtils.isEmpty(entity.getName())) {
            userInfo.setName(entity.getName());
        }
        Thread.sleep(time * 1000L);

        userInfoDao.update(userInfo);
    }

    @Transactional
    public void updatePessimistic(UserInfo entity) {
        UserInfo userInfo = userInfoDao.findByUserNameForUpdate(entity.getUserName());
        if (userInfo == null)
            return;

        if (!StringUtils.isEmpty(entity.getMobile())) {
            userInfo.setMobile(entity.getMobile());
        }
        if (!StringUtils.isEmpty(entity.getName())) {
            userInfo.setName(entity.getName());
        }

        userInfoDao.update(userInfo);
    }

}

测试中,我们在update方法中sleep几秒,其他线程的update将一直等待。

3.3 测试Web层
可以先调用/update/{time}接口,延迟执行,然后马上调用/update接口,会发现,/update接口一直在等待/update/{time}接口执行完成。

MybatisPessLockRest :

package com.cff.springbootwork.mybatislock.web;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import cn.pomit.springwork.mybatislock.domain.UserInfo;
import cn.pomit.springwork.mybatislock.service.UserInfoService;

/**
 * 测试悲观锁
 * 
 * @author fufei
 *
 */
@RestController
@RequestMapping("/mybatispesslock")
public class MybatisPessLockRest {

    @Autowired
    UserInfoService userInfoService;

    @RequestMapping(value = "/detail/{name}", method = { RequestMethod.GET })
    public UserInfo detail(@PathVariable("name") String name) {
        return userInfoService.getUserInfoByUserNamePessimistic(name);
    }

    @RequestMapping(value = "/save")
    public String save(@RequestBody UserInfo userInfo) throws InterruptedException {
        userInfoService.save(userInfo);
        return "0000";
    }

    @RequestMapping(value = "/update/{time}")
    public String update(@RequestBody UserInfo userInfo, @PathVariable("time") int time) throws InterruptedException {
        userInfoService.updateWithTimePessimistic(userInfo, time);

        return "0000";
    }

    @RequestMapping(value = "/update")
    public String update(@RequestBody UserInfo userInfo) throws InterruptedException {
        userInfoService.updatePessimistic(userInfo);
        return "0000";
    }
}

四、乐观锁
数据库访问dao层还是3.1那个UserInfoDao。

4.1 Dao层
UserInfoDao更新时,需要携带version字段进行更新:and version = #{version}。如果version不一致,是不会更新成功的,这时候,我们的select查询是不能带锁的。

UserInfoDao :

package com.cff.springbootwork.mybatislock.dao;

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

import cn.pomit.springwork.mybatislock.domain.UserInfo;

@Mapper
public interface UserInfoDao {
    @Select({
        "<script>",
            "SELECT ",
            "user_name as userName,passwd,name,mobile,valid, user_type as userType, version as version",
            "FROM user_info_test",
            "WHERE user_name = #{userName,jdbcType=VARCHAR}",
       "</script>"})
    UserInfo findByUserName(@Param("userName") String userName);

    @Update({
        "<script>",
        " update user_info_test set",
        " name = #{name, jdbcType=VARCHAR}, mobile = #{mobile, jdbcType=VARCHAR},version=version+1 ",
        " where user_name=#{userName} and version = #{version}",
        "</script>"
    })
    int updateWithVersion(UserInfo userInfo);

    @Insert({
        "<script>",
        "INSERT INTO user_info_test",
        "( user_name,",
        "name ,",
        "mobile,",
        "passwd,",
        "version",
         ") ",
        " values ",
         "( #{userName},",
         "#{name},",
         "#{mobile},",
         "#{passwd},",
         "#{version}",
        " ) ",
        "</script>"
    })
    int save(UserInfo entity);
}

4.2 Service层
service层我们做一下简单的调整。更新数据库前,先调用findByUserName方法,查询出当前的版本号,然后再更新。

UserInfoService :

package com.cff.springbootwork.mybatislock.service;

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

import cn.pomit.springwork.mybatislock.domain.UserInfo;
import cn.pomit.springwork.mybatislock.mapper.UserInfoDao;

@Service
public class UserInfoService {
    @Autowired
    UserInfoDao userInfoDao;
    public UserInfo getUserInfoByUserName(String userName){
        return userInfoDao.findByUserName(userName);
    }

    public void save(UserInfo entity) {
        entity.setVersion(0);
        userInfoDao.save(entity);
    }
    @Transactional
    public void updateWithTimeOptimistic(UserInfo entity, int time) throws Exception {      
        UserInfo userInfo = userInfoDao.findByUserName(entity.getUserName());
        if (userInfo == null)
            return;

        if (!StringUtils.isEmpty(entity.getMobile())) {
            userInfo.setMobile(entity.getMobile());
        }
        if (!StringUtils.isEmpty(entity.getName())) {
            userInfo.setName(entity.getName());
        }
        Thread.sleep(time * 1000L);

        int ret = userInfoDao.updateWithVersion(userInfo);
        if(ret < 1)throw new Exception("乐观锁导致保存失败");
    }

    @Transactional
    public void updateOptimistic(UserInfo entity) throws Exception {
        UserInfo userInfo = userInfoDao.findByUserName(entity.getUserName());
        if (userInfo == null)
            return;

        if (!StringUtils.isEmpty(entity.getMobile())) {
            userInfo.setMobile(entity.getMobile());
        }
        if (!StringUtils.isEmpty(entity.getName())) {
            userInfo.setName(entity.getName());
        }

        int ret = userInfoDao.updateWithVersion(userInfo);
        if(ret < 1)throw new Exception("乐观锁导致保存失败");
    }

}

4.2 测试Web层
可以先调用/update/{time}接口,延迟执行,然后马上调用/update接口,会发现,/update接口不会等待/update/{time}接口执行完成,读取完版本号能够成功更新数据,但是/update/{time}接口等待足够时间以后,更新的时候会失败,因为它的版本和数据库的已经不一致了。

注意: 这里更新失败不会抛异常,但是返回值会是0,即更新不成功,需要自行判断。jpa的乐观锁可以抛出异常,手动catch到再自行处理。

MybatisOptiLockRest :文章来源地址https://www.toymoban.com/news/detail-683254.html

package com.cff.springbootwork.mybatislock.web;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import cn.pomit.springwork.mybatislock.domain.UserInfo;
import cn.pomit.springwork.mybatislock.service.UserInfoService;

/**
 * 测试乐观锁
 * @author fufei
 *
 */
@RestController
@RequestMapping("/mybatislock")
public class MybatisOptiLockRest {

    @Autowired
    UserInfoService userInfoService;

    @RequestMapping(value = "/detail/{name}", method = { RequestMethod.GET })
    public UserInfo detail(@PathVariable("name") String name) {
        return userInfoService.getUserInfoByUserName(name);
    }

    @RequestMapping(value = "/save")
    public String save(@RequestBody UserInfo userInfo) throws InterruptedException {
        userInfoService.save(userInfo);
        return "0000";
    }

    @RequestMapping(value = "/update/{time}")
    public String update(@RequestBody UserInfo userInfo, @PathVariable("time") int time) throws Exception {
        userInfoService.updateWithTimeOptimistic(userInfo, time);

        return "0000";
    }

    @RequestMapping(value = "/update")
    public String update(@RequestBody UserInfo userInfo) throws Exception {
        userInfoService.updateOptimistic(userInfo);
        return "0000";
    }
}

到了这里,关于mybatis使用乐观锁和悲观锁的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • MySQL乐观锁与悲观锁

    遇见并发情况,需要保证数据的准确性,也就是与正确的预期一致,此时就会用到锁。 锁是在并发下控制程序的执行逻辑,以此来保证数据按照预期变动。 如果不加锁,并发情况下的可能数据不一致的情况,这是个概率问题。 乐观锁很乐观,假设数据一般情况不会造成冲突

    2024年01月23日
    浏览(34)
  • JavaEE 初阶篇-深入了解 CAS 机制与12种锁的特征(如乐观锁和悲观锁、轻量级锁与重量级锁、自旋锁与挂起等待锁、可重入锁与不可重入锁等等)

    🔥博客主页: 【 小扳_-CSDN博客】 ❤感谢大家点赞👍收藏⭐评论✍ 文章目录         1.0 乐观锁与悲观锁概述         1.1 悲观锁(Pessimistic Locking)         1.2 乐观锁(Optimistic Locking)         1.3 区别与适用场景         2.0 轻量级锁与重量级锁概述         2.1 真正加

    2024年04月16日
    浏览(34)
  • Mysql--技术文档--悲观锁、乐观锁-《控制并发机制简单认知、深度理解》

            首先在谈到并发控制机制的时候,我们通常会提及两种重要的锁策略。悲观锁(Pessimistic Locking)和乐观锁(Optimistic Locking)。这两个是在处理并发的时候采取的不同思路。         悲观锁: 悲观锁机制认为并发操作中会有冲突,因此默认情况下假设会出现并

    2024年02月10日
    浏览(43)
  • 悲观锁&乐观锁

    1.悲观锁 悲观锁介绍(百科): 悲观锁,正如其名,它指的是对数据被外界(包括本系统当前的其他事务,以及来自外部系统的事务处理)修改持保守态度,因此,在整个数据处理过程中,将数据处于锁定状态。悲观锁的实现,往往依靠数据库提供的锁机制(也只有数据库层

    2024年02月08日
    浏览(32)
  • [锁]:乐观锁与悲观锁

    摘要:乐观锁;悲观锁;实现方法;本地锁;分布式锁;死锁;行级锁;表级锁 问题 : ① 在多个线程访问共享资源时,会发生线程安全问题,例如:在根据订单号生成订单时,若用户第一次由于某种原因(网络连接不稳定)请求失败,则会再次发生请求,此时便会产生同一

    2024年02月08日
    浏览(35)
  • django实现悲观锁乐观锁

    前期准备 1.原生mysql悲观锁 2.orm实现上述(悲观锁)  3 乐观锁秒杀--》库存还有,有的人就没成功  

    2024年02月12日
    浏览(40)
  • [锁]:乐观锁、悲观锁与死锁

    摘要:乐观锁;悲观锁;实现方法;本地锁;分布式锁;死锁;行级锁;表级锁 问题 : ① 在多个线程访问共享资源时,会发生线程安全问题,例如:在根据订单号生成订单时,若用户第一次由于某种原因(网络连接不稳定)请求失败,则会再次发生请求,此时便会产生同一

    2024年02月08日
    浏览(35)
  • redis实战---乐观锁与悲观锁

    最近一直在研究Redis,今天学习到了乐观锁与悲观锁的部分,在这里进行总结。 Redis是一个内存中的键值存储系统,支持多种数据结构,如字符串、哈希、列表等。 Redis提供了两种锁机制,即乐观锁和悲观锁。 乐观锁是一种乐观的并发控制策略,它认为数据在大多数情况下

    2023年04月09日
    浏览(36)
  • Java并发(十四)----悲观互斥与乐观重试

    1. 悲观互斥 互斥实际是悲观锁的思想 例如,有下面取款的需求 用互斥来保护 2. 乐观重试 另外一种是乐观锁思想,它其实不是互斥

    2024年02月15日
    浏览(41)
  • Redis:事务操作以及监控(悲观锁,乐观锁)

    事务操作是指:在一组操作中,有很多的命令,如果在这组操作时,有一个命令出现的了bug,那么这组这组操作会进行回滚,将环境还原成没有开始这组操作时的状态。在MySQL等关系型数据库中事务操作可能会出现这种结果,但是在redis则也可能出现其他的错误,那就是语法问

    2024年02月05日
    浏览(38)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包