Spring Boot整合PostgreSQL+Hibernate Search多实体全文搜索问题求助

问题1：多SQL函数注册仅最后一个生效 #

你遇到的并非函数注册失败，而是SQLFunctionTemplate的模板语法存在解析歧义，导致后续注册的函数覆盖了前者。改用StandardSQLFunction并自定义渲染逻辑，可确保每个函数独立可解析：

public class FullTextSearchContributor implements MetadataBuilderContributor {
    @Override
    public void contribute(MetadataBuilder metadataBuilder) {
        // 固定列的全文搜索函数
        metadataBuilder.applySqlFunction(
            "pfts",
            new StandardSQLFunction(
                "pfts",
                BooleanType.INSTANCE,
                (functionName, arguments, factory) -> new SelfRenderingSqmFunction(
                    functionName,
                    BooleanType.INSTANCE,
                    arguments,
                    (context, function, args) -> {
                        context.getWriter().write("to_tsvector(name || description) @@ to_tsquery(");
                        args.get(0).render(context);
                        context.getWriter().write(")");
                    }
                )
            )
        );

        // 动态列的全文搜索函数
        metadataBuilder.applySqlFunction(
            "cfts",
            new StandardSQLFunction(
                "cfts",
                BooleanType.INSTANCE,
                (functionName, arguments, factory) -> new SelfRenderingSqmFunction(
                    functionName,
                    BooleanType.INSTANCE,
                    arguments,
                    (context, function, args) -> {
                        context.getWriter().write("to_tsvector(");
                        args.get(0).render(context);
                        context.getWriter().write(") @@ to_tsquery(");
                        args.get(1).render(context);
                        context.getWriter().write(")");
                    }
                )
            )
        );
    }
}

问题2：动态传递搜索字段参数失败 #

你用?1传递列名的方式错误——Hibernate参数绑定仅针对值类型，会将列名解析成字符串常量（比如传入"title || content"会被当成字符串而非列引用）。推荐两种可靠解决方式：

方式1：原生SQL+列名白名单（简单场景） #

直接拼接列名并通过白名单校验防止SQL注入：

@Repository
public class ProductRepository {
    @Autowired
    private EntityManager em;

    public List<Product> search(String columns, String query) {
        // 白名单校验，拦截非法列名
        Set<String> allowedCols = Set.of("name", "description", "sku");
        for (String col : columns.split("\\|\\|")) {
            if (!allowedCols.contains(col.trim())) {
                throw new IllegalArgumentException("非法列名");
            }
        }

        String sql = String.format(
            "SELECT p FROM Product p WHERE to_tsvector(%s) @@ to_tsquery(:query)",
            columns
        );
        return em.createQuery(sql, Product.class)
                 .setParameter("query", query)
                 .getResultList();
    }
}

方式2：Criteria API动态构建（类型安全，推荐） #

通过Criteria API动态拼接列，避免手动拼接SQL：

@Repository
public class GenericFullTextSearchRepository<T> {
    @Autowired
    private EntityManager em;

    public List<T> search(Class<T> entityClass, List<String> columnNames, String query) {
        CriteriaBuilder cb = em.getCriteriaBuilder();
        CriteriaQuery<T> cq = cb.createQuery(entityClass);
        Root<T> root = cq.from(entityClass);

        // 拼接指定列生成ts_vector表达式
        Expression<String> tsVector = cb.concat(root.get(columnNames.get(0)), root.get(columnNames.get(1)));
        for (int i = 2; i < columnNames.size(); i++) {
            tsVector = cb.concat(tsVector, root.get(columnNames.get(i)));
        }

        // 构建全文搜索条件
        Predicate searchPredicate = cb.equal(
            cb.function("to_tsvector", Boolean.class, tsVector),
            cb.function("to_tsquery", Boolean.class, cb.parameter(String.class, "query"))
        );

        cq.where(searchPredicate);
        return em.createQuery(cq)
                 .setParameter("query", query)
                 .getResultList();
    }
}

满足核心需求：多实体无关联动态全文搜索 #

基于通用仓库实现跨实体搜索，无需表关联：

@Service
public class FullTextSearchService {
    @Autowired
    private GenericFullTextSearchRepository genericRepo;

    // 搜索Product实体的name+description列
    public List<Product> searchProducts(String query) {
        return genericRepo.search(Product.class, List.of("name", "description"), query);
    }

    // 搜索Article实体的title+content列
    public List<Article> searchArticles(String query) {
        return genericRepo.search(Article.class, List.of("title", "content"), query);
    }
}

额外性能优化建议 #

1. 为常用列组合生成PostgreSQL存储列并创建GIN索引：

   ALTER TABLE product ADD COLUMN ts_vector tsvector GENERATED ALWAYS AS (to_tsvector(name || description)) STORED;
   CREATE INDEX idx_product_tsv ON product USING gin(ts_vector);
   

   查询时直接使用预生成的ts_vector列，避免实时拼接计算。

2. 使用plainto_tsquery替代to_tsquery，支持自然语言查询（无需手动输入布尔运算符）。

内容的提问来源于stack exchange，提问作者User Data Management