Spring Boot JPA 常见的那些坑

十一技术斩

前言

之前讲解了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方法
	          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 
        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_ 
        t_user user0_ 
    where
        user0_.oid=?
Hibernate: 
    update
        t_user 
        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_ 
        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_ 
        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_ 
        t_user user0_ 
    where
        user0_.oid=?
Hibernate: 
    update
        t_user 
        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_ 
        t_user user0_ 
    where
        user0_.oid=?
Hibernate: 
    update
        t_user 
        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_ 
        t_user user0_ 
    where
        user0_.oid=?
user userName: li'si
user age: 1811
userName will be updated to lisi
Hibernate: 
    update
        t_user u 
        u.name = ? 
    where
        u.oid = ?
user1 age: 1811
age will be updated to 18
Hibernate: 
    update