事物以及事物隔离线的代码详解

叁歲伎倆 2022-04-23 07:04 123阅读 0赞

## 前言 ##

不多bb了，直接上代码和注释，看不懂的找博主

数据库初始状态

//数据库中 id = 1 name = 0000 balance = 2222
       //数据库中 id = 2 name = aaaa balance = null
    
       //other id = 1 name = AAAA
       //other id = 2 name = BBBB

总结：

### 1、事物开启的时间 ###

如果service中即使一开始就表明了执行事物，但是事物开启的时间也要算在执行数据库语句的时候开开始

举例：一开始表1中name为0000，打上断点，先进入service，不执行sql语句。这个时候手动修改数据库中的name为1111，再执行查询语句，我们会发现取到了那么为1111的值，而不是0000（安装可重复读取的思想解决）（不论是可重复读`REPEATABLE_READ`还是不可重复读`READ_COMMITTED`）

如果是更新操作，我们在当前事物中进行了更新操作，其他事物更新相同id的数据，则其他事物不能修改，因为更新操作会将这条数据锁住，其他事物不能执这条id的数据，其他的id是可以任意修改的的，除非等当前事物执行完成或者当前事物回滚（总之就是当前事物结束）

### 2、可重复读取`REPEATABLE_READ` ###

事物开始执行的时候，相当于我们将数据库中进行了一个拍照，不论其他事物修改了其他或者本表任何表的任何数据，我们通过find看到的数据都是拍照的数据,也就是说即使其他事物对我们拿到的数据进行了更新，或者添加了新的数据，我们还是看不到。我们只能拿到照片中的数据。

### 3、不可重复读`READ_COMMITTED` 一般情况下建议使用 ###

1、只要不是我们从当前事物中取到的数据，其他事物修改了其他或者本表任何表的任何数据，我们查询的话，就是显示最新的数据

2、如果我们正在执行的事物取到了数据，即使别的事物修改成什么样子，我们再查询的话，还是一样的（不管是hibernate查询还是sql查询），相当于只给我们当前查询过的数据拍了照片（其实这个是我实际项目中得到的结果,但是关于网上给出的其他事物修改提交了，这里再次执行，应该是得到最新的数据）

### 4、update操作和重新赋值给另一个对象实体中内容变化不变化 ###

update 原生 sql语句不会更新当前实体对象，  
如果是一个根据id 进行更新，并且返回了结果 ，hibernate的操作会即使重新new一个对象出来也会对原理的对象 进行更新

DemoEntity demoEntity =  demoEntityRepository.findOne(id);
    
    
    
        isolationService.updateName(id,"zhang123456" ); 
        
        @Modifying
        @Query("UPDATE DemoEntity d set d.name = ?2 where d.id = ?1")
        int updateName(Long id ,String name);
        
        //即使重新赋值了新对象one，上面的demoEntity 也会跟着变化，一个事物中的数据，具有连贯性，update语句，则是返回了一个当前行。
        
                DemoEntity one = isolationService.transRequirs(1L,"transRequirsOne");

下面主要是可重复读取的数据
    
    package com.hlj.springboot.dome.common.moudle.service;
    
    import com.hlj.springboot.dome.common.entity.DemoEntity;
    import com.hlj.springboot.dome.common.entity.OtherEntity;
    import com.hlj.springboot.dome.common.entity.repository.DemoEntityRepository;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Isolation;
    import org.springframework.transaction.annotation.Propagation;
    import org.springframework.transaction.annotation.Transactional;
    
    import javax.annotation.Resource;
    
    /** * 作者 ：HealerJean * 日期 ：2019/1/23 下午8:02. * 类描述： */
    @Service
    public class IsolationStartService { 
    
        @Resource
        private DemoEntityRepository demoEntityRepository ;
    
        @Resource
        private IsolationService isolationService ;
    
    
        @Transactional(isolation = Isolation.READ_COMMITTED ,propagation = Propagation.REQUIRED,rollbackFor = Exception.class)
        public DemoEntity startTransactional(Long id) { 
    
            //数据库中 id = 1 name = 0000 balance = 2222
            //数据库中 id = 2 name = aaaa balance = null
    
            //other id = 1 name = AAAA
            //other id = 2 name = BBBB
    
            //这个时候修改id为1的name为1111，以下查询还没有开启，表明我们的事物目前为止其实还没有开启，因为没有涉及到数据库的操作，有了数据库操作，才会真正开启事物
            DemoEntity demoEntity =  demoEntityRepository.findOne(id);
            demoEntity.setName("startTransactional"); //还没有保存到数据库中，因为事物还没有提交，方法运行结束才会提现目前开启的这个事物，除非中间出现独立事物
            System.out.println(demoEntity);     //DemoEntity(id=1, name=startTransactional, balance=2222)
    
            //开始独立事物直接保存数据，直接在数据库中有显示
            DemoEntity transRequirsNew =   isolationService.transRequirsNew(id,"transRequirsNew");
            System.out.println(transRequirsNew); //DemoEntity(id=1, name=transRequirsNew, balance=2222)
    
            //解释：即使独立事物修改过，我们这里还是不会变，还是本事物中的数据(因为是两个事物，具有隔离性)
            System.out.println(demoEntity);  //DemoEntity(id=1, name=startTransactional, balance=2222)
    
            //当前事物下保存数据，上面的额startTransactional 事物还没有提交，所以和一开始的状态是一致的
            demoEntity = isolationService.transRequirs(id,"transRequirs");
            System.out.println(demoEntity) ; //DemoEntity(id=1, name=transRequirs, balance=2222)
    
            // 目前，直接看数据库中，name应该能是transRequirsNew， 手动修改数据库中的 name为 3333
            //读取已经提交的数据,这里没有开启独立事物，所以即使配置了，读已提交也不会生效，因为再我们这个方法一开始的时候，就已经确定了隔离性质
            demoEntity = isolationService.isoLationReadCommitedFind(id);
            System.out.println(demoEntity); // DemoEntity(id=1, name=transRequirs, balance=2222)
    
    
    
            // 可重复读 这个时候我们修改 2中的数据为 bbbb，会发现这个时候查询的时候，下面还为aaa ，
            // READ_COMMITTED 可重复读取：修改了之后，我们查询到的数据库是bbbb，说明READ_COMMITTED 生效了
            DemoEntity two = isolationService.transRequirsFind(2L);
            System.out.println(two) ;
            //可重复读 DemoEntity(id=2, name=aaaa, balance=null)
            //READ_COMMITTED DemoEntity(id=2, name=bbbb, balance=null)
    
    
            //下面一起修改了即使换一个变量名字，demoEntity的变量还是会跟着变的
            DemoEntity one = isolationService.transRequirs(1L,"transRequirsOne");
            System.out.println(one) ; //DemoEntity(id=1, name=transRequirsOne, balance=2222)
            System.out.println(demoEntity) ; //DemoEntity(id=1, name=transRequirsOne, balance=2222)
    
            //可重复读 这个时候直接修改 这张表中的数据为CCCC，我们会发现本事物中查询的还是之前的结果AAAA,说明本事物开启之后，就会对数据库中的数据进行锁定（相当于是拍了张照片）
            //READ_COMMITTED 这个时候直接修改数据库 这张表中的数据为CCCC， 这里查询得到的是CCCC，说明不可重复读生效了
            OtherEntity otherEntity = isolationService.findOther(1L);
            System.out.println(otherEntity);
            //可重复读 OtherEntity(id=1, name=AAAA)
            //READ_COMMITTED OtherEntity(id=1, name=CCC)
    
    
            //可重复读 这个时候直接修改 这张表中的数据为DDDD，我们会发现本事物中查询的还是之前的结果BBBB
            //READ_COMMITTED 这个时候直接修改数据库 这张表中的数据为CCCC， 这里查询得到的是CCCC，说明不可重复读生效了
            OtherEntity otherEntityTwo = isolationService.findOther(2L);
            System.out.println(otherEntityTwo);
            //可重复读 OtherEntity(id=2, name=BBBB)
            //READ_COMMITTED OtherEntity(id=2, name=DDDD)
    
    
            //指定id更新不会影响demoEntity 现在的数据
            isolationService.updateName(id,"zhang123456" );
            System.out.println(demoEntity); //DemoEntity(id=1, name=transRequirsOne, balance=2222)
    
            System.out.println(transRequirsNew);//DemoEntity(id=1, name=transRequirsNew, balance=2222)
            return demoEntity;
    
            //上面两种的最终数据库中就 都变成了
            // id =1 name= zhang123456 balance = 2222
            // id =2 name= bbb balance = nulll
    
            //other表 id= 1 name =CCCC
            //id = 2 name =DDDD
        }
    
    
    }

## 1、接口 ##

package com.hlj.springboot.dome.common.moudle.service;
    
    import com.hlj.springboot.dome.common.entity.DemoEntity;
    import com.hlj.springboot.dome.common.entity.OtherEntity;
    
    /** * 作者 ：HealerJean * 日期 ：2019/1/23 下午7:34. * 类描述： */
    public interface IsolationService { 
    
    
    
        /** * 方法中的事物为入口方法的事物 * @param id * @return */
        DemoEntity  transRequirs(Long id,String name);
        DemoEntity  transRequirsFind(Long id);
    
        /** * 开启一个事物 * @param id * @return */
        DemoEntity  transRequirsNew (Long id,String name);
    
    
        /** * 事物隔离级别为 读已提交（） * @param id * @return */
        DemoEntity   isoLationReadCommitedFind(Long id) ;
    
    
        int updateName(Long id,String name);
    
    
        OtherEntity findOther(Long id);
    
    }

## 3、接口实现类 ##

package com.hlj.springboot.dome.common.moudle.service.impl;
    
    import com.hlj.springboot.dome.common.entity.DemoEntity;
    import com.hlj.springboot.dome.common.entity.OtherEntity;
    import com.hlj.springboot.dome.common.entity.repository.DemoEntityRepository;
    import com.hlj.springboot.dome.common.entity.repository.OtherEntityRepository;
    import com.hlj.springboot.dome.common.moudle.service.IsolationService;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Isolation;
    import org.springframework.transaction.annotation.Propagation;
    import org.springframework.transaction.annotation.Transactional;
    
    import javax.annotation.Resource;
    
    /** * 作者 ：HealerJean * 日期 ：2019/1/23 下午7:35. * 类描述： */
    @Service
    @Slf4j
    public class IsolationServiceImpl  implements IsolationService { 
    
        @Resource
        private DemoEntityRepository demoEntityRepository ;
    
        @Resource
        private OtherEntityRepository otherEntityRepository ;
    
    
        @Transactional(propagation = Propagation.REQUIRED,rollbackFor = Exception.class)
        @Override
        public DemoEntity transRequirs(Long id,String name) { 
            DemoEntity demoEntity =  demoEntityRepository.findOne(id);
             demoEntity.setName(name);
            return demoEntityRepository.save(demoEntity);
        }
    
        @Transactional(propagation = Propagation.REQUIRED,rollbackFor = Exception.class)
        @Override
        public DemoEntity transRequirsFind(Long id) { 
            return demoEntityRepository.findOne(id);
        }
    
        @Transactional(propagation = Propagation.REQUIRES_NEW,rollbackFor = Exception.class)
        @Override
        public DemoEntity transRequirsNew(Long id,String name) { 
            DemoEntity demoEntity =  demoEntityRepository.findOne(id);
            demoEntity.setName(name);
            return demoEntityRepository.save(demoEntity);
        }
    
        @Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED,rollbackFor = Exception.class)
        @Override
        public DemoEntity isoLationReadCommitedFind(Long id) { 
            return demoEntityRepository.findOne(id);
        }
    
        @Transactional(propagation = Propagation.REQUIRED,rollbackFor = Exception.class)
        @Override
        public int updateName(Long id, String name) { 
            return demoEntityRepository.updateName(id,name);
        }
    
    
        @Transactional(propagation = Propagation.REQUIRED,rollbackFor = Exception.class)
        @Override
        public OtherEntity findOther(Long id) { 
            return otherEntityRepository.findOne(id);
        }
    }

![ContactAuthor][]

[ContactAuthor]: /images/20220323/093cc89379a14dfeb4a262228aef8cb1.png