Spring-Data-Jpa 保存时save和saveAndFlush的区别
Jpa是我们经常用到的ORM框架，使用它可以快速便捷的操作数据库，那么它有一个保存方法，你肯定不会陌生，就是save方法和saveAndFlush，这两个方法可能会经常用到，那么什么时候使用save方法，什么时候使用saveAndFlush呢，下面就进行简单总结一下。
Jpa save
首先创建一个表，进行完整的代码演示。
-- auto-generated definition
create table t_user
(
id int auto_increment primary key,
name varchar(255) not null,
age int not null,
is_deleted tinyint null,
created_at datetime null,
last_updated_at datetime null,
created_by mediumtext not null
);
上述我创建了一个t_user表，然后创建相应的entity.
@Entity
@Data
@ToString
@Table(name = "t_user")
@EntityListeners(value = AuditingEntityListener.class)
public class UserEntity extends AbstractAggregateRoot<UserEntity> {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id", columnDefinition = "int")
private Integer id;
/**
* 年龄
*/
@Column(name = "age", columnDefinition = "int")
private Integer age;
/**
* 名称
*/
@Column(name = "name", columnDefinition = "varchar")
private String name;
@CreatedDate
@Column(name = "created_at", columnDefinition = "datetime")
private LocalDateTime createdAt;
@LastModifiedDate
@Column(name = "last_updated_at", columnDefinition = "datetime")
private LocalDateTime lastUpdatedAt;
@CreatedBy
@Column(name = "created_by", columnDefinition = "long")
private Long createdBy;
@Column(name = "is_deleted", columnDefinition = "tinyint")
private Integer isDeleted;
}
上述创建好之后，再建立一个UserRepository，就可以使用了reposity来进行操作了。
下面直接列出service层代码，我去随机生成用户名，然后进行更新.
下面列出Repository代码
public interface UserRepository extends JpaRepository<UserEntity, Integer>, CustomUserRepository {
}
@Transactional(rollbackFor = Exception.class)
public void updateName() {
UserEntity userEntity = userRepository.findById(1).orElseThrow(() -> new RuntimeException("error"));
String str = UUID.randomUUID().toString();
System.out.println(str);
userEntity.setName(str);
// 使用save进行保存
userRepository.save(userEntity);
// 使用saveAndFlush进行保存
userRepository.saveAndFlush(userEntity);
}
上述代码执行完毕之后，不管是save还是saveAndFlush都执行成功，那么二者究竟有何不同呢。
底层实现
其实我们在使用jpa的时候，直接根据Entity来编写Repository层代码，而Repository是一个接口，那么在IOC容器中肯定是Spring帮我们生成了动态代理类，从而帮助我们进行增强逻辑，实现和数据库层面的交互。我们不妨直接在service层打断点，然后看看具体的repository对象是什么。
通过上述打断点来到了service方法里面，定位到repository其实是一个SimpleJpaRepository，这个SimpleJpaRepository 是由 jpa 来实现的，它一定实现了Repository接口，我们点进这个类里面的具体源码。
下面是我在SimpleJpaRepository里面找到的具体方法的源码。
/*
* (non-Javadoc)
* @see org.springframework.data.repository.CrudRepository#save(java.lang.Object)
*/
@Transactional
@Override
public <S extends T> S save(S entity) {
// 这里的em其实是EntityManager，它是javax定义的规范，这里jpa使用了它，
// 可以看到，首先save的时候，去判断这个entity是不是新的，如果是新的就去save，对应到数据库里面其实就是增加了一条记录。isNew其实就是判断entity里面有没有id值，如果有就是更新，没有的话，认为是新增记录。
if (entityInformation.isNew(entity)) {
em.persist(entity);
return entity;
} else {
// 如果不是新的，那么就进行merge，其实就是update.
return em.merge(entity);
}
}
/// 下面是saveAndFlush源码，它会首先调用save方法去保存，然后其次调用了一个方法
/*
* (non-Javadoc)
* @see org.springframework.data.jpa.repository.JpaRepository#saveAndFlush(java.lang.Object)
*/
@Transactional
@Override
public <S extends T> S saveAndFlush(S entity) {
S result = save(entity);
/// 多调用了一个 flush 方法
flush();
return result;
}
/*
* flush方法仅仅由entityManager又去调用了它里面的flush方法
* (non-Javadoc)
* @see org.springframework.data.jpa.repository.JpaRepository#flush()
*/
@Transactional
@Override
public void flush() {
em.flush();
}
下面截取了isNew的核心方法，其实就是判断有没有ID值，如果entity里面有id不为空，那么就认为你是更新，否则就是save保存。
public boolean isNew(T entity) {
ID id = getId(entity);
Class<ID> idType = getIdType();
if (!idType.isPrimitive()) {
return id == null;
}
if (id instanceof Number) {
return ((Number) id).longValue() == 0L;
}
throw new IllegalArgumentException(String.format("Unsupported primitive id type %s!", idType));
}
通过上述代码可以看到 saveAndFlush和save方法其实就差了一个entityManager的flush方法。其实从方法名字也可以看的出来的。
那么em.flush究竟做了哪些事呢。
遇到的坑
开启两个事务 A和B，都修改id为1的这条数据，同时设置JPA将sql语句打印至控制台 便于观察，执行情况， 表中数据如下:
[
{
"id": 1,
"name": "f7c8264c-b213-4c8f-b642-0fa1a819ade7",
"age": 43,
"is_deleted": 0,
"created_at": "2021-01-04 18:26:32",
"last_updated_at": "2021-01-18 00:35:16",
"created_by": "0"
}
]
可以看到name是一个随机字符串， 年龄是43。
| 事务A(线程A) | 事务B(线程B) |
|---|---|
| 更新用户姓名（更新为随机字符串） | 更新用户年龄 (更新为随机数字) |
| save(userEntity) | save(userEntity) |
| 事务卡在这儿不提交 | |
| 事务提交 |
观看上述执行流程，会发生什么情况呢？
首先看上述流程对应的代码演示, 注意 两个方法都加了事务哦
// 定义了两个方法，一个修改name,一个修改age。说一下这里为啥用随机字符串和随机数字
// ps: 如果jpa发现你的entity数据没有变更，是不会执行更新的呦，所以 我这里进行了随机字符串设置，便于我进行测试。
// 对应上面流程的事务A
@Transactional(rollbackFor = Exception.class)
public void updateName() {
UserEntity userEntity = userRepository.findById(1).orElseThrow(() -> new RuntimeException("error"));
String str = UUID.randomUUID().toString();
// 将生成的随机字符串进行打印，便于我对比数据库更新情况。
System.out.println(str);
userEntity.setName(str);
userRepository.save(userEntity);
// 睡上几分钟，sleep代码省略....
}
// 对应上述流程的事务B
@Transactional
public void updateAge() {
UserEntity userEntity = userRepository.findById(1).orElseThrow(() -> new RuntimeException("error"));
int random = ThreadLocalRandom.current().nextInt(100);
// 打印生成的随机数字
System.out.println("random : " + random);
userEntity.setAge(random);
userRepository.save(userEntity);
}
我当时按照数据库行锁理论，首先想到了肯定会阻塞，由于事务A先执行了save操作，然后事务卡在下面了，那么事务B肯定就没办法执行喽。但是并没有哎，事务B仍然顺利执行。
然后我观察控制台，发现并没有任何输出，这就表示了，sql没发送到mysql服务器，那么mysql端肯定不会给你加行锁喽。
debug情况展示.
可以看到save方法执行完成，事务没有提交的时候，是不会将update语句发送至mysql服务器的, 没有任何的update相关sql打印。
下面写一个controller 来进行访问修改年龄的接口，看看会不会卡住, 这里便于演示，我直接用Get请求了。
@GetMapping("/user/age")
public String updateAge() {
userService.updateAge();
return "OK";
}
结果如下:
左边部分请求更改姓名接口，会进行sleep住，右边部分直接请求修改年龄，可以看到一下就执行完了，没有任何卡住。
然后果断 改成saveAndFlush 再试一次， 对应的执行流程如下:
| 事务A(线程A) | 事务B(线程B) |
|---|---|
| 更新用户姓名（更新为随机字符串） | 更新用户年龄 (更新为随机数字) |
| saveAndFlush(userEntity) | save(userEntity) |
| 事务卡在这儿不提交 | |
| 事务提交 |
发现这次符合预期，事务B果然卡住了，等待事务A执行结束。
对应的代码如下, 与上述代码差别不大，只是事务A 对应的save操作换成了saveAndFlush()
// 对应上面流程的 事务A
@Transactional(rollbackFor = Exception.class)
public void updateName() throws InterruptedException {
UserEntity userEntity = userRepository.findById(1).orElseThrow(() -> new RuntimeException("error"));
String str = UUID.randomUUID().toString();
System.out.println(str);
userEntity.setName(str);
// 注意 换成了saveAndFlush()
userRepository.saveAndFlush(userEntity);
TimeUnit.SECONDS.sleep(2000);
}
@Transactional
public void updateAge() {
UserEntity userEntity = userRepository.findById(1).orElseThrow(() -> new RuntimeException("error"));
int random = ThreadLocalRandom.current().nextInt(100);
System.out.println("random : " + random);
userEntity.setAge(random);
userRepository.save(userEntity);
}
debug执行情况如下:
可以清晰的看到久违的update语句终于打印出来了，这时候 如果执行更改年龄的操作，必然会卡住，继续写个controller。
@GetMapping("/user/age")
public String updateAge() {
userService.updateAge();
return "OK";
}
Controller方法同上，为了方便测试，直接使用了Get方法进行测试。
左边部分依旧修改姓名，会进行sleep几分钟，右边修改年龄，可以看到，修改年龄的请求被阻塞住了。
上面就是save和saveAndFlush最明显的区别，save等到事务进行提交时，才进行doFlush，刷新sql至MySQL服务器，而saveAndFlush会直接立刻马上的将SQL发送至MySQL服务端。所以在使用的时候需要注意，如果有更新之后发送消息的场景，使用save需谨慎。
例如，下面代码:
@Transactional(rollbackFor = Exception.class)
public void updateName() throws InterruptedException {
UserEntity userEntity = userRepository.findById(1).orElseThrow(() -> new RuntimeException("error"));
String str = UUID.randomUUID().toString();
System.out.println(str);
userEntity.setName(str);
userRepository.save(userEntity);
// 发送消息至rabbitMQ
rabbitTemplate.sendAndConvert("更新用户名称");
}
上面代码由于在执行过程中，直接在事务中发消息，可能会导致mq消息已经发送到exchange，而userEntitiy在事务提交的时候 因字段错误或其他异常，会在将sql发送至mysql服务器时，由服务端报出错误。但是这时候MQ消息已经发送出去了，就导致了事务的不一致性。
关于解决方式以及原理，我会在后续事务相关的文章中，继续介绍。
使用总结
save和saveAndFlush其实底层多了一个entityManager的flush操作。而这个flush操作会将执行的sql发送至数据库服务器。而save方法需等到事务提交的时候，才会进行发送sql执行sql语句。
在使用的时候，如果save使用不当，当前事务不提交，这时候其他事务过来进行修改数据，可能会产生数据覆盖的情况。
而在使用saveAndFlush的时候，当前事务不提交，其他事务过来的时候修改同一行记录，会产生锁等待现象，如果使用saveAndFlush建议将saveAndFlush操作放在最后执行，最大粒度的减少锁等待时间。
如果有收获的话，欢迎点赞，留言，转发哦~
