前言

之前讲解了Spring Boot如何集成JPA和相关特性，虽然JPA使用非常的简单，但是我们在实际的 项目中需要去掌握JPA原理，这样才能更好的解决相关问题。

JPA为什么没有update方法

JPA提供了一个save方法，当主键为空的时候，则执行的为insert语句，当主键不为空的时候，则执行为update方法。

JPA使用Save方法的坑

问题1：需要区分Save方法什么时候执行的insert，什么时候执行的为update语句，切莫误把insert当作了update。

先看下JPA save方法的源码

@Transactional
	@Override
	public <S extends T> S save(S entity)
        {
                 //如果为新对象则执行持久化操作
		if (entityInformation.isNew(entity)) 
                {
		   em.persist(entity);
		   return entity;
		}
                //执行merge方法
                else 
                {
	          return em.merge(entity);
		}
	}
        
        	public boolean isNew(T entity)
                {
                
                //通过id查询实体对象
		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));
	}
        

上述源码可以简单理解，先通过id查询对象是否存在，如果存在则执行更新方法，否则执行新增方法。

新增示例

 @RequestMapping("/saveUser")
    public String saveUser(){
        
        User user =new User();
        user.setName("jpatest");
        user.setAge(100);
        userDao.save(user);
        return "成功";
    }

执行结果，我们可以看到输出的为insert语句

Hibernate: 
    insert 
    into
        t_user
        (address, age, email, name) 
    values
        (?, ?, ?, ?)

更新示例

  @RequestMapping("/updateUser")
    public String updateUser(){
        
        User user =new User();
        user.setOid(485612);
        user.setName("jpatest122");
        user.setAge(100);
        userDao.save(user);
        return "成功";
    }

第一次执行结果我们可以看到先执行查询语句，然后再执行更新语句。

Hibernate: 
    select
        user0_.oid as oid1_0_0_,
        user0_.address as address2_0_0_,
        user0_.age as age3_0_0_,
        user0_.email as email4_0_0_,
        user0_.name as name5_0_0_ 
    from
        t_user user0_ 
    where
        user0_.oid=?
Hibernate: 
    update
        t_user 
    set
        address=?,
        age=?,
        email=?,
        name=? 
    where
        oid=?

如果每次执行update操作都需要先执行查询然后再更新的话，会影响性能。

第二次执行，我们看到只输出了查询语句，没有执行更新操作，这是为什么呢?

Hibernate: 
    select
        user0_.oid as oid1_0_0_,
        user0_.address as address2_0_0_,
        user0_.age as age3_0_0_,
        user0_.email as email4_0_0_,
        user0_.name as name5_0_0_ 
    from
        t_user user0_ 
    where
        user0_.oid=?

这里因为session的缓存数据与快照区数据完全相同，没有更新任何属性，所以只会执行查询语句。

问题2：默认情况下，执行update语句会更新实体中的所有字段。

示例代码：

 @RequestMapping("/saveOrUpdateUser")
    public String saveOrUpdateUser()
    {
        //查询    
        User user =userDao.findById(485612).orElse(null);
        user.setName("jpatest123sssssxxwwwdds");
        userDao.save(user);
        return "成功";
    }

执行结果：我们可以看到，我只想更新用户名字段，但是执行的SQL语句却把实体中的所有字段都进行了更新。

Hibernate: 
    select
        user0_.oid as oid1_0_0_,
        user0_.address as address2_0_0_,
        user0_.age as age3_0_0_,
        user0_.email as email4_0_0_,
        user0_.name as name5_0_0_ 
    from
        t_user user0_ 
    where
        user0_.oid=?
Hibernate: 
    select
        user0_.oid as oid1_0_0_,
        user0_.address as address2_0_0_,
        user0_.age as age3_0_0_,
        user0_.email as email4_0_0_,
        user0_.name as name5_0_0_ 
    from
        t_user user0_ 
    where
        user0_.oid=?
Hibernate: 
    update
        t_user 
    set
        address=?,
        age=?,
        email=?,
        name=? 
    where
        oid=?

如果数据库中的字段非常多的话，执行更新操作将严重会影响性能，那么如何解决呢?

解决办法：我们需要在实体类中添加@DynamicUpdate注解，表示动态更新查询。

@DynamicUpdate
public class User

添加此注解后，执行SQL语句才是正确的SQl了语句

Hibernate: 
    select
        user0_.oid as oid1_0_0_,
        user0_.address as address2_0_0_,
        user0_.age as age3_0_0_,
        user0_.email as email4_0_0_,
        user0_.name as name5_0_0_ 
    from
        t_user user0_ 
    where
        user0_.oid=?
Hibernate: 
    update
        t_user 
    set
        name=? 
    where
        oid=?

问题3：JPA实体状态问题

JPA实体有如下四种状态：

• 瞬时状态：瞬时状态的实体就是一个普通的java对象，和持久化上下文无关联，数据库中也没有数据与之对应。
• 托管状态：EntityManager进行find或者persist操作返回的对象即处于托管状态，此时该对象已经处于持久化上下文中，因此任何对于该实体的更新都会同步到数据库中。
• 游离状态: 当事务提交后，处于托管状态的对象就转变为了游离状态。此时该对象已经不处于持久化上下文中，因此任何对于该对象的修改都不会同步到数据库中。
• 删除状态： 当调用EntityManger对实体进行delete后，该实体对象就处于删除状态。其本质也就是一个瞬时状态的对象。

状态之间转换：

我们通过一个实例来讲解：

 @Transactional(rollbackFor=Exception.class)
    public void updateUserNameByOid(int oid, String userName)
    {
       //查询数据库数据，将数据存放到缓存区和快照区
        User user = userDao.findById(oid).orElse(null);
        
        System.out.println("user userName: " + user.getName());
        System.out.println("user age: " + user.getAge());
        System.out.println("userName will be updated to " + userName);
        //查询数据库数据，由于执行update方法没有持久化到数据库
        userDao.modifyNameByOid(userName, 1);
        //由于没有执行更新操作，查询数据都是一样的
        User user1 = userDao.findById(oid).get();
        System.out.println("user1 age: " + user1.getAge());
        System.out.println("age will be updated to " + 18);
        user1.setAge(18);
        //更新年龄字段
        userDao.save(user1);
    }

执行结果却出人意料，数据库种用户名字段没有更新，只更新了年龄字段。

Hibernate: 
    select
        user0_.oid as oid1_0_0_,
        user0_.address as address2_0_0_,
        user0_.age as age3_0_0_,
        user0_.email as email4_0_0_,
        user0_.name as name5_0_0_ 
    from
        t_user user0_ 
    where
        user0_.oid=?
user userName: li'si
user age: 1811
userName will be updated to lisi
Hibernate: 
    update
        t_user u 
    set
        u.name = ? 
    where
        u.oid = ?
user1 age: 1811
age will be updated to 18
Hibernate: 
    update
        t_user 
    set
        age=? 
    where
        oid=?

上述的update方法不是执行了name字段的修改，为什么数据的字段没有更新。

原因如下： 当在一个事务内通过update一个从数据库中查询出来的实体时，Spring Data JPA并不会马上执行Update SQL语句，将修改同步到数据库，而是等到事务提交时才会决定是否调用flush()方法将缓存中的实体信息同步到数据库中，当调用 flush()方法时才会执行Update SQL语句。

Spring Data JPA除了一级缓存外，还有一个快照区，当将查询结果放到一级缓存中时，会同时复制一份数据放入快照区中，Spring Data JPA通过快照区与缓存中的数据是否一致来判断数据从数据库查询出来后是否发生过修改。

在上面例子中，第一次执行User user = userDao.findById(485612).get()这句代码后，一级缓存区和快照区都会同时保存一个User实例，如下图：

当方法执行完user1.setAge(18);后，缓存区和快照区的User实例中的状态信息已经发生了变化

Spring Data JPA在事务提交时，为了保持数据库和缓存的数据同步，会清理一级缓存并根据主键字段值判断一级缓存中的对象属性值和快照中的对象属性值是否一致，如果两个对象的属性值不一致，则调用flush()方法执行Update SQL语句，将缓存的内容同步到数据库，并更新快照；如果一致，则不调用flush()方法。

所以上述例子修改方案为：执行update的方法后需要执行flush方法，将修改的信息更新到数据库即可。

总结

Spring Data JPA虽然为程序员封装了很多实用的方法，程序员可以方便地使用Spring Data JPA去写数据访问层代码，但是如果我们对框架的机制不理解时，会导致错误发生，这种错误很难通过debug的方式来解决。所以学习框架时我们应该充分了解框架的原理和机制，才能避免放错。

原文链接：https://juejin.cn/post/7089676216906547237