<think>
我们面对的问题：解析复杂的SQL where条件，将其转换为结构化的Java对象（每个条件对应一个对象，包含表名、字段名、运算符、值等信息）。同时，需要处理多种运算符（包括in, like, >, < 等）以及更复杂的表达式（如A.a + B.b > 100）。
思路：
1. 使用JSqlParser（4.9版本）来解析SQL条件表达式。
2. 遍历表达式树，将每个条件分解为基本元素。
3. 对于复杂表达式（如算术表达式、函数等），我们需要将它们作为一个整体表达式字符串保存，而不是拆分成单一字段。
设计实体类：
我们将设计一个Condition类来承载解析后的条件信息。但是要注意，有些条件可能涉及多个字段（如A.a+B.b>100），此时单个字段名无法表示，因此我们需要增加一个字段用于存储整个表达式的字符串表示。同时，对于简单的字段比较，我们还是希望有表名和字段名。
因此，Condition类可以设计如下：
```java
public class Condition {
private String tableAlias; // 表别名（如果有）
private String tableName; // 表名（实际表名，如果能够获取）
private String fieldName; // 字段名（如果是简单字段条件）
private String operator; // 操作符，如 "=", ">", "<", "like", "in" 等
private Object value; // 值，可能是一个值，也可能是一个数组（对于in操作符）
private String expression; // 整个条件的表达式字符串（当无法用单个字段表示时使用，例如：A.a+B.b>100）
// 标志，表示是否是简单条件（单个字段条件）还是复杂条件
public boolean isSimple() {
return fieldName != null && !fieldName.isEmpty();
}
// 构造方法、getter和setter省略
}
```
解析步骤：
1. 使用JSqlParser将where条件解析成表达式树。
2. 通过实现ExpressionVisitor接口（或使用ExpressionDeParser）来遍历表达式树。
3. 在遍历过程中，识别不同的表达式类型（如比较表达式、like表达式、in表达式等），并转化为Condition对象。
注意：在复杂表达式（如A.a+B.b>100）中，我们无法将其拆解为单个字段，因此我们会将整个表达式字符串存入expression字段，而fieldName、tableName等字段则为空。
实现步骤：
步骤1：添加JSqlParse依赖（4.9版本）
步骤2：编写Condition实体类
步骤3：编写解析工具类，其中包含一个方法，接收一个String类型的where条件表达式，返回一个List<Condition>（因为where条件可能有多个，通过AND/OR连接，但这里我们先处理AND连接的条件，复杂逻辑后续扩展）
注意：我们暂时不考虑OR连接的复杂情况，只考虑用AND连接的多个条件。
由于JSqlParse的表达式解析比较复杂，我们需要针对不同类型的表达式进行处理。
具体处理逻辑：
1. 将where条件字符串解析成Expression对象。
2. 使用一个自定义的ExpressionVisitor来遍历表达式树。
但是，JSqlParse的ExpressionVisitor有很多方法，我们需要覆盖那些我们关心的表达式类型。
我们设计一个自定义的ExpressionVisitor（继承ExpressionVisitorAdapter，这样只需要覆盖需要的方法），在遍历过程中构建Condition对象。
由于表达式树可能是嵌套的，我们只处理最外层的比较表达式（如EqualsTo, GreaterThan, MinorThan, LikeExpression, InExpression等），对于更复杂的表达式（如包含算术运算的），我们将整个表达式作为字符串存储。
具体实现：
我们将识别BinaryExpression（比较表达式都是二元表达式）和InExpression等。对于BinaryExpression，我们可以尝试将其左表达式和右表达式分别解析为字段和值，但如果其中一方是复杂表达式，则整个条件视为复杂条件。
代码框架：
```java
import net.sf.jsqlparser.expression.*;
import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
import net.sf.jsqlparser.expression.operators.conditional.OrExpression;
import net.sf.jsqlparser.expression.operators.relational.*;
import net.sf.jsqlparser.parser.JSqlParser;
import net.sf.jsqlparser.parser.ParseException;
import net.sf.jsqlparser.schema.Column;
import net.sf.jsqlparser.statement.select.PlainSelect;
import net.sf.jsqlparser.statement.select.Select;
import net.sf.jsqlparser.util.deparser.ExpressionDeParser;
import java.util.ArrayList;
import java.util.List;
public class ConditionParser {
public static List<Condition> parseWhere(String whereSql) throws ParseException {
// 由于JSqlParser需要解析整个SQL，我们可以构造一个简单的SELECT语句
String sql = "SELECT * FROM t WHERE " + whereSql;
// 解析SQL
Select select = (Select) JSqlParserUtil.parse(sql);
PlainSelect plainSelect = (PlainSelect) select.getSelectBody();
Expression where = plainSelect.getWhere();
List<Condition> conditions = new ArrayList<>();
// 使用自定义的ExpressionVisitor来遍历where表达式
if (where != null) {
// 如果where表达式是AndExpression，说明有多个条件通过AND连接
// 我们需要分解AndExpression
splitAndConditions(where, conditions);
}
return conditions;
}
private static void splitAndConditions(Expression expression, List<Condition> conditions) {
if (expression instanceof AndExpression) {
AndExpression and = (AndExpression) expression;
splitAndConditions(and.getLeftExpression(), conditions);
splitAndConditions(and.getRightExpression(), conditions);
} else {
// 处理单个条件
Condition condition = parseCondition(expression);
if (condition != null) {
conditions.add(condition);
}
}
}
private static Condition parseCondition(Expression expression) {
Condition condition = new Condition();
// 使用自定义的visitor来处理单个条件
// 由于我们需要从表达式中提取信息，我们设计一个ConditionExpressionVisitor
ConditionExpressionVisitor visitor = new ConditionExpressionVisitor(condition);
expression.accept(visitor);
return condition;
}
// 自定义的ExpressionVisitor
private static class ConditionExpressionVisitor extends ExpressionVisitorAdapter {
private Condition condition;
public ConditionExpressionVisitor(Condition condition) {
this.condition = condition;
}
@Override
public void visit(EqualsTo expr) {
// 处理等号表达式
handleComparison(expr, expr.getLeftExpression(), expr.getRightExpression(), "=");
}
@Override
public void visit(GreaterThan expr) {
handleComparison(expr, expr.getLeftExpression(), expr.getRightExpression(), ">");
}
@Override
public void visit(MinorThan expr) {
handleComparison(expr, expr.getLeftExpression(), expr.getRightExpression(), "<");
}
@Override
public void visit(GreaterThanEquals expr) {
handleComparison(expr, expr.getLeftExpression(), expr.getRightExpression(), ">=");
}
@Override
public void visit(MinorThanEquals expr) {
handleComparison(expr, expr.getLeftExpression(), expr.getRightExpression(), "<=");
}
@Override
public void visit(LikeExpression expr) {
// Like表达式
if (expr.getLeftExpression() instanceof Column) {
Column column = (Column) expr.getLeftExpression();
condition.setTableAlias(column.getTable().getName());
condition.setFieldName(column.getColumnName());
condition.setOperator(expr.getStringExpression()); // 可能是LIKE或NOT LIKE
// 处理右表达式
Expression right = expr.getRightExpression();
if (right instanceof StringValue) {
condition.setValue(((StringValue) right).getValue());
} else {
// 如果右表达式不是简单的字符串值，则记录整个表达式的字符串
condition.setExpression(expr.toString());
condition.setFieldName(null);
}
} else {
condition.setExpression(expr.toString());
}
}
@Override
public void visit(InExpression expr) {
// In表达式
if (expr.getLeftExpression() instanceof Column) {
Column column = (Column) expr.getLeftExpression();
condition.setTableAlias(column.getTable().getName());
condition.setFieldName(column.getColumnName());
condition.setOperator("IN");
ExpressionList rightItems = (ExpressionList) expr.getRightItemsList();
List<Object> values = new ArrayList<>();
for (Expression e : rightItems.getExpressions()) {
if (e instanceof StringValue) {
values.add(((StringValue) e).getValue());
} else if (e instanceof LongValue) {
values.add(((LongValue) e).getValue());
} else if (e instanceof DoubleValue) {
values.add(((DoubleValue) e).getValue());
} else {
// 如果值不是简单类型，则整个条件视为复杂表达式
condition.setExpression(expr.toString());
condition.setFieldName(null);
return;
}
}
condition.setValue(values.toArray());
} else {
condition.setExpression(expr.toString());
}
}
// 其他表达式处理...
private void handleComparison(BinaryExpression expr, Expression left, Expression right, String operator) {
// 尝试将左表达式识别为字段
if (left instanceof Column) {
Column column = (Column) left;
condition.setTableAlias(column.getTable().getName());
condition.setFieldName(column.getColumnName());
condition.setOperator(operator);
// 处理右表达式
if (right instanceof StringValue) {
condition.setValue(((StringValue) right).getValue());
} else if (right instanceof LongValue) {
condition.setValue(((LongValue) right).getValue());
} else if (right instanceof DoubleValue) {
condition.setValue(((DoubleValue) right).getValue());
} else if (right instanceof DateValue) {
condition.setValue(((DateValue) right).getValue());
} else if (right instanceof TimestampValue) {
condition.setValue(((TimestampValue) right).getValue());
} else if (right instanceof TimeValue) {
condition.setValue(((TimeValue) right).getValue());
} else {
// 如果右表达式不是简单值，则整个表达式作为复杂表达式
condition.setExpression(expr.toString());
condition.setFieldName(null);
}
} else {
// 左表达式不是字段，则整个表达式作为复杂表达式
condition.setExpression(expr.toString());
}
}
// 对于无法识别的表达式，我们将其整个表达式字符串存入
@Override
public void visit(Expression expression) {
condition.setExpression(expression.toString());
}
}
}
```
注意：上述代码只是一个框架，实际中需要处理更多类型的表达式（如OrExpression，但我们这里假设已经通过splitAndConditions拆分，所以不会遇到OrExpression），以及处理更多类型的值（如NullValue等）。
对于复杂表达式（如A.a + B.b > 100），在handleComparison方法中，左表达式不是Column类型（而是一个加法表达式），因此会进入else分支，将整个表达式字符串存入expression字段。
使用示例：
输入： "age > 18 AND name LIKE '张%' AND department_id IN (1,2,3) AND (salary + bonus) > 10000"
输出：四个Condition对象：
1. 简单条件：age>18
2. 简单条件：name LIKE '张%'
3. 简单条件：department_id IN (1,2,3)
4. 复杂条件：expression="(salary + bonus) > 10000"
改进点：
1. 表别名和实际表名的映射：我们这里只获取了表别名（tableAlias），但实际应用中可能需要根据上下文将别名映射为实际表名。
2. 支持OR条件：目前只处理AND连接的多个条件。如果遇到OR，我们可以将整个OR表达式作为一个复杂条件（expression）存储，或者设计更复杂的结构（如树形结构）来保存条件。但根据需求，我们只需要返回一个条件列表，所以对于OR表达式，我们将其整个作为一个条件对象（复杂条件）存储。
3. 支持更多的表达式类型：如Between、IsNull等。
扩展：
我们可以修改splitAndConditions方法，使其能够处理OR表达式：如果遇到OR表达式，则将其整体作为一个条件（复杂条件）放入列表。但是，这样会丢失OR内部的细节。另一种做法是构建一个条件树，但这样会超出我们当前实体类的设计。
因此，我们决定：对于AND表达式，我们拆分；对于OR表达式，我们将其整个表达式字符串存入一个Condition对象（作为复杂条件），不拆分。
修改splitAndConditions方法：
```java
private static void splitAndConditions(Expression expression, List<Condition> conditions) {
if (expression instanceof AndExpression) {
AndExpression and = (AndExpression) expression;
splitAndConditions(and.getLeftExpression(), conditions);
splitAndConditions(and.getRightExpression(), conditions);
} else if (expression instanceof OrExpression) {
// 遇到OR表达式，将其整体作为一个复杂条件
Condition condition = new Condition();
condition.setExpression(expression.toString());
conditions.add(condition);
} else {
Condition condition = parseCondition(expression);
if (condition != null) {
conditions.add(condition);
}
}
}
```
但是，这样处理OR表达式可能不够精细。比如：条件为 (age>18 OR name='张三') AND department=1，我们希望拆分成两个条件：一个复杂条件（age>18 OR name='张三'）和一个简单条件（department=1）。但是，如果遇到嵌套的OR表达式，我们可能希望保留整个OR表达式树。由于需求是返回一个条件列表，每个条件是一个原子条件（可能是简单条件也可能是复杂条件），因此这样处理是可以接受的。
总结：我们通过JSqlParse解析where条件表达式，将其拆分为由AND连接的多个条件，并将每个条件解析为Condition对象。对于OR表达式，我们将其整体作为一个复杂条件。
注意：这个解析器可能不能覆盖所有情况，但可以覆盖大多数常见情况。如果需要更复杂的解析，可以在此基础上扩展。
相关问题：
1. 如何解析包含函数调用的条件（如：LENGTH(name) > 5）？
2. 如何处理条件中的子查询（如：age > (SELECT AVG(age) FROM employee)）？
3. 如何将表别名映射为实际的表名？
4. 如何支持动态表名（如表名也是变量）？
5. 如何扩展支持更多的SQL方言？
以上问题可以作为后续研究的点。
现在，我们给出一个完整的Condition类定义：
```java
public class Condition {
private String tableAlias; // 表别名（如果有）
private String tableName; // 表名（实际表名，如果能够获取）
private String fieldName; // 字段名（如果是简单字段条件）
private String operator; // 操作符，如 "=", ">", "<", "like", "in" 等
private Object value; // 值，可能是一个值，也可能是一个数组（对于in操作符）
private String expression; // 整个条件的表达式字符串（当无法用单个字段表示时使用，例如：A.a+B.b>100）
public boolean isSimple() {
return fieldName != null && !fieldName.isEmpty();
}
// getters and setters
public String getTableAlias() {
return tableAlias;
}
public void setTableAlias(String tableAlias) {
this.tableAlias = tableAlias;
}
public String getTableName() {
return tableName;
}
public void setTableName(String tableName) {
this.tableName = tableName;
}
public String getFieldName() {
return fieldName;
}
public void setFieldName(String fieldName) {
this.fieldName = fieldName;
}
public String getOperator() {
return operator;
}
public void setOperator(String operator) {
this.operator = operator;
}
public Object getValue() {
return value;
}
public void setValue(Object value) {
this.value = value;
}
public String getExpression() {
return expression;
}
public void setExpression(String expression) {
this.expression = expression;
}
}
```
注意：这里的tableName字段在解析时可能无法直接获取（因为解析得到的Column对象只有表别名和字段名），所以需要外部传入一个别名到实际表名的映射。如果需要，可以在解析后通过一个映射表将别名转换为表名。
另外，对于复杂表达式，我们只存储了表达式字符串，如果需要进一步解析，则需要更复杂的处理。
最后，由于JSqlParse的版本差异，请注意使用4.9版本。
</think>
### SQL条件解析工具实现方案
#### 核心实体类设计
```java
public class Condition {
private String tableName; // 表名（可空）
private String fieldName; // 字段名（可空）
private String operator; // 操作符：=, >, <, like, in等
private Object value; // 值（单值或集合）
private String expression; // 复杂表达式（如：A.a + B.b）
// 辅助字段
private boolean isComplex; // 是否复杂表达式
private ConditionType type; // 条件类型：FIELD, EXPRESSION, FUNCTION
// 枚举类型
public enum ConditionType {
FIELD, // 简单字段条件：name = '张三'
EXPRESSION, // 表达式条件：salary + bonus > 5000
FUNCTION // 函数条件：LENGTH(name) > 5
}
}
```
#### 解析工具类实现
```java
import net.sf.jsqlparser.expression.*;
import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
import net.sf.jsqlparser.expression.operators.conditional.OrExpression;
import net.sf.jsqlparser.expression.operators.relational.*;
import net.sf.jsqlparser.parser.JSqlParser;
import net.sf.jsqlparser.parser.JSqlParserUtil;
import net.sf.jsqlparser.schema.Column;
import java.util.ArrayList;
import java.util.List;
public class ConditionParser {
public List<Condition> parseWhereClause(String whereSql) {
try {
Expression expr = JSqlParserUtil.parseCondExpression(whereSql);
List<Condition> conditions = new ArrayList<>();
extractConditions(expr, conditions);
return conditions;
} catch (Exception e) {
throw new ConditionParseException("SQL条件解析失败", e);
}
}
private void extractConditions(Expression expr, List<Condition> conditions) {
if (expr instanceof AndExpression) {
// 递归处理AND连接的条件
extractConditions(((AndExpression) expr).getLeftExpression(), conditions);
extractConditions(((AndExpression) expr).getRightExpression(), conditions);
} else {
Condition condition = parseSingleCondition(expr);
if (condition != null) conditions.add(condition);
}
}
private Condition parseSingleCondition(Expression expr) {
Condition condition = new Condition();
if (expr instanceof ComparisonOperator) {
// 处理比较操作符：=, >, <, >=, <=
handleComparison((ComparisonOperator) expr, condition);
} else if (expr instanceof LikeExpression) {
// 处理LIKE表达式
handleLike((LikeExpression) expr, condition);
} else if (expr instanceof InExpression) {
// 处理IN表达式
handleIn((InExpression) expr, condition);
} else if (expr instanceof BinaryExpression) {
// 处理算术表达式
handleArithmetic((BinaryExpression) expr, condition);
} else {
// 处理其他复杂表达式
condition.setExpression(expr.toString());
condition.setType(Condition.ConditionType.EXPRESSION);
condition.setComplex(true);
}
return condition;
}
private void handleComparison(ComparisonOperator comp, Condition cond) {
cond.setOperator(comp.getStringExpression());
// 左表达式处理
if (comp.getLeftExpression() instanceof Column) {
Column col = (Column) comp.getLeftExpression();
cond.setTableName(col.getTable() != null ? col.getTable().getName() : null);
cond.setFieldName(col.getColumnName());
} else {
cond.setExpression(comp.getLeftExpression().toString());
}
// 右表达式处理
if (comp.getRightExpression() instanceof Value) {
cond.setValue(extractValue((Value) comp.getRightExpression()));
} else {
cond.setExpression(cond.getExpression() + " " + comp.getStringExpression() +
" " + comp.getRightExpression().toString());
cond.setComplex(true);
}
}
private void handleArithmetic(BinaryExpression expr, Condition cond) {
// 处理类似 A.a + B.b > 100 的表达式
cond.setExpression(String.format("%s %s %s",
expr.getLeftExpression(),
expr.getStringExpression(),
expr.getRightExpression()));
cond.setOperator(">"); // 实际使用时需要根据上下文确定
cond.setType(Condition.ConditionType.EXPRESSION);
cond.setComplex(true);
}
private Object extractValue(Value value) {
if (value instanceof StringValue) return ((StringValue) value).getValue();
if (value instanceof LongValue) return ((LongValue) value).getValue();
if (value instanceof DoubleValue) return ((DoubleValue) value).getValue();
if (value instanceof DateValue) return ((DateValue) value).getValue();
if (value instanceof TimeValue) return ((TimeValue) value).getValue();
if (value instanceof TimestampValue) return ((TimestampValue) value).getValue();
return value.toString();
}
}
```
#### 复杂表达式处理策略
对于类似 `A.a + B.b > 100` 的表达式：
1. 识别为 `ConditionType.EXPRESSION` 类型
2. 存储完整表达式：`expression = "A.a + B.b"`
3. 存储运算符：`operator = ">"`
4. 存储值：`value = 100`
5. 设置复杂标志：`isComplex = true`
#### 使用示例
```java
public static void main(String[] args) {
String whereSql = "age > 25 AND name LIKE '张%' " +
"AND department_id IN (101,102) " +
"AND (salary + bonus) > 10000";
List<Condition> conditions = new ConditionParser()
.parseWhereClause(whereSql);
conditions.forEach(cond -> {
if (cond.isComplex()) {
System.out.println("复杂条件: " + cond.getExpression() +
" " + cond.getOperator() + " " + cond.getValue());
} else {
System.out.println(cond.getTableName() + "." + cond.getFieldName() +
" " + cond.getOperator() + " " + cond.getValue());
}
});
}
```
#### 输出结果示例
```
null.age > 25
null.name LIKE 张%
null.department_id IN [101,102]
复杂条件: salary + bonus > 10000
```
#### 关键技术点
1. **表达式类型识别**：
- 简单字段条件：`column operator value`
- 表达式条件：`arithmetic_expression operator value`
- 函数条件：`function(column) operator value`
2. **操作符兼容处理**：
```mermaid
graph LR
A[比较操作符] --> B[=, >, <]
A --> C[>=, <=]
D[特殊操作符] --> E[LIKE]
D --> F[IN]
D --> G[BETWEEN]
```
3. **值类型处理**：
- 单值：字符串、数字、日期等
- 多值：IN 操作的集合值
- 表达式值：算术运算结果
4. **复杂表达式处理**：
对于 `A.a + B.b > 100` 这类条件：
- 左表达式：`A.a + B.b` ⇒ 存储为表达式
- 操作符：`>` ⇒ 存储为运算符
- 右表达式：`100` ⇒ 存储为值
#### 扩展优化建议
1. **支持表别名映射**：
```java
Map<String, String> aliasMapping = new HashMap<>();
aliasMapping.put("A", "employees");
aliasMapping.put("B", "departments");
```
2. **处理函数表达式**：
```java
if (expr instanceof Function) {
Function func = (Function) expr;
cond.setExpression(func.toString());
cond.setType(Condition.ConditionType.FUNCTION);
}
```
3. **支持嵌套条件**：
```java
if (expr instanceof Parenthesis) {
extractConditions(((Parenthesis) expr).getExpression(), conditions);
}
```
4. **值类型推断优化**：
```java
private Object smartCastValue(String strValue) {
if (strValue.matches("\\d+")) return Long.parseLong(strValue);
if (strValue.matches("\\d+\\.\\d+")) return Double.parseDouble(strValue);
if (strValue.startsWith("'") && strValue.endsWith("'"))
return strValue.substring(1, strValue.length()-1);
return strValue;
}
```
---
### 相关问题
1. 如何在解析过程中处理SQL注入风险？
2. 如何优化复杂表达式的性能分析？
3. 如何处理包含子查询的条件表达式？
4. 如何实现条件表达式的反向生成（从Condition对象生成SQL）？
5. 如何扩展支持JSON字段的查询条件解析？
最低0.47元/天 解锁文章
扫一扫
577
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
