spring - 如何在不使用 hibernate 级别 1 缓存或手动 session 刷新的情况下测试 Spring @Transactional？

Question

使用 Spring + Hibernate 和事务注释。

我正在尝试测试以下内容:

1. 调用更改 User 对象的方法，然后调用 @Transactional 服务方法来持久化它
2. 在该方法之后从数据库读回对象并确保其值正确

我遇到的第一个问题是在步骤 2 中读取 User 对象只是返回 Hibernate 1 级缓存中的用户对象，而没有实际从数据库中读取。

因此，我使用 session 手动从缓存中逐出该对象，以强制从数据库中读取。但是，当我这样做时，对象值永远不会保留在单元测试中(我知道由于我指定的设置，它会在测试完成后回滚)。

我尝试在调用@Transactional 服务方法后手动刷新 session ，并且确实提交了更改。然而，这并不是我所期望的。我认为 @Transactional 服务方法将确保事务在返回之前被提交并刷新 session 。我知道一般来说 Spring 会决定何时进行此管理，但我认为 @Transactional 方法中的“工作单元”就是该方法。

无论如何，现在我正在尝试弄清楚如何测试 @Transactional 方法。

这是一个失败的 junit 测试方法:

@RunWith(SpringJUnit4ClassRunner.class)
@Transactional
@TransactionConfiguration(transactionManager = "userTransactionManager", defaultRollback = true)
@WebAppConfiguration()
@ContextConfiguration(locations = { "classpath:test-applicationContext.xml",
        "classpath:test-spring-servlet.xml",
        "classpath:test-applicationContext-security.xml" })
public class HibernateTest {

    @Autowired
    @Qualifier("userSessionFactory")
    private SessionFactory sessionFactory;

    @Autowired
    private UserService userService;

    @Autowired
    private PaymentService paymentService;

    @Autowired
    private QueryService queryService;

    @Autowired
    private NodeService nodeService;

    @Autowired
    private UserUtils userUtils;

    @Autowired
    private UserContext userContext;

  @Test
    public void testTransactions() {
        // read the user
        User user1 = userService.readUser(new Long(77));
        // change the display name
        user1.setDisplayName("somethingNew");
        // update the user using service method that is marked @Transactional
        userService.updateUserSamePassword(user1);
        // when I manually flush the session everything works, suggesting the
        // @Transactional has not flushed it at the end of the method marked
        // @Transactional, which implies it is leaving the transaction open?
        // session.flush();
        // evict the user from hibernate level 1 cache to insure we are reading
        // raw from the database on next read
        sessionFactory.getCurrentSession().evict(user1);
        // try to read the user again
        User user2 = userService.readUser(new Long(77));
        System.out.println("user1 displayName is " + user1.getDisplayName());
        System.out.println("user2 displayName is " + user2.getDisplayName());
        assertEquals(user1.getDisplayName(), user2.getDisplayName());
    }
}

如果我手动刷新 session ，则测试成功。但是，我希望 @Transactional 方法能够处理提交和刷新 session 。

updateUserSamePassword 的服务方法在这里:

@Transactional("userTransactionManager")
@Override
public void updateUserSamePassword(User user) {
    userDAO.updateUser(user);
}

DAO 方法在这里:

@Override
public void updateUser(User user) {
    Session session = sessionFactory.getCurrentSession();
    session.update(user);
}

SessionFactory 是 Autowiring 的:

@Autowired
@Qualifier("userSessionFactory")
private SessionFactory sessionFactory;

我正在使用 XML 应用程序上下文配置。我有:

<context:annotation-config />
<tx:annotation-driven transaction-manager="userTransactionManager" />

还有

<bean id="userDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close"> 
    <property name="driverClass" value="${user.jdbc.driverClass}"/>
    <property name="jdbcUrl" value="${user.jdbc.jdbcUrl}" />
    <property name="user" value="${user.jdbc.user}" />
    <property name="password" value="${user.jdbc.password}" />
    <property name="initialPoolSize" value="3" />
    <property name="minPoolSize" value="1" />
    <property name="maxPoolSize" value="17" />
</bean>

<bean id="userSessionFactory"
    class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
    <property name="dataSource" ref="userDataSource" />
    <property name="configLocation" value="classpath:user.hibernate.cfg.xml" />
</bean>

<bean id="userTransactionManager"
    class="org.springframework.orm.hibernate4.HibernateTransactionManager">
    <property name="dataSource" ref="userDataSource" />
    <property name="sessionFactory" ref="userSessionFactory" />
</bean>

还有对服务和 dao 类的组件扫描。正如我所说，这正在生产中发挥作用。

我认为，如果我有一个标记为@Transactional的方法，那么在该方法结束时(例如此处的更新方法)，Spring将强制 session 提交并刷新。

我只能看到几个选项:

1. 我错误配置了一些东西，尽管这通常对我有用(只是不适用于单元测试)。有什么猜测吗？关于如何测试这个有什么想法吗？

2. 有关单元测试配置本身的某些行为与应用程序的行为方式不同。

3. 事务和 session 不是这样工作的。我唯一的推论是 Spring 在调用该更新方法后使事务和/或 session 保持打开状态。因此，当我手动驱逐 session 对象上的用户时，这些更改尚未提交。

任何人都可以确认这是否是预期的行为吗？ @Transaction 不应该在 session 上强制提交和刷新吗？如果不是，那么如何测试标记为 @Transactional 的方法以及这些方法是否确实适用于事务？

即，我应该如何在这里重写我的单元测试？

还有其他想法吗？

Answer 1

这就是我遇到的情况。在测试方法中考虑以下代码:

    String testDisplayNameChange = "ThisIsATest";
    User user = userService.readUser(new Long(77));
    user.setDisplayName(testDisplayNameChange);
    user = userService.readUser(new Long(77));
    assertNotEquals(user.getDisplayName(), testDisplayNameChange);

请注意，方法 userService.readUser 在服务类中被标记为@Transactional。

如果该测试方法被标记为@Transactional，则测试失败。如果不是，则成功。现在我不确定 Hibernate 缓存是否/何时真正参与其中。如果测试方法是事务性的，那么每次读取都发生在一个事务中，并且我相信它们只会命中 Hibernate 1 级缓存(并且实际上并不从数据库读取)。但是，如果测试方法不是事务性的，则每次读取都发生在它自己的事务中，并且每次都会访问数据库。因此，hibernate 1 级缓存与 session /事务管理相关联。

要点:

1. 即使测试方法正在调用另一个类中的多个事务方法，如果该测试方法本身是事务性的，则所有这些调用都发生在一个事务中。测试方法是“工作单元”。但是，如果测试方法不是事务性的，则该测试中对该事务性方法的每次调用都会在其自己的事务中执行。

2. 我的测试类被标记为@Transactional，因此每个方法都将是事务性的，除非使用@AfterTransaction 等重写注释进行标记。我可以很容易地不标记类 @Transactional 并标记每个方法 @Transactional

3. 使用 Spring @Transactional 时，Hibernate 1 级缓存似乎与事务相关。 IE。同一事务中对象的后续读取将命中 Hibernate 1 级缓存，而不是数据库。请注意，您可以调整 2 级缓存和其他机制。

我打算有一个 @Transactional 测试方法，然后在测试类中的另一个方法上使用 @AfterTransaction 并提交原始 SQL 来评估数据库中的值。这将完全绕过 ORM 和 hibernate 一级缓存，确保您比较数据库中的实际值。

简单的答案是从我的测试类中删除@Transactional。耶。