数据库悲观锁和乐观锁使用Mybatis

使用mysql做数据库，mybatis做orm的系统中，mybatis的乐观锁和悲观锁实际上就是mysql的乐观锁和悲观锁。

实例中使用springboot整合mybatis，一并记录了。

添加依赖：

1. <dependency>
2. <groupId>mysql </groupId>
3. <artifactId>mysql-connector-java </artifactId>
4. </dependency>
6. <groupId>org.mybatis.spring.boot </groupId>
7. <artifactId>mybatis-spring-boot-starter </artifactId>
8. <version>1.1.1 </version>

application.properties配置：

1. mybatis. type-aliases- package=com.lin.learn.mysql
2. spring.datasource.driverClassName = com.mysql.jdbc.Driver
3. spring.datasource.url = jdbc:mysql: //192.168.0.103:3306/mysql?useUnicode=true&characterEncoding=utf-8
4. spring.datasource.username = root
5. spring.datasource.password = root

实体类：

1. publicclassTestEntity{
2. privateint id;
3. privateint count;
4. privateint version;
5. publicintgetId(){
6. return id;
7. }
8. publicvoidsetId(int id){
9. this.id = id;
11. publicintgetCount(){
12. return count;
14. publicvoidsetCount(int count){
15. this.count = count;
17. publicintgetVersion(){
18. return version;
20. publicvoidsetVersion(int version){
21. this.version = version;

加上相关注解：

1. @SpringBootApplication
2. @MapperScan( "com.lin.learn.mysql")
3. publicclassApp{
4. publicstaticvoidmain(String[] args){
5. ApplicationContext applicationContext = SpringApplication.run(App.class, args);

乐观锁

就是使用一个version字段标识数据的当前版本，每次更新数据的时候同时更新version = version + 1，where条件中需要加上version等于当前事务查询出的数据的version，如果version的值已经改变，则更新失败。

Mapper：

1. publicinterfaceTestMapper{
2. @Select("select * from `test` where `id` = #{id} for update")
3. @Results({
4. @Result(column = "id", property = "id", javaType = Integer.class),
5. @Result(column = "count", property = "count", javaType = Integer.class),
6. @Result(column = "version", property = "version", javaType = Integer.class)
7. })
8. public TestEntity getById( @Param("id") int id);
9. @Update("update `test` set `count` = #{count}, `version` = #{version} + 1 where `id` = #{id} and `version` = #{version}")
10. public int update(TestEntity testEntity);

业务代码，就是数据库一个数据修改：

1. import org.springframework.stereotype.Component;
2. import org.springframework.transaction.annotation.Transactional;
3. import javax.annotation.Resource;
4. @Component
5. publicclassTestService{
6. @Resource
7. private TestMapper mapper;
8. publicvoidincreaseCount(int id){
9. while ( true) {
10. try {
11. TestEntity testEntity = mapper.getById(id);
12. testEntity.setCount(testEntity.getCount() + 1);
13. int updateCount = mapper.update(testEntity);
14. if(updateCount > 0) {
15. break;
17. } catch (Exception e) {
18. e.printStackTrace();

测试：

1. import com.lin.learn.mysql.TestService;
2. import org.mybatis.spring.annotation.MapperScan;
3. import org.springframework.boot.SpringApplication;
4. import org.springframework.boot.autoconfigure.SpringBootApplication;
5. import org.springframework.context.ApplicationContext;
11. TestService service = applicationContext.getBean(TestService.class);
12. new Thread( new Runnable() {
13. @Override
14. publicvoidrun(){
15. for( int i = 0; i < 10; i++) {
16. service.increaseCount( 3);
19. }).start();

上面代码执行后数据库数据最终结果得到正确的数据。

悲观锁

本质上就是用select for update锁行，需要注意的是如果where子句条件没有命中索引将导致锁表。并且查询和更新操作都需要在同一个事务里里面。

在Mapper添加新的更新方法：

1. import org.apache.ibatis.annotations.*;
12. @Update("update `test` set `count` = #{count} where `id` = #{id}")
13. public void updateNoSafe(TestEntity testEntity);

在业务代码里面添加新的方法：

22. @Transactional
23. publicvoidincreaseNoSafe(int id){
27. mapper.updateNoSafe(testEntity);

这里是用@Transaction注解声明这个更新数据的事务。

16. service.increaseNoSafe( 3);