如何在发送至EntityManager前动态修改预定义JPA查询？

针对你的需求——不改动现有JPA查询方法，在查询发送至EntityManager前动态添加前置条件，以下是可行的方案：

1. 使用Hibernate StatementInspector 拦截并修改SQL #

这是最轻量化的方案，不需要修改任何Repository代码，全局或按需拦截SQL语句并追加动态条件：

• 实现org.hibernate.resource.jdbc.spi.StatementInspector接口，重写inspect方法，在方法里解析原始SQL，根据当前请求上下文的参数拼接动态WHERE条件：

public class DynamicFilterStatementInspector implements StatementInspector {
    // 用ThreadLocal传递当前请求的动态过滤参数，比如从请求上下文获取
    private static final ThreadLocal<Map<String, Object>> FILTER_PARAMS = new ThreadLocal<>();

    public static void setFilterParams(Map<String, Object> params) {
        FILTER_PARAMS.set(params);
    }

    public static void clearFilterParams() {
        FILTER_PARAMS.remove();
    }

    @Override
    public String inspect(String sql) {
        Map<String, Object> params = FILTER_PARAMS.get();
        if (params == null || params.isEmpty()) {
            return sql;
        }
        // 解析SQL，拼接动态条件（复杂场景建议用JSqlParser等SQL解析库处理）
        StringBuilder filteredSql = new StringBuilder(sql);
        if (sql.contains("WHERE")) {
            filteredSql.append(" AND ");
        } else {
            filteredSql.append(" WHERE ");
        }
        // 动态组合AND/OR条件，示例：status = :status AND category IN (:categories)
        List<String> conditions = new ArrayList<>();
        params.forEach((key, value) -> {
            if (value instanceof Collection) {
                conditions.add(key + " IN (:" + key + ")");
            } else {
                conditions.add(key + " = :" + key);
            }
        });
        filteredSql.append(String.join(" AND ", conditions));
        return filteredSql.toString();
    }
}

• 在Spring Boot配置中指定该Inspector：

spring.jpa.properties.hibernate.session_factory.statement_inspector=com.yourpackage.DynamicFilterStatementInspector

• 在请求拦截器或切面中，把当前请求的动态参数存入ThreadLocal，查询完成后清理。

2. 自定义Spring Data JPA Repository基类 #

通过扩展SimpleJpaRepository，重写查询执行逻辑，动态为派生查询或@Query查询添加条件：

• 创建自定义Repository基类：

public class CustomJpaRepository<T, ID> extends SimpleJpaRepository<T, ID> {
    private final EntityManager entityManager;

    public CustomJpaRepository(JpaEntityInformation<T, ?> entityInformation, EntityManager entityManager) {
        super(entityInformation, entityManager);
        this.entityManager = entityManager;
    }

    // 重写派生查询的执行方法，比如findBy...系列方法
    @Override
    public <S extends T> List<S> findAll(Example<S> example) {
        // 获取动态条件
        Predicate dynamicPredicate = buildDynamicPredicate(getDomainClass());
        // 合并原有Example的Predicate和动态Predicate
        ExampleMatcher matcher = example.getMatcher();
        Predicate examplePredicate = getQueryByExamplePredicate(example.getProbe(), matcher);
        Predicate combinedPredicate = entityManager.getCriteriaBuilder().and(examplePredicate, dynamicPredicate);
        
        CriteriaQuery<S> query = entityManager.getCriteriaBuilder().createQuery((Class<S>) getDomainClass());
        Root<S> root = query.from((Class<S>) getDomainClass());
        query.where(combinedPredicate);
        return entityManager.createQuery(query).getResultList();
    }

    // 重写findOne等其他需要增强的方法...

    // 构建动态Predicate，从请求上下文获取参数
    private <S> Predicate buildDynamicPredicate(Class<S> domainClass) {
        CriteriaBuilder cb = entityManager.getCriteriaBuilder();
        Root<S> root = cb.createQuery(domainClass).from(domainClass);
        List<Predicate> predicates = new ArrayList<>();
        // 示例：根据请求上下文添加status和category的动态组合条件
        String status = RequestContextHolder.getRequestAttributes().getAttribute("status", RequestAttributes.SCOPE_REQUEST);
        String category = RequestContextHolder.getRequestAttributes().getAttribute("category", RequestAttributes.SCOPE_REQUEST);
        if (status != null) {
            predicates.add(cb.equal(root.get("status"), status));
        }
        if (category != null) {
            predicates.add(cb.equal(root.get("category"), category));
        }
        // 支持AND/OR组合，根据参数判断组合方式
        String combineType = RequestContextHolder.getRequestAttributes().getAttribute("combineType", RequestAttributes.SCOPE_REQUEST);
        if ("OR".equals(combineType)) {
            return cb.or(predicates.toArray(new Predicate[0]));
        } else {
            return cb.and(predicates.toArray(new Predicate[0]));
        }
    }
}

• 在Repository接口上指定基类：

@RepositoryDefinition(repositoryBaseClass = CustomJpaRepository.class)
public interface MyRepository extends JpaRepository<User, Long> {
    List<User> findByUserName(String userName); // 原有方法无需修改
}

3. Spring AOP 切面拦截Repository方法 #

通过AOP拦截所有Repository方法调用，动态修改查询逻辑：

• 定义切面，拦截Repository的方法：

@Aspect
@Component
public class RepositoryQueryEnhancerAspect {
    @Autowired
    private EntityManager entityManager;

    @Around("execution(* com.yourpackage.repository..*(..))")
    public Object enhanceQuery(ProceedingJoinPoint joinPoint) throws Throwable {
        // 获取方法元数据，判断是否是JPA查询方法
        Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
        RepositoryQuery repositoryQuery = getRepositoryQuery(method);
        if (repositoryQuery == null) {
            return joinPoint.proceed();
        }

        // 获取原始查询语句
        String originalQuery = getOriginalQuery(repositoryQuery);
        // 构建动态条件
        String dynamicCondition = buildDynamicCondition();
        // 修改查询语句
        String modifiedQuery = originalQuery + (originalQuery.contains("WHERE") ? " AND " : " WHERE ") + dynamicCondition;

        // 执行修改后的查询
        Query query = entityManager.createQuery(modifiedQuery);
        // 设置原有方法的参数
        Object[] args = joinPoint.getArgs();
        for (int i = 0; i < args.length; i++) {
            query.setParameter(i + 1, args[i]);
        }
        // 添加动态条件的参数
        Map<String, Object> dynamicParams = getDynamicParams();
        dynamicParams.forEach(query::setParameter);

        return query.getResultList();
    }

    // 辅助方法：根据Spring Data版本实现获取RepositoryQuery、原始查询语句等逻辑
    private RepositoryQuery getRepositoryQuery(Method method) {
        // 示例：通过Spring Data的RepositoryFactoryBean获取对应查询对象
        return null;
    }

    private String getOriginalQuery(RepositoryQuery repositoryQuery) {
        if (repositoryQuery instanceof AbstractJpaQuery) {
            return ((AbstractJpaQuery) repositoryQuery).getQueryString();
        }
        return null;
    }

    private String buildDynamicCondition() {
        // 根据请求上下文构建动态条件字符串，比如"status = :status OR category = :category"
        return "";
    }

    private Map<String, Object> getDynamicParams() {
        // 获取动态条件的参数
        return new HashMap<>();
    }
}

方案对比 #

• 对比JPA Specification：无需修改现有方法签名，不用额外传递Specification参数
• 对比Hibernate Filters：无需预先定义Filter条件，完全支持动态组合AND/OR逻辑
• 对比QueryRewriter：无需将所有派生查询改为@Query字符串形式，保留原有方法的简洁性

内容的提问来源于stack exchange，提问作者Ravina Motwani