Hibernate参数化查询改造：多条件分支现有查询优化方案

嘿，我来帮你把这段存在SQL注入风险的拼接HQL代码改成安全的参数化查询，主要有两种常用的实现方式，我都给你详细演示一下：

方法一：使用参数化HQL拼接 #

这种方式保留了你原来的条件判断逻辑，但把字符串拼接的变量替换成Hibernate的命名参数，避免直接拼接用户输入，彻底杜绝SQL注入风险。

实现代码 #

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;

public List<PaymentConfiguration> getPaymentConfigurations(String countryCode, String currencyCode, String paymentCategory, String paymentType, String region) {
    Session session = getCurrentSession();
    List<PaymentConfiguration> results = new ArrayList<>();
    try {
        StringBuilder hql = new StringBuilder("from PaymentConfiguration where activeIndicator = 'Y'");
        
        // 处理countryCode条件：使用命名参数:countryCode
        hql.append(" AND (countryCode is null OR countryCode = :countryCode)");
        
        // 处理currencyCode条件：非空时添加参数化片段
        if (null != currencyCode && !currencyCode.isEmpty()) {
            hql.append(" AND (billingCurrencyCode is null OR billingCurrencyCode = :currencyCode)");
        }
        
        // 处理paymentCategory条件：非空时添加参数化片段
        if (null != paymentCategory && !paymentCategory.isEmpty()) {
            hql.append(" AND paymentCategory = :paymentCategory");
        }
        
        // 处理paymentType条件：非空时添加参数化片段
        if (null != paymentType && !paymentType.isEmpty()) {
            hql.append(" AND paymentType = :paymentType");
        }
        
        // 处理region对应的vendorId条件：用参数化列表传递in值
        if (null != region && region.equalsIgnoreCase("Domestic")) {
            hql.append(" AND vendorId in (:domesticVendors)");
        } else {
            hql.append(" AND vendorId in (:internationalVendors)");
        }
        
        // 创建查询并绑定所有参数
        Query query = session.createQuery(hql.toString());
        query.setParameter("countryCode", countryCode);
        
        if (null != currencyCode && !currencyCode.isEmpty()) {
            query.setParameter("currencyCode", currencyCode);
        }
        
        if (null != paymentCategory && !paymentCategory.isEmpty()) {
            query.setParameter("paymentCategory", paymentCategory);
        }
        
        if (null != paymentType && !paymentType.isEmpty()) {
            query.setParameter("paymentType", paymentType);
        }
        
        // 绑定vendorId的列表参数
        if (null != region && region.equalsIgnoreCase("Domestic")) {
            query.setParameterList("domesticVendors", Arrays.asList("v1", "v2", "v3"));
        } else {
            query.setParameterList("internationalVendors", Arrays.asList("v1", "v3", "v4"));
        }
        
        results = query.list();
    } catch (Exception e) {
        // 这里可以添加自定义的异常处理逻辑，比如日志记录
        e.printStackTrace();
    }
    return results;
}

关键说明 #

• 所有动态变量都用命名参数（比如:countryCode）代替直接字符串拼接，Hibernate会自动处理参数的转义，避免SQL注入。
• 对于IN语句的列表值，使用setParameterList方法绑定，比直接拼接列表更安全也更灵活。
• 条件判断逻辑和原来保持一致，只是把拼接的字符串改成参数化片段，学习成本低。

方法二：使用Hibernate Criteria API（面向对象式查询） #

如果你的条件逻辑比较复杂，推荐用Criteria API，它完全不需要拼接字符串，用面向对象的方式构建查询，可读性和可维护性更强，同样自动支持参数化。

实现代码 #

import java.util.ArrayList;
import java.util.List;
import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.criterion.Disjunction;
import org.hibernate.criterion.Restrictions;

public List<PaymentConfiguration> getPaymentConfigurations(String countryCode, String currencyCode, String paymentCategory, String paymentType, String region) {
    Session session = getCurrentSession();
    List<PaymentConfiguration> results = new ArrayList<>();
    try {
        Criteria criteria = session.createCriteria(PaymentConfiguration.class);
        
        // 基础条件：activeIndicator = 'Y'
        criteria.add(Restrictions.eq("activeIndicator", "Y"));
        
        // countryCode条件：is null 或者等于传入值（用Disjunction实现OR逻辑）
        Disjunction countryDisjunction = Restrictions.disjunction();
        countryDisjunction.add(Restrictions.isNull("countryCode"));
        countryDisjunction.add(Restrictions.eq("countryCode", countryCode));
        criteria.add(countryDisjunction);
        
        // currencyCode条件：非空时添加OR逻辑
        if (null != currencyCode && !currencyCode.isEmpty()) {
            Disjunction currencyDisjunction = Restrictions.disjunction();
            currencyDisjunction.add(Restrictions.isNull("billingCurrencyCode"));
            currencyDisjunction.add(Restrictions.eq("billingCurrencyCode", currencyCode));
            criteria.add(currencyDisjunction);
        }
        
        // paymentCategory条件：非空时添加等于判断
        if (null != paymentCategory && !paymentCategory.isEmpty()) {
            criteria.add(Restrictions.eq("paymentCategory", paymentCategory));
        }
        
        // paymentType条件：非空时添加等于判断
        if (null != paymentType && !paymentType.isEmpty()) {
            criteria.add(Restrictions.eq("paymentType", paymentType));
        }
        
        // region对应的vendorId条件
        if (null != region && region.equalsIgnoreCase("Domestic")) {
            criteria.add(Restrictions.in("vendorId", "v1", "v2", "v3"));
        } else {
            criteria.add(Restrictions.in("vendorId", "v1", "v3", "v4"));
        }
        
        results = criteria.list();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return results;
}

关键说明 #

• 用Restrictions类的静态方法构建查询条件，完全不需要手写HQL字符串，避免拼写错误。
• Disjunction用于构建OR逻辑，默认的条件组合是AND逻辑，逻辑关系清晰。
• 所有条件自动参数化，Hibernate会处理底层的SQL生成和参数绑定，安全性拉满。

额外推荐：JPA CriteriaBuilder（适用于新版本Hibernate） #

如果你的项目使用Hibernate 5.x+，官方更推荐使用JPA标准的CriteriaBuilder，用法和Hibernate Criteria类似，但更符合JPA规范：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;

public List<PaymentConfiguration> getPaymentConfigurations(String countryCode, String currencyCode, String paymentCategory, String paymentType, String region) {
    EntityManager em = getEntityManager(); // 假设你有获取EntityManager的方法
    List<PaymentConfiguration> results = new ArrayList<>();
    try {
        CriteriaBuilder cb = em.getCriteriaBuilder();
        CriteriaQuery<PaymentConfiguration> cq = cb.createQuery(PaymentConfiguration.class);
        Root<PaymentConfiguration> root = cq.from(PaymentConfiguration.class);
        
        // 基础条件
        Predicate activePredicate = cb.equal(root.get("activeIndicator"), "Y");
        
        // countryCode的OR条件
        Predicate countryPredicate = cb.or(cb.isNull(root.get("countryCode")), cb.equal(root.get("countryCode"), countryCode));
        
        // 组合初始条件
        Predicate finalPredicate = cb.and(activePredicate, countryPredicate);
        
        // 添加currencyCode条件
        if (null != currencyCode && !currencyCode.isEmpty()) {
            Predicate currencyPredicate = cb.or(cb.isNull(root.get("billingCurrencyCode")), cb.equal(root.get("billingCurrencyCode"), currencyCode));
            finalPredicate = cb.and(finalPredicate, currencyPredicate);
        }
        
        // 添加paymentCategory条件
        if (null != paymentCategory && !paymentCategory.isEmpty()) {
            Predicate categoryPredicate = cb.equal(root.get("paymentCategory"), paymentCategory);
            finalPredicate = cb.and(finalPredicate, categoryPredicate);
        }
        
        // 添加paymentType条件
        if (null != paymentType && !paymentType.isEmpty()) {
            Predicate typePredicate = cb.equal(root.get("paymentType"), paymentType);
            finalPredicate = cb.and(finalPredicate, typePredicate);
        }
        
        // 添加vendorId条件
        Predicate vendorPredicate;
        if (null != region && region.equalsIgnoreCase("Domestic")) {
            vendorPredicate = root.get("vendorId").in(Arrays.asList("v1", "v2", "v3"));
        } else {
            vendorPredicate = root.get("vendorId").in(Arrays.asList("v1", "v3", "v4"));
        }
        finalPredicate = cb.and(finalPredicate, vendorPredicate);
        
        cq.where(finalPredicate);
        results = em.createQuery(cq).getResultList();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return results;
}

总结 #

• 如果你的查询逻辑相对简单，参数化HQL拼接是最直接的改造方式，和原有代码风格接近。
• 如果查询条件复杂、经常变动，Criteria API/CriteriaBuilder更适合，代码可读性和可维护性更好。
• 两种方式都能彻底避免SQL注入，符合安全规范。

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