前言

Github:https://github.com/HealerJean

博客:http://blog.healerjean.com

不多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,不操作数据库。这个时候手动修改数据库中的name为1111,再执行查询语句,我们会发现取到了那么为1111的值,而不是0000(不论是可重复读REPEATABLE_READ 还是不可重复读READ_COMMITTED

如果是sql(注意一定是sql)更新操作,我们在当前事物中进行了更新操作,其他事物更新相同id的数据,则其他事物不能修改,因为更新操作会将这条数据锁住(排它锁),其他事物不能更新执这条id的数据(可以使用select普通查看

hibernate save方法进行更新数据不会马上执行sql语句,它会等到事物最后全部执行完成、或者这条数据的记录直到本事物中对它进行数据库操作的时候(一般是纯sql语句,否则hiberante方法会具有缓存而不执行数据库语句)才会执行sql语句,所以hibernate相关save更新按照代码根据情况进行锁住,影响到别的事物对它进行修改) ->(包括,新开启了一个独立事物对它进行修改也不能完成),但是对于其他的id是可以任意修改的的,除非等当前事物执行完成或者当前事物回滚(总之就是当前事物结束)

2、可重复读取REPEATABLE_READ

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

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

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

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

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

1、update 原生 sql语句不会更新当前实体对象,

2、如果是同一个事物中,如果是一个根据id 进行更新,并且返回了结果 ,hibernate,即使重新new一个对象出来也会对原来的的对象 进行更新

3、如果是中间独立事物进行了修改,返回了其他对象,不会更新当前实体对象。


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