MyBatis 源码解析：XMLScriptBuilder 工作机制

发布于：2024-09-18 ⋅ 阅读:(13) ⋅ 点赞:(0)
微信交流群：https://732903.hlcode.cn/?id=NK1fWUR

摘要

MyBatis 提供了强大的动态 SQL 功能，它通过解析 XML 配置文件中的动态 SQL 标签（如 <if>、<choose>、<foreach> 等），来实现灵活的 SQL 生成。而 XMLScriptBuilder 类则负责解析这些 XML 配置并生成最终的 SQL 语句。本文将详细解析 XMLScriptBuilder 的工作机制，并通过自定义实现来帮助您深入理解该类的功能。

前言

MyBatis 中的动态 SQL 功能是通过解析 XML 配置文件实现的。XML 文件中包含了动态 SQL 的定义，例如 <if>, <choose>, <foreach> 等标签。XMLScriptBuilder 类通过解析这些标签并生成相应的 SQL 语句，是 MyBatis 生成动态 SQL 的核心组件。本文将自定义实现一个简化版的 XMLScriptBuilder，帮助你更好地理解 MyBatis 中的动态 SQL 工作机制。

自定义实现：XMLScriptBuilder

目标与功能

我们将自定义实现一个简化版的 XMLScriptBuilder，该类能够：

  1. 解析动态 SQL XML 配置。
  2. 支持常用的 SQL 标签，如 <if>, <where>, <choose>, <foreach>。
  3. 动态生成最终的 SQL 语句。

核心流程

  1. 解析 XML 标签：通过解析 XML 文件中的 <if>, <where> 等动态标签，构建相应的 SQL 片段。
  2. 生成 SQL 语句：根据解析结果，将 SQL 片段拼接为完整的 SQL 语句。
  3. 参数绑定：支持 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);
            }
        }
    }

    /**
     * 解析 <if> 标签。
     * @param element <if> 标签元素
     */
    private void parseIf(Element element) {
        String test = element.getAttribute("test");
        if (evaluateCondition(test)) {
            sql.append(element.getTextContent()).append(" ");
        }
    }

    /**
     * 解析 <choose> 标签。
     * @param element <choose> 标签元素
     */
    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;
            }
        }

        // 处理 <otherwise> 节点
        NodeList otherwiseNodes = element.getElementsByTagName("otherwise");
        if (otherwiseNodes.getLength() > 0) {
            sql.append(otherwiseNodes.item(0).getTextContent()).append(" ");
        }
    }

    /**
     * 解析 <foreach> 标签。
     * @param element <foreach> 标签元素
     */
    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(" ");
            }
        }
    }

    /**
     * 解析 <where> 标签。
     * @param element <where> 标签元素
     */
    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 标签。
  • 处理 <if>, <choose>, <foreach>, <where> 标签：针对不同的 SQL 标签进行解析，根据条件生成 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 节点，将 <if>、<choose> 等动态 SQL 标签转换为具体的 SQL 片段。

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 方法：解析 <if> 标签，根据条件生成 IfSqlNode。
  • parseChooseNode 方法：解析 <choose> 标签，生成 ChooseSqlNode。
  • parseWhereNode 方法：解析 <where> 标签，生成 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 的内部原理！

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布