MyBatis 源码解析：XMLScriptBuilder 工作机制

最新推荐文章于 2024-11-11 16:57:31 发布
最新推荐文章于 2024-11-11 16:57:31 发布
阅读量1.5k 收藏 13
点赞数 9
分类专栏： MyBatis 源码解读 文章标签： mybatis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40254606/article/details/142034839
版权

摘要

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 的内部原理！

捕风捉你
关注
专栏目录
Mybatis3源码分析(05)-加载Configuration-加载MappedStatement
ashan
12-18 1万+
XMLStatementBuilder.parseStatementNode()方法 resultMap元素的解析已经分析完毕。与resultMap不一样，XmlMapperBuilder在解析select/update/insert/delete的元素时会创建一个XMLStatementBuilder对象，解析的工作交由其方法parseStatementNode()方法完成。private v
MyBatis（三） xml文件解析流程 动态SQL解析
自由
05-23 5945
1.MyBatis将整个系统串联起来的就是Configure对象这个需要牢记。在前面MyBatis xml文件解析流程(二) Mapper解析中介绍了Mapper的解析入口，以及Mapper文件中各个节点的解析方法。里面有几个类需要总结下 > 1.**BaseBuilder:**作为其他Builder类的基类 2.**XMLConfigBuilder:**在Configuration解析时介绍过，主
mybatis XMLScriptBuilder
master_boy的博客
04-23 554
解析XMLScriptBuilder XMLScriptBuilder 解析sql语句里面的标签 XMLScriptBuilder内部逻辑主入口，最终返回对MixedSqlNode的封装，根据isDynamic决定具体SqlSource的实现类。 MixedSqlNode的生成逻辑 我去，node.newXNode()里面还有解析逻辑，调试才看出来，怎么多了一次${}解析 ...
Mybatis源码研究之XMLScriptBuilder
夫礼者的专栏
10-19 1472
这个XMLScriptBuilder类才是真正在背后解析用来解析mapper文件中的每个<select/>,<insert/>,<update/>,<delete/>节点内的SQL字符串的(其中可能包含动态SQL部分,诸如<if/>,<where/>等)
mybatis源码解读(五)：XMLScriptBuilder详解-各种SQLNODE
qq_41063182的博客
06-21 2021
功能 动态 SQL 是 MyBatis 的强大特性之一。如果你使用过 JDBC 或其它类似的框架，你应该能理解根据不同条件拼接 SQL 语句有多痛苦，例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。利用动态 SQL，可以彻底摆脱这种痛苦，诸如 foreach、set这些标签，在我们写sql的时候会提供很大的方便。 mybatis 解析动态sql的这种能力是由 XMLScriptBuilder 类完成的。 第一步：解析sql，区别当前的sql是静态文本sql还是带标签的动态sql，
手敲Mybatis(七)-细化xml语句解析和构建
dfBeautifulLive的博客
03-11 803
为什么这一章节要细分之前的解析xml处理逻辑，原因是违反了单一原则设计，职责并不明确，将Sql语句、参数、返回值等等一切都进行解析，那么这种的需要拆开，为了后面可维护可扩展，例如Mapper级别的有mapper解析，Sql语句有Sql语句的解析，因为Sql也是脚本，需要对脚本进行动态处理，也会延伸一些脚本类来处理对应语句图一，全部职责混到一个类里一个方法里。
MyBatis 源码解析：通过源码深入理解 SQL 的执行过程 - GitChat
05-13
MyBatis 源码解析：通过源码深入理解 SQL 的执行过程 抓下来打包成了HTML文件, 方便离线观看
Mybatis源码解析之流程解析：初始化阶段
12-22
源码解析地址 https://github.com/erlieStar/mybatis-3 debug源码用项目 https://github.com/erlieStar/mybatis-examples 介绍 Mybatis的核心流程主要分为两大阶段 初始化阶段：读取XML配置文件和注解中的配置信息，...
MyBatis源码解析
12-18
MyBatis源码解析
mybatis-3.5.4:mybatis源码分析
03-24
MyBatis SQL Mapper Java框架 MyBatis SQL映射器框架使将关系数据库与面向对象的应用程序一起使用变得更加容易。 MyBatis使用XML描述符或注释将对象与存储过程或SQL语句耦合。 相对于对象关系映射工具，简单性是...
MyBatis源码分析.pdf
05-23
MyBatis是一款流行的Java持久层框架，提供了强大的数据库访问能力，本文将对MyBatis的源码进行深入分析，从而帮助读者更好地理解MyBatis的工作机理。 1. MyBatis入门 MyBatis是一款基于Java的持久层框架，提供了...
mybatis学习之路----#{}, ${}两种传参数方式的区别--附源码解读
小菜鸟的专栏
09-09 4851
点滴记载，点滴进步，愿自己更上一层楼。
Mybatis原理分析--动态生成Sql原理
FeelTouch Labs
03-02 1475
好文：https://www.jianshu.com/p/ec40a82cae28 本文将带你分析Mybatis是如何动态生成SQL。 首先，会根据源码分析框架初始化时xml文件的加载、解析、缓存过程。着重介绍 xml的解析过程 和 使用解析的结果，最后列举实例和对照源码DeBug分析：当DAO接口调用时标签的解析、参数的创建、SQL的生成过程，并总结整个流程。 数据的处理 My...
MyBatis源码分析之Script用法详解
u012734441的专栏
01-22 1万+
MyBatis源码分析之在上一篇文章中讲到MyBatis的#{paras}和${paras}用法，在里面提到在解析sql组装成SqlSource对象时，会判断当前sql是否是动态类型，然后里面有一个对sql中是否含有**1. 与之前相同，讲到这里还是先讲一下@ResultMap(&amp;quot;BaseResultMap&amp;quot;) @Select(&amp;quot;&amp;amp;lt;script&amp;amp;gt;&amp;quo
Mybatis增强型注解简化SQL语句(一)
热门推荐
ExcellentYuXiao的专栏
11-21 2万+
Mybatis增强型注解简化SQL语句
MyBatis源码（四）之mapper文件解析和动态Sql解析启动阶段
mayongzhan_csdn的专栏
11-17 791
上篇博文介绍了Mybatis 执行流程全貌 非常重要。本博文mybatis启动过程是如何解析配置文件的。 这还得从Spring的配置文件中SqlSessionFactoryBean 创建SqlsessionFactory说起。该Bean实现了InitializingBean【又是一个Spring的拓展点】在Spring实例化设置和属性之后会触发afterPropertySet的调用。 每个mapp
MybatisPlus的LambdaQueryWrapper用法
2301_79693537的博客
08-21 5498
【代码】MybatisPlus的LambdaQueryWrapper用法。
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
最新发布
mm
11-11 290
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

捕风捉你

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值