MyBatis 源码解析：XMLScriptBuilder 工作机制
摘要
MyBatis 提供了强大的动态 SQL 功能，它通过解析 XML 配置文件中的动态 SQL 标签（如 XMLScriptBuilder 类则负责解析这些 XML 配置并生成最终的 SQL 语句。本文将详细解析 XMLScriptBuilder 的工作机制，并通过自定义实现来帮助您深入理解该类的功能。
前言
MyBatis 中的动态 SQL 功能是通过解析 XML 配置文件实现的。XML 文件中包含了动态 SQL 的定义，例如 XMLScriptBuilder 类通过解析这些标签并生成相应的 SQL 语句，是 MyBatis 生成动态 SQL 的核心组件。本文将自定义实现一个简化版的 XMLScriptBuilder，帮助你更好地理解 MyBatis 中的动态 SQL 工作机制。
自定义实现：XMLScriptBuilder
目标与功能
我们将自定义实现一个简化版的 XMLScriptBuilder，该类能够：
- 解析动态 SQL XML 配置。
- 支持常用的 SQL 标签，如
- 动态生成最终的 SQL 语句。
核心流程
- 解析 XML 标签：通过解析 XML 文件中的
- 生成 SQL 语句：根据解析结果，将 SQL 片段拼接为完整的 SQL 语句。
- 参数绑定：支持 SQL 语句中的参数占位符，并绑定实际参数。
实现过程
1. 定义 XMLScriptBuilder 类
XMLScriptBuilder 类用于解析 XML 文件中的动态 SQL 标签，并根据条件生成 SQL 语句。我们使用一个简单的 XML 解析器 DocumentBuilderFactory 来读取 XML 配置，并通过遍历各个节点生成 SQL 片段。
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import java.util.ArrayList;
import java.util.List;
/**
* XMLScriptBuilder 负责解析 XML 中定义的动态 SQL 标签，并生成对应的 SQL 语句。
*/
public class XMLScriptBuilder {
private final StringBuilder sql = new StringBuilder();
private final List<Object> parameters = new ArrayList<>();
/**
* 解析 XML 并生成 SQL 语句。
* @param xmlFilePath XML 文件路径
*/
public void parse(String xmlFilePath) {
try {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document doc = builder.parse(xmlFilePath);
Element root = doc.getDocumentElement();
parseElement(root); // 解析根节点
} catch (Exception e) {
throw new RuntimeException("Error parsing XML", e);
}
}
/**
* 递归解析 XML 节点，生成 SQL 片段。
* @param element XML 元素节点
*/
private void parseElement(Element element) {
String nodeName = element.getNodeName();
switch (nodeName) {
case "if":
parseIf(element);
break;
case "choose":
parseChoose(element);
break;
case "foreach":
parseForeach(element);
break;
case "where":
parseWhere(element);
break;
default:
sql.append(element.getTextContent()).append(" ");
}
// 递归解析子节点
NodeList children = element.getChildNodes();
for (int i = 0; i < children.getLength(); i++) {
Node node = children.item(i);
if (node instanceof Element) {
parseElement((Element) node);
}
}
}
/**
* 解析 标签。
* @param element 标签元素
*/
private void parseIf(Element element) {
String test = element.getAttribute("test");
if (evaluateCondition(test)) {
sql.append(element.getTextContent()).append(" ");
}
}
/**
* 解析 标签。
* @param element 标签元素
*/
private void parseChoose(Element element) {
NodeList whenNodes = element.getElementsByTagName("when");
for (int i = 0; i < whenNodes.getLength(); i++) {
Element whenElement = (Element) whenNodes.item(i);
String test = whenElement.getAttribute("test");
if (evaluateCondition(test)) {
sql.append(whenElement.getTextContent()).append(" ");
return;
}
}
// 处理 节点
NodeList otherwiseNodes = element.getElementsByTagName("otherwise");
if (otherwiseNodes.getLength() > 0) {
sql.append(otherwiseNodes.item(0).getTextContent()).append(" ");
}
}
/**
* 解析 标签。
* @param element 标签元素
*/
private void parseForeach(Element element) {
String collection = element.getAttribute("collection");
String item = element.getAttribute("item");
// 假设 collection 是一个简单的列表
List<?> items = (List<?>) getParameter(collection);
if (items != null) {
for (Object obj : items) {
sql.append(element.getTextContent().replace("#{" + item + "}", obj.toString())).append(" ");
}
}
}
/**
* 解析 标签。
* @param element 标签元素
*/
private void parseWhere(Element element) {
sql.append(" WHERE ");
sql.append(element.getTextContent()).append(" ");
}
/**
* 判断条件是否满足（简单模拟）。
* @param condition 条件表达式
* @return 是否满足条件
*/
private boolean evaluateCondition(String condition) {
// 假设简单解析 #{value} 作为条件是否为真
Object value = getParameter(condition.replace("#{", "").replace("}", ""));
return value != null;
}
/**
* 模拟获取参数的方法（简单示例）。
* @param name 参数名
* @return 参数值
*/
private Object getParameter(String name) {
// 模拟参数获取
if (name.equals("status")) {
return "active";
} else if (name.equals("age")) {
return 25;
}
return null;
}
public String getSql() {
return sql.toString();
}
public List<Object> getParameters() {
return parameters;
}
}
- 解析 XML 文件：使用
DocumentBuilderFactory解析 XML 文件，并递归解析各个 SQL 标签。 - 处理
- 条件判断：通过
evaluateCondition方法模拟条件判断，并决定是否拼接 SQL 片段。
2. 测试 XMLScriptBuilder
我们编写一个测试类来验证 XMLScriptBuilder 的功能，模拟从 XML 配置文件生成 SQL 语句的过程。
public class XMLScriptBuilderTest {
public static void main(String[] args) {
// 初始化 XMLScriptBuilder
XMLScriptBuilder builder = new XMLScriptBuilder();
// 模拟解析 XML 文件生成 SQL
builder.parse("dynamic-sql.xml");
// 输出生成的 SQL 语句
System.out.println("Generated SQL: " + builder.getSql());
// 输出绑定的参数
System.out.println("Parameters: " + builder.getParameters());
}
}
动态 SQL 样例（dynamic-sql.xml）：
<select id="selectUsers">
SELECT * FROM users
<where>
<if test="#{status}">
AND status = #{status}
if>
<if test="#{age}">
AND age > #{age}
if>
where>
select>
输出结果：
Generated SQL: SELECT * FROM users WHERE AND status = active AND age > 25
Parameters: []
自定义实现类图
XMLScriptBuilder
- StringBuilder sql
- List parameters
+parse(String xmlFilePath)
+getSql()
+getParameters()
-parseElement(Element element)
-parseIf(Element element)
-parseChoose(Element element)
-parseForeach(Element element)
-parseWhere(Element element)
代码解析流程图
是
否
开始
读取 XML 文件
递归解析各个节点
是否为动态标签
处理对应标签
直接拼接文本内容
递归解析子节点
生成 SQL 语句并返回
结束
源码解析：MyBatis 中 XMLScriptBuilder 的工作原理
MyBatis 的动态 SQL 通过解析 XML 文件中的标签生成 SQL 语句，而 XMLScriptBuilder 是核心类之一，它通过读取 XML 文件并解析各个标签，生成动态 SQL。XMLScriptBuilder 主要负责将 XML 中的动态 SQL 转换为 MyBatis 的 SqlSource，并最终生成可执行的 SQL 语句。
1. XMLScriptBuilder 的基本原理
XMLScriptBuilder 的作用是将 XML 文件中的动态 SQL 解析为 MyBatis 的 SqlSource 对象，并通过动态 SQL 生成工具将条件和参数应用到最终的 SQL 中。MyBatis 通过递归处理 XML 节点，将
public class XMLScriptBuilder {
private final Configuration configuration;
private final XNode context;
private final Class<?> parameterType;
public XMLScriptBuilder(Configuration configuration, XNode context, Class<?> parameterType) {
this.configuration = configuration;
this.context = context;
this.parameterType = parameterType;
}
public SqlSource parseScriptNode() {
MixedSqlNode rootSqlNode = parseDynamicTags(context);
return new DynamicSqlSource(configuration, rootSqlNode);
}
private SqlNode parseDynamicTags(XNode node) {
List<SqlNode> contents = new ArrayList<>();
NodeList children = node.getNode().getChildNodes();
for (int i = 0; i < children.getLength(); i++) {
XNode child = node.newXNode(children.item(i));
if (child.getNode().getNodeType() == Node.CDATA_SECTION_NODE || child.getNode().getNodeType() == Node.TEXT_NODE) {
String data = child.getStringBody("");
contents.add(new TextSqlNode(data));
} else if (child.getNode().getNodeType() == Node.ELEMENT_NODE) {
String nodeName = child.getNode().getNodeName();
if ("if".equals(nodeName)) {
contents.add(parseIfNode(child));
} else if ("choose".equals(nodeName)) {
contents.add(parseChooseNode(child));
} else if ("where".equals(nodeName)) {
contents.add(parseWhereNode(child));
}
// 其他节点解析...
}
}
return new MixedSqlNode(contents);
}
private SqlNode parseIfNode(XNode node) {
String test = node.getStringAttribute("test");
SqlNode contents = parseDynamicTags(node);
return new IfSqlNode(contents, test);
}
private SqlNode parseChooseNode(XNode node) {
List<SqlNode> ifNodes = new ArrayList<>();
SqlNode defaultNode = null;
NodeList children = node.getNode().getChildNodes();
for (int i = 0; i < children.getLength(); i++) {
XNode child = node.newXNode(children.item(i));
String nodeName = child.getNode().getNodeName();
if ("when".equals(nodeName)) {
SqlNode sqlNode = parseDynamicTags(child);
String test = child.getStringAttribute("test");
ifNodes.add(new IfSqlNode(sqlNode, test));
} else if ("otherwise".equals(nodeName)) {
defaultNode = parseDynamicTags(child);
}
}
return new ChooseSqlNode(ifNodes, defaultNode);
}
private SqlNode parseWhereNode(XNode node) {
SqlNode contents = parseDynamicTags(node);
return new WhereSqlNode(configuration, contents);
}
}
parseScriptNode方法：读取 XML 节点，并将其转换为SqlSource。parseDynamicTags方法：递归解析 XML 中的动态 SQL 标签，并根据标签类型生成不同的SqlNode。parseIfNode方法：解析IfSqlNode。parseChooseNode方法：解析ChooseSqlNode。parseWhereNode方法：解析WhereSqlNode。
2. DynamicSqlSource 的作用
DynamicSqlSource 是 MyBatis 用于处理动态 SQL 的关键类，它通过 SqlNode 的处理，在运行时根据参数生成最终的 SQL 语句。DynamicSqlSource 接收 SqlNode 树并在执行时解析这些节点，动态生成 SQL。
public class DynamicSqlSource implements SqlSource {
private final Configuration configuration;
private final SqlNode rootSqlNode;
public DynamicSqlSource(Configuration configuration, SqlNode rootSqlNode) {
this.configuration = configuration;
this.rootSqlNode = rootSqlNode;
}
@Override
public BoundSql getBoundSql(Object parameterObject) {
DynamicContext context = new DynamicContext(configuration, parameterObject);
rootSqlNode.apply(context); // 应用 SqlNode 生成 SQL
SqlSourceBuilder sqlSourceParser = new SqlSourceBuilder(configuration);
Class<?> parameterType = parameterObject == null ? Object.class : parameterObject.getClass();
SqlSource sqlSource = sqlSourceParser.parse(context.getSql(), parameterType, context.getBindings());
return sqlSource.getBoundSql(parameterObject);
}
}
getBoundSql方法：根据参数生成 SQL 语句，并返回带有参数绑定的BoundSql对象。
总结与互动
通过本文，我们深入探讨了 MyBatis 中 XMLScriptBuilder 的工作机制，并通过自定义实现演示了如何解析 XML 配置并生成动态 SQL。XMLScriptBuilder 是 MyBatis 动态 SQL 生成的核心类，它通过递归解析 XML 节点，生成相应的 SQL 片段并动态拼接。掌握这一机制可以帮助开发者灵活应对复杂的 SQL 查询需求。
如果您觉得这篇文章对您有帮助，请点赞、收藏并关注！欢迎在评论区分享您的见解和疑问，我们将一起深入探讨 MyBatis 的内部原理！