Spring Data JPA Update@Query 未更新？

我能够让它工作。我将在这里描述我的应用程序和集成测试。

示例应用程序

示例应用程序有两个与此问题相关的类和一个接口:

1. 应用程序上下文配置类
2. 实体类
3. 存储库接口

下面描述了这些类和存储库接口。

PersistenceContext类的源代码如下:

import com.jolbox.bonecp.BoneCPDataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.annotation.EnableTransactionManagement;


import javax.sql.DataSource;
import java.util.Properties;


@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(basePackages = "net.petrikainulainen.spring.datajpa.todo.repository")
@PropertySource("classpath:application.properties")
public class PersistenceContext {


protected static final String PROPERTY_NAME_DATABASE_DRIVER = "db.driver";
protected static final String PROPERTY_NAME_DATABASE_PASSWORD = "db.password";
protected static final String PROPERTY_NAME_DATABASE_URL = "db.url";
protected static final String PROPERTY_NAME_DATABASE_USERNAME = "db.username";


private static final String PROPERTY_NAME_HIBERNATE_DIALECT = "hibernate.dialect";
private static final String PROPERTY_NAME_HIBERNATE_FORMAT_SQL = "hibernate.format_sql";
private static final String PROPERTY_NAME_HIBERNATE_HBM2DDL_AUTO = "hibernate.hbm2ddl.auto";
private static final String PROPERTY_NAME_HIBERNATE_NAMING_STRATEGY = "hibernate.ejb.naming_strategy";
private static final String PROPERTY_NAME_HIBERNATE_SHOW_SQL = "hibernate.show_sql";


private static final String PROPERTY_PACKAGES_TO_SCAN = "net.petrikainulainen.spring.datajpa.todo.model";


@Autowired
private Environment environment;


@Bean
public DataSource dataSource() {
BoneCPDataSource dataSource = new BoneCPDataSource();


dataSource.setDriverClass(environment.getRequiredProperty(PROPERTY_NAME_DATABASE_DRIVER));
dataSource.setJdbcUrl(environment.getRequiredProperty(PROPERTY_NAME_DATABASE_URL));
dataSource.setUsername(environment.getRequiredProperty(PROPERTY_NAME_DATABASE_USERNAME));
dataSource.setPassword(environment.getRequiredProperty(PROPERTY_NAME_DATABASE_PASSWORD));


return dataSource;
}


@Bean
public JpaTransactionManager transactionManager() {
JpaTransactionManager transactionManager = new JpaTransactionManager();


transactionManager.setEntityManagerFactory(entityManagerFactory().getObject());


return transactionManager;
}


@Bean
public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
LocalContainerEntityManagerFactoryBean entityManagerFactoryBean = new LocalContainerEntityManagerFactoryBean();


entityManagerFactoryBean.setDataSource(dataSource());
entityManagerFactoryBean.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
entityManagerFactoryBean.setPackagesToScan(PROPERTY_PACKAGES_TO_SCAN);


Properties jpaProperties = new Properties();
jpaProperties.put(PROPERTY_NAME_HIBERNATE_DIALECT, environment.getRequiredProperty(PROPERTY_NAME_HIBERNATE_DIALECT));
jpaProperties.put(PROPERTY_NAME_HIBERNATE_FORMAT_SQL, environment.getRequiredProperty(PROPERTY_NAME_HIBERNATE_FORMAT_SQL));
jpaProperties.put(PROPERTY_NAME_HIBERNATE_HBM2DDL_AUTO, environment.getRequiredProperty(PROPERTY_NAME_HIBERNATE_HBM2DDL_AUTO));
jpaProperties.put(PROPERTY_NAME_HIBERNATE_NAMING_STRATEGY, environment.getRequiredProperty(PROPERTY_NAME_HIBERNATE_NAMING_STRATEGY));
jpaProperties.put(PROPERTY_NAME_HIBERNATE_SHOW_SQL, environment.getRequiredProperty(PROPERTY_NAME_HIBERNATE_SHOW_SQL));


entityManagerFactoryBean.setJpaProperties(jpaProperties);


return entityManagerFactoryBean;
}
}

假设我们有一个名为 Todo的简单实体，其源代码如下所示:

@Entity
@Table(name="todos")
public class Todo {


public static final int MAX_LENGTH_DESCRIPTION = 500;
public static final int MAX_LENGTH_TITLE = 100;


@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;


@Column(name = "description", nullable = true, length = MAX_LENGTH_DESCRIPTION)
private String description;


@Column(name = "title", nullable = false, length = MAX_LENGTH_TITLE)
private String title;


@Version
private long version;
}

我们的存储库接口有一个名为 updateTitle()的方法，它更新 todo 条目的标题。TodoRepository接口的源代码如下:

import net.petrikainulainen.spring.datajpa.todo.model.Todo;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;


import java.util.List;


public interface TodoRepository extends JpaRepository<Todo, Long> {


@Modifying
@Query("Update Todo t SET t.title=:title WHERE t.id=:id")
public void updateTitle(@Param("id") Long id, @Param("title") String title);
}

updateTitle()方法没有使用 @Transactional注释进行注释，因为我认为最好使用服务层作为事务边界。

整合测试

集成测试使用了 DbUnit、 Spring Test 和 Spring-Test-DBUnit:

1. DbUnit 数据集，用于在执行测试之前将数据库初始化为已知状态。
2. DbUnit 数据集，用于验证实体的标题是否已更新。
3. 整合测试。

下面对这些组件进行了更详细的描述。

用于将数据库初始化为已知状态的 DbUnit 数据集文件的名称为 ToDoData.xml，其内容如下:

<dataset>
<todos id="1" description="Lorem ipsum" title="Foo" version="0"/>
<todos id="2" description="Lorem ipsum" title="Bar" version="0"/>
</dataset>

The name of the DbUnit dataset which is used to verify that the title of the todo entry is updated is called ToDoData-update. xml and its content looks as follows (for some reason the version of the todo entry was not updated but the title was. Any ideas why?):

<dataset>
<todos id="1" description="Lorem ipsum" title="FooBar" version="0"/>
<todos id="2" description="Lorem ipsum" title="Bar" version="0"/>
</dataset>

实际集成测试的源代码如下所示(请记住使用 @Transactional注释对测试方法进行注释) :

import com.github.springtestdbunit.DbUnitTestExecutionListener;
import com.github.springtestdbunit.TransactionDbUnitTestExecutionListener;
import com.github.springtestdbunit.annotation.DatabaseSetup;
import com.github.springtestdbunit.annotation.ExpectedDatabase;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestExecutionListeners;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.support.DependencyInjectionTestExecutionListener;
import org.springframework.test.context.support.DirtiesContextTestExecutionListener;
import org.springframework.test.context.transaction.TransactionalTestExecutionListener;
import org.springframework.transaction.annotation.Transactional;


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {PersistenceContext.class})
@TestExecutionListeners({ DependencyInjectionTestExecutionListener.class,
DirtiesContextTestExecutionListener.class,
TransactionalTestExecutionListener.class,
DbUnitTestExecutionListener.class })
@DatabaseSetup("todoData.xml")
public class ITTodoRepositoryTest {


@Autowired
private TodoRepository repository;


@Test
@Transactional
@ExpectedDatabase("toDoData-update.xml")
public void updateTitle_ShouldUpdateTitle() {
repository.updateTitle(1L, "FooBar");
}
}

在运行集成测试之后，测试通过，todo 条目的标题被更新。我遇到的唯一问题是版本字段没有更新。知道为什么吗？

我知道这个描述有点模糊。如果您想获得更多关于为 Spring Data JPA 存储库编写集成测试的信息，可以阅读 我的博客文章。

我终于明白是怎么回事了。

在保存对象的语句上创建集成测试时，建议刷新实体管理器，以避免出现任何错误的否定，即避免测试正常运行，但其操作在生产环境中运行时会失败。事实上，测试可能运行良好，只是因为第一级缓存没有刷新，没有写入到数据库中。为了避免这种错误的负整合测试，在测试体中使用显式的刷新。注意，生产代码永远不应该使用任何显式的刷新，因为决定何时刷新是 ORM 的角色。

在更新语句上创建集成测试时，可能需要清除实体管理器，以重新加载第一级缓存。事实上，更新语句完全绕过第一级缓存，直接写入数据库。然后，第一级缓存将失去同步，并反映更新后的对象的旧值。要避免对象的这种陈旧状态，请在测试主体中使用显式 clear。注意，生产代码永远不应该使用任何显式的 clear，因为决定何时清除的是 ORM 的角色。

我的测试现在正常了。

默认情况下 EntityManager 不会自动刷新更改:

@Modifying(clearAutomatically = true)
@Query("update RssFeedEntry feedEntry set feedEntry.read =:isRead where feedEntry.id =:entryId")
void markEntryAsRead(@Param("entryId") Long rssFeedEntryId, @Param("isRead") boolean isRead);

当我试图像你一样执行一个更新查询时，我也遇到了同样的问题-

@Modifying
@Transactional
@Query(value = "UPDATE SAMPLE_TABLE st SET st.status=:flag WHERE se.referenceNo in :ids")
public int updateStatus(@Param("flag")String flag, @Param("ids")List<String> references);

如果您在主类上放置了 @EnableTransactionManagement注释，那么这将是有效的。 Spring 3.1引入了在 @Configuration类中使用的 @EnableTransactionManagement注释，并启用了事务支持。

这里的潜在问题是 JPA 的第一级缓存。 从 JPA 规范2.2版本3.1章节可以看出:

EntityManager 实例与持久性上下文相关联。持久化上下文是一组实体实例，其中对于任何持久化实体标识都有一个 唯一实体实例。

这一点很重要，因为 JPA 跟踪对该实体的更改，以便将它们刷新到数据库中。 作为一个副作用，它还意味着在单个持久化上下文中，实体只加载一次。 这就是为什么重新加载已更改的实体没有任何效果的原因。

你有几个选择来处理这个问题:

1. 从 EntityManager中驱逐实体。 这可以通过调用 EntityManager.detach来完成，用驱逐所有实体的 @Modifying(clearAutomatically = true)注释更新方法。 确保对这些实体的更改首先被刷新，否则您可能会丢失更改

2. 使用 EntityManager.refresh()。

3. 使用不同的持久性上下文来加载实体。 最简单的方法是在一个单独的事务中执行。 对于 Spring，这可以通过在从未使用 @Transactional进行注释的 bean 调用的 bean 上使用单独的方法进行注释来完成。 另一种方法是使用 TransactionTemplate，这种方法在使事务边界非常明显的测试中特别有效