使用Java SqlBuilder创建含AND/OR条件的动态SQL查询求助

我完全懂你遇到的这个麻烦——用Java的SqlBuilder构建混合了AND和OR的动态SQL，尤其是还要处理随机出现的多条件组合，很容易把逻辑搞乱或者写出有优先级问题的查询。别慌，咱们核心思路就是用条件分组（括号）明确逻辑优先级，绝大多数Java SqlBuilder库都支持嵌套条件的构建，下面结合你的示例一步步说明：

1. 先拆解你的目标条件逻辑 #

你的目标WHERE子句本质上是两个逻辑块的OR组合：

块1：t2.creditLimit > 70000 AND t2.creditLimit < 100000（两个用AND关联的条件）
块2：t0.officeCode = 6（单个独立条件）

咱们要先分别构建每个逻辑块，再把它们用OR连接起来，这样就能避免逻辑优先级混乱。

2. 以Apache Commons DbUtils SqlBuilder为例（主流实现之一） #

如果你用的是Apache Commons DbUtils的SqlBuilder，可以通过嵌套子条件的方式实现：

// 初始化主SqlBuilder
SqlBuilder mainBuilder = new SqlBuilder();

// 构建第一个逻辑块：(creditLimit >70000 AND creditLimit <100000)
SqlBuilder creditLimitGroup = new SqlBuilder();
creditLimitGroup.where("t2.creditLimit > ?", 70000)
               .and("t2.creditLimit < ?", 100000);

// 构建第二个逻辑块：t0.officeCode = ?
SqlBuilder officeCodeGroup = new SqlBuilder();
officeCodeGroup.where("t0.officeCode = ?", 6);

// 把两个块用OR连接，注意给每个块加括号保证优先级
mainBuilder.where("(" + creditLimitGroup.getWhereClause() + ") OR " + officeCodeGroup.getWhereClause());

// 合并参数（一定要保证参数顺序和占位符对应）
mainBuilder.addParameters(creditLimitGroup.getParameters());
mainBuilder.addParameters(officeCodeGroup.getParameters());

// 拼接完整SQL（结合你的SELECT和JOIN部分）
String finalSql = "SELECT * FROM classicmodels.offices t1 "
                + "INNER JOIN classicmodels.employees t0 ON (t1.officeCode = t0.officeCode) "
                + "INNER JOIN classicmodels.customers t2 ON (t0.employeeNumber = t2.salesRepEmployeeNumber OR t0.firstName = t2.contactFirstName) "
                + mainBuilder.getWhereClause()
                + " ORDER BY t0.firstName ASC";

3. 处理动态随机的多个AND/OR条件 #

如果你的条件是动态生成的（比如用户前端多选筛选，可能随机出现多组AND/OR条件），可以抽象一个简单的工具方法来处理条件分组：

第一步：定义条件组模型 #

先搞一个简单的类来封装一组用AND关联的条件，以及对应的参数：

// 简单的条件组类，用来包裹一组AND条件
static class ConditionGroup {
    private List<String> conditionExpressions;
    private List<Object> parameters;

    // 构造器、getter/setter按需实现即可
}

第二步：编写动态构建方法 #

这个方法负责把多个ConditionGroup用OR连接，自动给每个组加括号：

public static String buildDynamicWhere(List<ConditionGroup> conditionGroups, List<Object> collectedParams) {
    if (conditionGroups == null || conditionGroups.isEmpty()) {
        return ""; // 没有条件就返回空，避免WHERE关键字多余
    }

    StringBuilder whereClause = new StringBuilder("WHERE ");
    Iterator<ConditionGroup> groupIterator = conditionGroups.iterator();

    while (groupIterator.hasNext()) {
        ConditionGroup currentGroup = groupIterator.next();
        // 用括号包裹当前组的AND条件
        whereClause.append("(");
        
        Iterator<String> condIterator = currentGroup.getConditionExpressions().iterator();
        while (condIterator.hasNext()) {
            whereClause.append(condIterator.next());
            if (condIterator.hasNext()) {
                whereClause.append(" AND ");
            }
        }
        
        whereClause.append(")");
        if (groupIterator.hasNext()) {
            whereClause.append(" OR ");
        }
        // 收集当前组的参数，统一后续绑定
        collectedParams.addAll(currentGroup.getParameters());
    }

    return whereClause.toString();
}

第三步：用这个方法处理你的示例 #

List<ConditionGroup> groups = new ArrayList<>();

// 第一个组：信用额度范围条件
ConditionGroup creditGroup = new ConditionGroup();
creditGroup.setConditionExpressions(Arrays.asList("t2.creditLimit > ?", "t2.creditLimit < ?"));
creditGroup.setParameters(Arrays.asList(70000, 100000));
groups.add(creditGroup);

// 第二个组：办公室代码条件
ConditionGroup officeGroup = new ConditionGroup();
officeGroup.setConditionExpressions(Collections.singletonList("t0.officeCode = ?"));
officeGroup.setParameters(Collections.singletonList(6));
groups.add(officeGroup);

// 收集所有参数
List<Object> allParams = new ArrayList<>();
String dynamicWhere = buildDynamicWhere(groups, allParams);

// 拼接最终SQL
String finalSql = "SELECT * FROM classicmodels.offices t1 "
                + "INNER JOIN classicmodels.employees t0 ON (t1.officeCode = t0.officeCode) "
                + "INNER JOIN classicmodels.customers t2 ON (t0.employeeNumber = t2.salesRepEmployeeNumber OR t0.firstName = t2.contactFirstName) "
                + dynamicWhere
                + " ORDER BY t0.firstName ASC";

4. 其他SqlBuilder库的通用思路 #

不管你用的是MyBatis的Criteria、Querydsl还是其他ORM的SqlBuilder工具，核心逻辑都是一样的：

• 嵌套条件：用库提供的API来嵌套条件（比如MyBatis里or()方法内部包裹and()组合）
• 明确优先级：始终用括号把逻辑上属于同一组的AND条件包裹，再和其他组用OR关联
• 参数绑定：一定要用占位符（?或者命名参数），绝对不要直接拼接参数，避免SQL注入风险

比如MyBatis的实现示例：

Criteria criteria = new Criteria();
// 第一个OR块：信用额度范围
criteria.or(criteria.createCriteria()
    .andGreaterThan("t2.creditLimit", 70000)
    .andLessThan("t2.creditLimit", 100000));
// 第二个OR块：办公室代码
criteria.or(criteria.createCriteria()
    .andEqualTo("t0.officeCode", 6));

// 生成WHERE子句
String whereClause = criteria.toSqlString();

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