如何验证Spring JPA Repository执行的查询并检查未查询特定表？

针对你修复懒加载后需要验证查询行为的需求，这里提供几个可落地的测试实现方案：

方案一：利用Hibernate统计器监控查询 #

Spring Data JPA默认用Hibernate作为实现时，可以开启Hibernate的统计功能，直接获取执行的查询统计数据：

1. 首先在测试环境配置中开启统计：
   在application-test.yml添加：

   spring:
     jpa:
       properties:
         hibernate:
           generate_statistics: true
           stats:
             enabled: true
   

2. 测试类中通过EntityManager获取统计对象，验证查询行为：

   @SpringBootTest
   @Transactional
   class RepositoryTest {
       @Autowired
       private EntityManager entityManager;
       @Autowired
       private YourRepository yourRepository;
   
       @Test
       void shouldNotFetchAssociatedTable() {
           // 执行Repository方法
           YourEntity entity = yourRepository.findById(1L).orElseThrow();
           // 触发懒加载（如果有的话）
           entity.getAssociatedEntity();
   
           // 获取Hibernate统计对象
           Session session = entityManager.unwrap(Session.class);
           Statistics stats = session.getSessionFactory().getStatistics();
   
           // 验证关联表的获取次数为0（假设关联表对应实体是AssociatedEntity）
           Assertions.assertEquals(0, stats.getEntityFetchCount(AssociatedEntity.class));
           // 或者验证总查询次数符合预期（比如只执行了1次主表查询）
           Assertions.assertEquals(1, stats.getQueryExecutionCount());
       }
   }
   

方案二：自定义SQL拦截器捕获执行语句 #

通过Hibernate的StatementInspector拦截所有执行的SQL，收集后验证是否包含特定表的查询：

1. 实现自定义Inspector：

   public class SqlCapturingInspector implements StatementInspector {
       private final List<String> executedSql = new ArrayList<>();
   
       @Override
       public String inspect(String sql) {
           executedSql.add(sql);
           return sql;
       }
   
       public List<String> getExecutedSql() {
           return executedSql;
       }
   }
   

2. 测试类中注册并使用这个Inspector：

   @SpringBootTest
   @Transactional
   class RepositoryTest {
       @Autowired
       private EntityManager entityManager;
       @Autowired
       private YourRepository yourRepository;
       private SqlCapturingInspector sqlInspector;
   
       @BeforeEach
       void setUp() {
           sqlInspector = new SqlCapturingInspector();
           Session session = entityManager.unwrap(Session.class);
           // 注册自定义Inspector
           session.setStatementInspector(sqlInspector);
       }
   
       @Test
       void shouldNotQueryAssociatedTable() {
           // 执行查询操作
           YourEntity entity = yourRepository.findById(1L).orElseThrow();
           entity.getAssociatedEntity();
   
           // 验证所有执行的SQL中不包含关联表的查询
           boolean hasAssociatedTableQuery = sqlInspector.getExecutedSql().stream()
                   .anyMatch(sql -> sql.contains("SELECT * FROM associated_table"));
           Assertions.assertFalse(hasAssociatedTableQuery);
       }
   }
   

方案三：通过日志捕获SQL并断言 #

如果不想写复杂的拦截器，可以配置日志级别为DEBUG，捕获Hibernate输出的SQL语句，再验证内容：

1. 配置测试环境的日志（比如logback-test.xml）：

   <logger name="org.hibernate.SQL" level="DEBUG" />
   

2. 用日志捕获工具（比如SLF4J的MemoryAppender）收集日志，然后断言：

   @SpringBootTest
   @Transactional
   class RepositoryTest {
       @Autowired
       private YourRepository yourRepository;
       private MemoryAppender memoryAppender;
   
       @BeforeEach
       void setUp() {
           memoryAppender = new MemoryAppender();
           Logger logger = (Logger) LoggerFactory.getLogger("org.hibernate.SQL");
           logger.addAppender(memoryAppender);
           memoryAppender.start();
       }
   
       @AfterEach
       void tearDown() {
           Logger logger = (Logger) LoggerFactory.getLogger("org.hibernate.SQL");
           logger.removeAppender(memoryAppender);
           memoryAppender.stop();
       }
   
       @Test
       void shouldNotQueryAssociatedTable() {
           yourRepository.findById(1L).orElseThrow().getAssociatedEntity();
   
           List<ILoggingEvent> events = memoryAppender.getLoggedEvents();
           boolean hasAssociatedQuery = events.stream()
                   .map(ILoggingEvent::getMessage)
                   .anyMatch(msg -> msg.contains("associated_table"));
           Assertions.assertFalse(hasAssociatedQuery);
       }
   }
   

这些方案都能帮你验证修复后的懒加载行为是否符合预期，确保没有额外查询关联表。

内容的提问来源于stack exchange，提问作者Ben Green