能否构建自定义Spring JPA Repository自动追加Where条件？

完全可以实现你需求的低侵入式全局查询条件追加，以下是具体方案分析及实现方式：

核心方案推荐 #

方案1：自定义Repository基类+查询拦截（覆盖所有查询场景） #

该方案基于Spring Data JPA原生扩展，既能继承JpaRepository全部功能，又能拦截包括命名查询、JPQL、方法名查询在内的所有查询类型，且侵入性极低。

步骤1：定义自定义Repository接口

让开发者只需继承该接口即可获得增强功能：

public interface CustomJpaRepository<T, ID> extends JpaRepository<T, ID> {
    // 可添加自定义通用方法，比如设置过滤标签的方法
    void setGlobalFilterCondition(String condition);
}

步骤2：实现自定义Repository基类

继承SimpleJpaRepository，重写核心查询方法，并拦截EntityManager的查询创建逻辑：

public class CustomJpaRepositoryImpl<T, ID> extends SimpleJpaRepository<T, ID> implements CustomJpaRepository<T, ID> {

    private final EntityManager entityManager;
    private final ThreadLocal<String> globalFilter = new ThreadLocal<>();

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

    // 重写基础查询方法，追加全局条件
    @Override
    public List<T> findAll() {
        return findAll(getGlobalSpecification());
    }

    @Override
    public Optional<T> findById(ID id) {
        Specification<T> spec = (root, query, cb) -> 
            cb.and(cb.equal(root.get(getIdAttribute()), id), getGlobalSpecification().toPredicate(root, query, cb));
        return findOne(spec);
    }

    // 拦截JPQL查询
    @Override
    public <S extends T> List<S> findAll(@Nullable Specification<S> spec) {
        if (spec == null) {
            spec = (Specification<S>) getGlobalSpecification();
        } else {
            spec = spec.and((Specification<S>) getGlobalSpecification());
        }
        return super.findAll(spec);
    }

    // 处理命名查询和原生JPQL查询的核心逻辑
    private Query wrapQueryWithFilter(Query originalQuery) {
        String originalJpql = originalQuery.unwrap(org.hibernate.query.Query.class).getQueryString();
        String filteredJpql = appendFilterCondition(originalJpql);
        return entityManager.createQuery(filteredJpql);
    }

    // 动态追加Where条件，兼容原始查询已有Where的情况
    private String appendFilterCondition(String originalJpql) {
        String condition = globalFilter.get();
        if (StringUtils.isBlank(condition)) {
            return originalJpql;
        }
        if (originalJpql.contains("WHERE")) {
            return originalJpql.replace("WHERE", "WHERE " + condition + " AND ");
        } else {
            return originalJpql + " WHERE " + condition;
        }
    }

    // 生成全局过滤的Specification
    private Specification<T> getGlobalSpecification() {
        return (root, query, cb) -> cb.and(cb.equal(root.get("filterTag"), globalFilter.get()));
    }

    @Override
    public void setGlobalFilterCondition(String condition) {
        this.globalFilter.set(condition);
    }
}

步骤3：配置自定义Repository工厂

让Spring Data JPA使用你的自定义实现类：

public class CustomJpaRepositoryFactoryBean<T extends Repository<S, ID>, S, ID> extends JpaRepositoryFactoryBean<T, S, ID> {

    public CustomJpaRepositoryFactoryBean(Class<? extends T> repositoryInterface) {
        super(repositoryInterface);
    }

    @Override
    protected RepositoryFactorySupport createRepositoryFactory(EntityManager entityManager) {
        return new CustomJpaRepositoryFactory(entityManager);
    }

    private static class CustomJpaRepositoryFactory extends JpaRepositoryFactory {
        private final EntityManager entityManager;

        public CustomJpaRepositoryFactory(EntityManager entityManager) {
            super(entityManager);
            this.entityManager = entityManager;
        }

        @Override
        protected <T, ID> JpaRepositoryImplementation<T, ID> getTargetRepository(RepositoryInformation info, EntityManager em) {
            JpaEntityInformation<T, ID> entityInfo = getEntityInformation((Class<T>) info.getDomainType());
            return new CustomJpaRepositoryImpl<>(entityInfo, em);
        }

        @Override
        protected Class<?> getRepositoryBaseClass(RepositoryMetadata metadata) {
            return CustomJpaRepositoryImpl.class;
        }
    }
}

步骤4：开启自定义Repository支持

在Spring配置类中指定使用自定义工厂：

@Configuration
@EnableJpaRepositories(
    basePackages = "com.yourcompany.repo",
    repositoryFactoryBeanClass = CustomJpaRepositoryFactoryBean.class
)
public class JpaConfig {
}

方案2：Hibernate底层拦截（侵入性更低） #

通过Hibernate的StatementInspector拦截所有生成的SQL语句，直接追加过滤条件，无需修改Repository结构：

实现自定义Inspector

public class GlobalFilterInspector implements StatementInspector {

    private final ThreadLocal<String> filterCondition = new ThreadLocal<>();

    @Override
    public String inspect(String sql) {
        String condition = filterCondition.get();
        if (StringUtils.isBlank(condition)) {
            return sql;
        }
        // 处理SQL拼接逻辑，需注意子查询、联合查询等复杂场景
        if (sql.contains("WHERE")) {
            return sql + " AND " + condition;
        } else {
            return sql + " WHERE " + condition;
        }
    }

    public void setFilterCondition(String condition) {
        this.filterCondition.set(condition);
    }
}

配置Hibernate使用Inspector

在application.properties中添加：

spring.jpa.properties.hibernate.session_factory.statement_inspector=com.yourcompany.GlobalFilterInspector

关于JpaSpecifications和QueryDsl的局限性 #

• JpaSpecifications：仅能覆盖基于Specification构建的查询，无法拦截命名查询、直接JPQL查询，单独使用无法满足需求。
• QueryDsl：仅能处理自身API构建的查询，若要覆盖所有查询场景，需强制开发者替换所有现有查询为QueryDsl风格，侵入性较高，不符合你的低侵入要求。

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