如何为Hibernate查询设置超时以终止长耗时查询？

问题背景 #

系统中存在占用内存的长耗时查询，尝试通过Hibernate和JDBC的超时设置中断执行，但均不生效，需要实现可靠的强制查询超时。

环境信息 #

• Oracle数据库：Oracle Database 19c Enterprise Edition Release 19.0.0.0.0 - Production
• Hibernate：5.6.10
• Java：17
• Spring：5.3.21

当前配置与测试代码 #

Spring数据源与Hibernate配置 #

<bean id="dataSource"
        class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="oracle.jdbc.OracleDriver" />
        <property name="url" value="jdbc:oracle:thin:@localhost:1521/ltoi" />
        <property name="username" value="" />
        <property name="password" value="" />               
</bean>
<bean id="hibernateProperties"
        class="org.springframework.beans.factory.config.PropertiesFactoryBean">
        <description>
            Globale Einstellungen/Properties zu Hibernate
            Connection Pool, Caching-Strategie, Fetch-Strategie, ...
      </description>
        <property name="properties">
            <props>
                <prop key="hibernate.dialect">de.cfs.hbn.CustomOracleDialect</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.default_schema">CASHDATA</prop>
                <prop key="hibernate.current_session_context_class">thread</prop>
                <!--  <prop key="hibernate.transaction.factory_class">org.hibernate.engine.transaction.internal.jdbc.JdbcTransactionFactory</prop> -->
                <prop key="hibernate.transaction.coordinator_class">jdbc</prop>
                <prop key="hibernate.connection.release_mode">after_transaction</prop>
                <prop key="hibernate.max_fetch_depth">4</prop>
                <prop key="hibernate.jdbc.fetch_size">50</prop>
                <prop key="hibernate.jdbc.batch_size">50</prop>
                <prop key="hibernate.order_inserts">true</prop>
                <prop key="hibernate.order_updates">true</prop>
                <prop key="hibernate.jdbc.batch_versioned_data">true</prop>               
                <prop key="hibernate.cache.use_second_level_cache">false</prop>
                <prop key="hibernate.cache.use_query_cache">false</prop>
                <prop key="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</prop>
                <prop key="hibernate.id.new_generator_mappings">true</prop>
                <prop key="hibernate.hql.bulk_id_strategy">org.hibernate.hql.spi.id.inline.InlineIdsInClauseBulkIdStrategy</prop>
                <prop key="hibernate.allow_update_outside_transaction">true</prop>
                
                <prop key="hibernate.use_sql_comments">true</prop>
                
            </props>
        </property>
    </bean>

Hibernate超时测试代码 #

@Test
public void timeoutTest2()
{
    Session se = sessionFactory.openSession();
    
    String query = """
            select c.id
            from Transaction c
            join Customer k on k.id = c.kd_id
            where k.kd_nr = 35
            """;
    
    List<BigDecimal> resultList = se.createNativeQuery(query)        
    //.setHint("org.hibernate.timeout", 1)
    .setTimeout(1)
    .getResultList();
    
    se.close();
    
    System.out.println(resultList.size());
    
    assertTrue(resultList.size() > 0);
    
}

JDBC超时测试代码 #

try
{
    //Class.forName(OracleDriver.class.getClass().getName().toString()).newInstance();
    Connection conn = DriverManager
            .getConnection("jdbc:oracle:thin:@127.0.0.1:1521/LTOI", "user", "password");            
    
    conn.setAutoCommit(false);
    
    PreparedStatement statement = conn.prepareStatement("select * from cashdata.neu_cashpoint_xml");
    statement.setQueryTimeout(2);
    statement.setFetchSize(1000000);
    
    ResultSet result = statement.executeQuery();
    
    while (result.next())
    {                
        System.out.println(result.getBigDecimal(1));                
    }
    
    conn.commit();
    result.close();
    statement.close();
    conn.close();
}
catch (SQLException e)
{
    System.out.println(e.getMessage());
}

可行的强制超时方案 #

1. 修正Oracle JDBC驱动的使用方式 #

Oracle JDBC thin驱动的setQueryTimeout有明确局限性：

• 仅在结果集分批获取阶段生效，不会中断数据库端的查询执行过程。
• 若设置超大fetchSize（如测试代码中的1000000），驱动会一次性拉取大量数据，超时检查只会在这批数据获取完成后触发，导致超时失效。

解决方法：

• 降低fetchSize至合理值（比如保持Hibernate默认的50），让驱动分批获取数据，确保超时检查能在每批数据获取时触发。

2. 数据库端设置查询超时（最可靠） #

直接在Oracle数据库层面设置超时，从根源中断长耗时查询：

• 会话级超时：在执行目标查询前，执行ALTER SESSION SET QUERY_TIMEOUT = 10;（单位：秒），该设置对当前会话的所有查询生效。可以通过Hibernate拦截器或事件监听器，在会话打开时自动执行这条语句。
• 系统级默认超时：联系DBA修改数据库参数QUERY_TIMEOUT，对所有新会话生效（需权限）。

3. 修正Hibernate超时配置 #

Hibernate的setTimeout方法依赖JDBC驱动支持，结合Oracle特性调整：

• 对于原生查询，使用org.hibernate.timeout提示替代setTimeout，确保Hibernate正确传递超时参数到JDBC：

  List<BigDecimal> resultList = se.createNativeQuery(query)        
      .setHint("org.hibernate.timeout", 1)
      .getResultList();
  

4. 应用层线程中断兜底 #

如果数据库端和JDBC方案无法满足需求，可在应用层通过线程中断强制终止查询：

• 将查询逻辑放入独立线程，设置超时时间，超时后调用线程interrupt()方法。需确保Hibernate/JDBC操作响应线程中断，示例：

  ExecutorService executor = Executors.newSingleThreadExecutor();
  Future<List<BigDecimal>> future = executor.submit(() -> {
      try (Session se = sessionFactory.openSession()) {
          return se.createNativeQuery(query)
              .getResultList();
      }
  });
  
  try {
      List<BigDecimal> resultList = future.get(1, TimeUnit.SECONDS);
      System.out.println(resultList.size());
  } catch (TimeoutException e) {
      future.cancel(true); // 中断线程
      System.out.println("查询超时，已终止");
  } finally {
      executor.shutdown();
  }
  

5. 替换为支持超时的连接池 #

当前使用的DriverManagerDataSource是简单数据源，无连接级超时管理。替换为HikariCP或Apache DBCP2等专业连接池，配置连接超时与查询超时：

• HikariCP示例配置：

  <bean id="dataSource" class="com.zaxxer.hikari.HikariDataSource">
      <property name="driverClassName" value="oracle.jdbc.OracleDriver"/>
      <property name="jdbcUrl" value="jdbc:oracle:thin:@localhost:1521/ltoi"/>
      <property name="username" value=""/>
      <property name="password" value=""/>
      <property name="connectionTimeout" value="3000"/> <!-- 连接超时（毫秒） -->
      <property name="validationTimeout" value="1000"/>
      <property name="maxLifetime" value="1800000"/>
  </bean>
  

  专业连接池能更可靠地管理连接生命周期，避免资源泄漏。

内容的提问来源于stack exchange，提问作者Ivan Penkov