JPA中自定義的插入、更新、刪除方法為什么要添加@Modifying注解和@Transactional注解？

　　前幾天，有個同事在使用JPA的自定義SQL方法時，程序一直報異常，搗鼓了半天也沒能解決，咨詢我的時候，我看了一眼他的程序，差不多是這個樣子的：

@Repository
public interface UserRepository extends JpaRepository<User,Long> {

    @Query(value = "delete from pro_user where id = ?1",nativeQuery = true)
    void deleteUserById(Long id);
}

　　我告訴他，你的deleteUserById方法缺少了@Modifying注解和@Transactional注解，他半信半疑地試了一下，然后果然就解決了。其實，如果他查一下官方資料或許很快也就能找到答案。基於這個背景，本文詳細講解一下為何我們自定義的插入、更新、刪除操作需要加@Modifying注解和@Transactional注解。

一、@Modifying注解

　　在官方資料中，給出了這樣幾句說明：

As the queries themselves are tied to the Java method that executes them, you can actually bind them directly by using the Spring Data JPA @Query annotation 
rather than annotating them to the domain class.

You can modify queries that only need parameter binding by annotating the query method with @Modifying

The @Modifying annotation is only relevant in combination with the @Query annotation. Derived query methods or custom methods do not require this Annotation.

Doing so triggers the query annotated to the method as an updating query instead of a selecting one.

　　如下：

@Modifying
@Query("update User u set u.firstname = ?1 where u.lastname = ?2")
int setFixedFirstnameFor(String firstname, String lastname);

　　第一句話的意思是可以用@Query注解來將自定義sql語句綁定到自定義方法上。

　　第二句話的意思時，可以用@Modifying注解來標注只需要綁定參數的自定義的更新類語句（更新、插入、刪除）。

　　第三名話的意思是說@Modifying只與@Query聯合使用，派生類的查詢方法和自定義的方法不需要此注解，如：

@Repository
public interface UserRepository extends JpaRepository<User,Long> {

    // 父類的保存方法
    @Override
    User save(User entity); 

    // 按照JPA語法規則自定義的查詢方法
    List<User> findFirst10ByLastname(String lastName, Pageable pageable);  
}

　　第四句話的意思是，當加上@Modifying注解時，JPA會以更新類語句來執行，而不再是以查詢語句執行。　　

　　也就是說，當我們要通過自已寫的更新、插入、刪除SQL語句來實現更新、插入、刪除操作時，至少需要用兩個步驟：

　　1）@Query來注入我們自定義的sql；

　　2）使用@Modifying來標注是一個更新類的自定義語句。

　　按照這個規則，修改同事的那個方法：

 @Repository
 public interface UserRepository extends JpaRepository<User,Long> {
 
     @Modifying
     @Query(value = "delete from pro_user where id = ?1",nativeQuery = true)
     void deleteUserById(Long id);
 }

　　但是，此時，該方法還不完整，執行時程序會報以下錯誤：

org.springframework.dao.InvalidDataAccessApiUsageException: Executing an update/delete query; nested exception is javax.persistence.TransactionRequiredException: 
Executing an update/delete query
    at org.springframework.orm.jpa.EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(EntityManagerFactoryUtils.java:402)
    at org.springframework.orm.jpa.vendor.HibernateJpaDialect.translateExceptionIfPossible(HibernateJpaDialect.java:255)
    ......
    at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:70)
Caused by: javax.persistence.TransactionRequiredException: Executing an update/delete query
    at org.hibernate.internal.AbstractSharedSessionContract.checkTransactionNeededForUpdateOperation(AbstractSharedSessionContract.java:398)
    at org.hibernate.query.internal.AbstractProducedQuery.executeUpdate(AbstractProducedQuery.java:1585)
    .......

二、@Transactional注解

　　官方的說明：

　　By default, CRUD methods on repository instances are transactional. For read operations, the transaction configuration readOnly flag is set to true. All others are configured with a plain @Transactional so that default transaction configuration applies. For details, see JavaDoc of SimpleJpaRepository. If you need to tweak transaction configuration for one of the methods declared in a repository, redeclare the method in your repository interface, as follows:

　　Example. Custom transaction configuration for CRUD

public interface UserRepository extends CrudRepository<User, Long> {

  @Override
  @Transactional(timeout = 10)
  public List<User> findAll();

  // Further query method declarations
}

　　這句話的意思是，默認情況下，repository 接口中的CRUD方法都是被@Transactional注解修飾了的，對於讀的操作方法，@Transactional注解的readOnly屬性是被設置為true的，即只讀；CRUD中的其他方法被@Transactional修飾，即非只讀。如果你需要修改repository 接口中的某些方法的事務屬性，可以在該方法上重新加上@Transactional注解，並設置需要的屬性。

　　我們先來看一下，@Transactional注解的源碼：

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Transactional {

    Propagation propagation() default Propagation.REQUIRED;

    Isolation isolation() default Isolation.DEFAULT;

    int timeout() default -1;

    boolean readOnly() default false;
  
    // 其他省略
}

　　由上可見@Transactional注解的readOnly默認的屬性的false，即非只讀，當一個事務是非只讀事務的時候，我們可以進行任何操作。

　　再看一下repository 接口的實現類SimpleJpaRepository的源碼(只摘了部分源碼)：

@Repository
@Transactional(
    readOnly = true
)
public class SimpleJpaRepository<T, ID> implements JpaRepositoryImplementation<T, ID> {
   
    @Transactional
    public void deleteById(ID id) {
        Assert.notNull(id, "The given id must not be null!");
        this.delete(this.findById(id).orElseThrow(() -> {
            return new EmptyResultDataAccessException(String.format("No %s entity with id %s exists!", this.entityInformation.getJavaType(), id), 1);
        }));
    }

    @Transactional
    public void delete(T entity) {
        Assert.notNull(entity, "The entity must not be null!");
        this.em.remove(this.em.contains(entity) ? entity : this.em.merge(entity));
    }

    @Transactional
    public void deleteAll(Iterable<? extends T> entities) {
        Assert.notNull(entities, "The given Iterable of entities not be null!");
        Iterator var2 = entities.iterator();

        while(var2.hasNext()) {
            T entity = var2.next();
            this.delete(entity);
        }
    }

    public T getOne(ID id) {
        Assert.notNull(id, "The given id must not be null!");
        return this.em.getReference(this.getDomainClass(), id);
    }

    public List<T> findAll() {
        return this.getQuery((Specification)null, (Sort)Sort.unsorted()).getResultList();
    }

    public List<T> findAll(@Nullable Specification<T> spec) {
        return this.getQuery(spec, Sort.unsorted()).getResultList();
    }

    public List<T> findAll(@Nullable Specification<T> spec, Sort sort) {
        return this.getQuery(spec, sort).getResultList();
    }

    public <S extends T> long count(Example<S> example) {
        return executeCountQuery(this.getCountQuery(new SimpleJpaRepository.ExampleSpecification(example), example.getProbeType()));
    }

    public <S extends T> boolean exists(Example<S> example) {
        return !this.getQuery(new SimpleJpaRepository.ExampleSpecification(example), example.getProbeType(), (Sort)Sort.unsorted()).getResultList().isEmpty();
    }

    @Transactional
    public <S extends T> S save(S entity) {
        if (this.entityInformation.isNew(entity)) {
            this.em.persist(entity);
            return entity;
        } else {
            return this.em.merge(entity);
        }
    }

    @Transactional
    public <S extends T> S saveAndFlush(S entity) {
        S result = this.save(entity);
        this.flush();
        return result;
    }

    @Transactional
    public void flush() {
        this.em.flush();
    }
}

　　從SimpleJpaRepository源碼中可以看出：

　   1）該類上注解了只讀事務@Transactional(readOnly = true)；

       2）該類的所有查詢類操作方法都與類相同，都擁有只讀事務；

       3）該類的所有保存、更新、刪除操作方法都用@Transactional重新注解了（默認readOnly=false）。

　　說明JPA為我們提供的所有方法，包括JPA規則的自定義方法在其底層都為我們做好了事務處理，而我們自定義的方法需要自己來標注事務的類型是只讀還是非只讀。根據這個原理，再次修改開篇所列出的方法：

@Repository
public interface UserRepository extends JpaRepository<User,Long> {

    @Transactional
    @Modifying
    @Query(value = "delete from pro_user where id = ?1",nativeQuery = true)
    void deleteUserById(Long id);
}

　　至此，該方法按所期望的結果運行成功了。

三、@Modifying注解補充說明

@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.METHOD, ElementType.ANNOTATION_TYPE })
@Documented
public @interface Modifying {

    boolean flushAutomatically() default false;

    boolean clearAutomatically() default false;
}

　　該注解中有兩個屬性：flushAutomatically、clearAutomatically，從字面理解是自動刷新和自動清除。

　　自動刷新，即執行完語句后立即將變化內容刷新到磁盤，如果是insert語句操作，則與JPA的<S extends T> S saveAndFlush(S entity);方法效果相同；

　　自動清除，即執行完語句后自動清除掉已經過期的實體，比如，我們刪除了一個實體，但是在還沒有執行flush操作時，這個實體還存在於實體管理器EntityManager中，但這個實體已經過期沒有任何用處，直到flush操作時才會被刪除掉。如果希望在刪除該實體時立即將該實體從實體管理器中刪除，則可以將該屬性設置為true，如：

@Modifying(clearAutomatically = true)
    @Transactional
    @Query(value = "delete from pro_user where id = ?1",nativeQuery = true)
    void deleteUserById(Long id);